Sunbelt Computer Software

PL/B Language Development and Support

algorithms-python/ciphers/caesar_cipher.py at master · zinating/algorithms-python · GitHub

239 lines (181 loc) · 7.67 KB

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

from __future__ import annotations

from string import ascii_letters

def encrypt(input_string: str, key: int, alphabet: str | None = None) -> str:

"""

encrypt

=======

Encodes a given string with the caesar cipher and returns the encoded

message

Parameters:

-----------

* input_string: the plain-text that needs to be encoded

* key: the number of letters to shift the message by

Optional:

* alphabet (None): the alphabet used to encode the cipher, if not

specified, the standard english alphabet with upper and lowercase

letters is used

Returns:

* A string containing the encoded cipher-text

More on the caesar cipher

=========================

The caesar cipher is named after Julius Caesar who used it when sending

secret military messages to his troops. This is a simple substitution cipher

where every character in the plain-text is shifted by a certain number known

as the "key" or "shift".

Example:

Say we have the following message:

"Hello, captain"

And our alphabet is made up of lower and uppercase letters:

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

And our shift is "2"

We can then encode the message, one letter at a time. "H" would become "J",

since "J" is two letters away, and so on. If the shift is ever two large, or

our letter is at the end of the alphabet, we just start at the beginning

("Z" would shift to "a" then "b" and so on).

Our final message would be "Jgnnq, ecrvckp"

Further reading

===============

* https://en.m.wikipedia.org/wiki/Caesar_cipher

Doctests

========

>>> encrypt('The quick brown fox jumps over the lazy dog', 8)

'bpm yCqks jzwEv nwF rCuxA wDmz Bpm tiHG lwo'

>>> encrypt('A very large key', 8000)

's nWjq dSjYW cWq'

>>> encrypt('a lowercase alphabet', 5, 'abcdefghijklmnopqrstuvwxyz')

'f qtbjwhfxj fqumfgjy'

"""

# Set default alphabet to lower and upper case english chars

alpha = alphabet or ascii_letters

# The final result string

result = ""

for character in input_string:

if character not in alpha:

# Append without encryption if character is not in the alphabet

result += character

else:

# Get the index of the new key and make sure it isn't too large

new_key = (alpha.index(character) + key) % len(alpha)

# Append the encoded character to the alphabet

result += alpha[new_key]

return result

def decrypt(input_string: str, key: int, alphabet: str | None = None) -> str:

"""

decrypt

=======

Decodes a given string of cipher-text and returns the decoded plain-text

Parameters:

-----------

* input_string: the cipher-text that needs to be decoded

* key: the number of letters to shift the message backwards by to decode

Optional:

* alphabet (None): the alphabet used to decode the cipher, if not

specified, the standard english alphabet with upper and lowercase

letters is used

Returns:

* A string containing the decoded plain-text

More on the caesar cipher

=========================

The caesar cipher is named after Julius Caesar who used it when sending

secret military messages to his troops. This is a simple substitution cipher

where very character in the plain-text is shifted by a certain number known

as the "key" or "shift". Please keep in mind, here we will be focused on

decryption.

Example:

Say we have the following cipher-text:

"Jgnnq, ecrvckp"

And our alphabet is made up of lower and uppercase letters:

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

And our shift is "2"

To decode the message, we would do the same thing as encoding, but in

reverse. The first letter, "J" would become "H" (remember: we are decoding)

because "H" is two letters in reverse (to the left) of "J". We would

continue doing this. A letter like "a" would shift back to the end of

the alphabet, and would become "Z" or "Y" and so on.

Our final message would be "Hello, captain"

Further reading

===============

* https://en.m.wikipedia.org/wiki/Caesar_cipher

Doctests

========

>>> decrypt('bpm yCqks jzwEv nwF rCuxA wDmz Bpm tiHG lwo', 8)

'The quick brown fox jumps over the lazy dog'

>>> decrypt('s nWjq dSjYW cWq', 8000)

'A very large key'

>>> decrypt('f qtbjwhfxj fqumfgjy', 5, 'abcdefghijklmnopqrstuvwxyz')

'a lowercase alphabet'

"""

# Turn on decode mode by making the key negative

key *= -1

return encrypt(input_string, key, alphabet)

def brute_force(input_string: str, alphabet: str | None = None) -> dict[int, str]:

"""

brute_force

===========

Returns all the possible combinations of keys and the decoded strings in the

form of a dictionary

Parameters:

-----------

* input_string: the cipher-text that needs to be used during brute-force

Optional:

* alphabet: (None): the alphabet used to decode the cipher, if not

specified, the standard english alphabet with upper and lowercase

letters is used

More about brute force

======================

Brute force is when a person intercepts a message or password, not knowing

the key and tries every single combination. This is easy with the caesar

cipher since there are only all the letters in the alphabet. The more

complex the cipher, the larger amount of time it will take to do brute force

Ex:

Say we have a 5 letter alphabet (abcde), for simplicity and we intercepted the

following message:

"dbc"

we could then just write out every combination:

ecd... and so on, until we reach a combination that makes sense:

"cab"

Further reading

===============

* https://en.wikipedia.org/wiki/Brute_force

Doctests

========

>>> brute_force("jFyuMy xIH'N vLONy zILwy Gy!")[20]

"Please don't brute force me!"

>>> brute_force(1)

Traceback (most recent call last):

TypeError: 'int' object is not iterable

"""

# Set default alphabet to lower and upper case english chars

alpha = alphabet or ascii_letters

# To store data on all the combinations

brute_force_data = {}

# Cycle through each combination

for key in range(1, len(alpha) + 1):

# Decrypt the message and store the result in the data

brute_force_data[key] = decrypt(input_string, key, alpha)

return brute_force_data

if __name__ == "__main__":

while True:

print(f'\n{"-" * 10}\n Menu\n{"-" * 10}')

print(*["1.Encrypt", "2.Decrypt", "3.BruteForce", "4.Quit"], sep="\n")

# get user input

choice = input("\nWhat would you like to do?: ").strip() or "4"

# run functions based on what the user chose

if choice not in ("1", "2", "3", "4"):

print("Invalid choice, please enter a valid choice")

elif choice == "1":

input_string = input("Please enter the string to be encrypted: ")

key = int(input("Please enter off-set: ").strip())

print(encrypt(input_string, key))

elif choice == "2":

input_string = input("Please enter the string to be decrypted: ")

key = int(input("Please enter off-set: ").strip())

print(decrypt(input_string, key))

elif choice == "3":

input_string = input("Please enter the string to be decrypted: ")

brute_force_data = brute_force(input_string)

for key, value in brute_force_data.items():

print(f"Key: {key} | Message: {value}")

elif choice == "4":

print("Goodbye.")

break