Review¶
- Rules of Programming
- Cryptography
Cryptography¶
- The study of using secret codes
- Encryption is a method of scrambling input text using a cipher key to create cipher text
In [ ]:
alphabet = "abcdefghijklmnopqrstuvwxyz"
input_text = "twas brillig in the slithy tove"
cipher_key = 15
cipher_text = ""
for character in input_text:
character_position = alphabet.find(character)
new_position = character_position + cipher_key
if new_position >= len(alphabet):
new_position = new_position - len(alphabet)
new_letter = alphabet[new_position]
cipher_text = cipher_text + new_letter
print(cipher_text)
Variables¶
- Variables are like containers. They have a label (a variable name) and can hold a value.
Here is a variable that contains a string.
In [ ]:
jabberwocky = "Did gyre and gimble in the wabe:"
print(jabberwocky)
Indexing¶
- Individual characters in strings can be identified using an index.
- This is done by adding square brackets to the end of a string (value or variable)
- Indexes start from 0 (It's a computer science thing.)
In [ ]:
input_text = "all mimsy were the borogoves"
input_text[0] # This should be a
cipher_key = 15
alphabet = "abcdefghijklmnopqrstuvwxyz"
print(alphabet[0 + cipher_key])
print(alphabet[1 + cipher_key])
print(alphabet[2 + cipher_key])
print(alphabet[3 + cipher_key])
Looking Up a Character in a String¶
- Python is an object-oriented language. This means we can ask questions of objects.
- Strings are objects.
- Ask a string to find where a letter occurs.
.find(letter)
In [ ]:
alphabet = "abcdefghijklmnopqrstuvwxyz"
input_text = "and the mome raths outgrabe"
cipher_key = 3
character = input_text[0]
character_position = alphabet.find(character)
new_position = character_position + cipher_key
new_letter = alphabet[new_position]
print(new_letter)
character = input_text[1]
character_position = alphabet.find(character)
new_position = character_position + cipher_key
new_letter = alphabet[new_position]
print(new_letter)
character = input_text[2]
character_position = alphabet.find(character)
new_position = character_position + cipher_key
new_letter = alphabet[new_position]
print(new_letter)
character = input_text[3]
character_position = alphabet.find(character)
new_position = character_position + cipher_key
new_letter = alphabet[new_position]
print(new_letter)
String Concatenation¶
- Two strings can be added together using the + operator. This is called string concatenation.
- Python concatenates the strings exactly. It doesn't add extra spaces.
In [ ]:
print("Beware the Jabberwock," + " " + "my son!")
spam = "email"
eggs = "bacon"
print (spam + eggs)
Decision Structures¶
So far, we've been writing programs that do the same thing repeatedly. If order for a program to be more reactive, we need a way for it to make decisions. Depending on whether something is the case, it takes one action or another.
In [ ]:
temperature = 10
if (temperature < 5):
print("Wear a coat.")
Boolean Expressions and Relational Operators¶
We can use decision structures to adjust string indexes that are too big or too small.
if the index is too big then ...
In [ ]:
alphabet = "abcdefghijklmnopqrstuvwxyz "
index = 25
print(len(alphabet))
print(str(index) + ": " + str(alphabet[index]))
index = index + 1
print(str(index) + ": " + str(alphabet[index]))
index = index + 1
# print(alphabet[27])
if index >= len(alphabet):
index = index - len(alphabet)
print(str(index) + ": " + str(alphabet[index]))
index = index + 1
if index >= len(alphabet):
index = index - len(alphabet)
print(str(index) + ": " + str(alphabet[index]))
Repetition Structures¶
So far, we have been repeating actions by repeating lines of code.
If we are going to encrypt longer strings, we need to make this easier.
This is where repetition structures come in.
In [ ]:
for number in [1, 2, 3, 4]:
print(number)
for character in "The jaws that bite, the claws that catch!":
print(character)
More Characters¶
So far, the program can only handle lowercase characters. We can expand the set of characters to include:
- Uppercase
- Digits
- Punctuation
But we'll probably run into something that's not yet in our alphabet.
How can we fix this?
In [1]:
alphabet = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
input_text = "$@Twas brillig in the slithy tove"
cipher_key = 1
cipher_text = ""
for character in input_text:
if character in alphabet:
character_position = alphabet.find(character)
new_position = character_position + cipher_key
if new_position >= len(alphabet):
new_position = new_position - len(alphabet)
new_letter = alphabet[new_position]
cipher_text = cipher_text + new_letter
else:
cipher_text = cipher_text + character
print(cipher_text)
Input¶
- The current program requires the input string and cipher key to be assigned to a variable.
- This is called "hard coding". It's considered to be a bad practice, because computer programs are fragile. The program needs to be changed to handle different inputs.
Let's change this.
Let's start with the last one.
- variable = input(prompt) or variable = raw_input(prompt)
- input() is a function, like print()
- prompt is the string to be displayed on the screen
- variable holds the data input from the keyboard
In [15]:
sentence = raw_input("Type in a sentence: ")
number = int(raw_input("Enter a number between 0 and 25: "))
In [ ]:
alphabet = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
input_text = raw_input("Enter your input text: ")
cipher_key = raw_input("Enter a number between 0 and " + str(len(alphabet)) + ": ")
cipher_key = int(cipher_key)
cipher_text = ""
for character in input_text:
if character in alphabet:
character_position = alphabet.find(character)
new_position = character_position + cipher_key
if new_position >= len(alphabet):
new_position = new_position - len(alphabet)
new_letter = alphabet[new_position]
cipher_text = cipher_text + new_letter
else:
cipher_text = cipher_text + character
print(cipher_text)
Decryption¶
Decrypting the Caesar cipher is the same as the encryption process but in reverse.
Let's try doing this on paper.
Exchange a cipher text and cipher key with someone else. Decrypt the cipher text.
In [ ]:
alphabet = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
input_text = raw_input("Enter your input text: ")
cipher_key = raw_input("Enter a number between 0 and " + str(len(alphabet)) + ": ")
cipher_key = int(cipher_key)
cipher_text = ""
for character in input_text:
if character in alphabet:
character_position = alphabet.find(character)
new_position = character_position + cipher_key
if new_position >= len(alphabet):
new_position = new_position - len(alphabet)
new_letter = alphabet[new_position]
cipher_text = cipher_text + new_letter
else:
cipher_text = cipher_text + character
print(cipher_text)
Decrypting Using the Program¶
In [22]:
alphabet = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
direction = raw_input("Encrypt or decrypt? (d/e): ")
input_text = raw_input("Enter your input text: ")
cipher_key = raw_input("Enter a number between 0 and " + str(len(alphabet)) + ": ")
cipher_key = int(cipher_key)
if direction == "d":
cipher_key = -cipher_key
cipher_text = ""
for character in input_text:
if character in alphabet:
character_position = alphabet.find(character)
new_position = character_position + cipher_key
if new_position >= len(alphabet):
new_position = new_position - len(alphabet)
new_letter = alphabet[new_position]
cipher_text = cipher_text + new_letter
else:
cipher_text = cipher_text + character
print(cipher_text)
Breaking an Encryption¶
Modern methods of breaking an encryption are based on statistical techniques.
- For example, the frequency of characters (e.g. E and T are most common) or words ("the," "be," "and")
But the Caesar cipher is a pretty simple linear cipher. We can try using "brute force"
- A brute force technique involves trying every cipher key.
Let's write a breaking program using the existing code as a starting point.
In [ ]:
Functions¶
- A function is a way to group together lines of code.
- Useful for doing the same task in different places.
- Makes the code easier to read.
- Avoids repeating code.
def function_name():
statement
statement
statement- A function has the following parts.
- A name
- Parameters (inputs)
- Optionally, return values (outputs)
In [24]:
# This program demonstrates a function
# First we define a function named "message"
def message():
print("I am Arthur")
print ("King of the Britons")
# Call the message function
message()
In [28]:
def holy_hand_grenade(tick):
output = ""
if tick == 1:
output = "Keepest going"
elif tick == 2:
output = "Nor either count thou two, excepting that thou then proceed to three"
elif tick == 3:
output = "Lobbest thou thy Holy Hand Grenade of Antioch towards thou foe"
elif tick == 4:
output = "Four shalt thou not count"
elif tick == 5:
output = "Five is right out"
return output
holy_hand_grenade(3)
Out[28]:
Let's Practice¶
In [32]:
# Turn this code into a function
# Input? temperature
# Processing? decision
# Output? string
input_temp = 10
def what_to_wear(temperature):
output = ""
if (temperature < 15):
output = "Wear a coat."
return output
attire = what_to_wear(input_temp)
print(attire)
Putting It Together¶
- Let's put our decryption code into a function
- Call it repeatedly with possible cipher keys
In [2]:
alphabet = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
input_string = raw_input("Enter your input text: ")
def decrypt(input_text, cipher_key):
cipher_text = ""
for character in input_text:
if character in alphabet:
character_position = alphabet.find(character)
new_position = character_position - cipher_key
if new_position >= len(alphabet):
new_position = new_position - len(alphabet)
new_letter = alphabet[new_position]
cipher_text = cipher_text + new_letter
else:
cipher_text = cipher_text + character
return cipher_text
for key in range(len(alphabet)):
possible_string = decrypt(input_string, key)
print(possible_string)
In [39]:
for num in range(10):
print(num)
Last Words on Cryptography¶
- Cryptography is like a dance of "yes" and "no."
- As encryption algorithms get better, so do the algorithms to break them.
- But you've learned a lot about basic principles
- Improvements are based on increasing the number of combinations to try and/or changing the frequency of letters/words in the output
Improvements on Caesar Cipher¶
- Polyalphabetic ciphers encode the same character in a different ways.
- In our code, it would be like using multiple alphabets and cycling through them
- Encryption keys can be longer
- A key can point to a cycle of keys
- Non-linear ciphers group code into blocks and rotated before encryption
- Four characters becomes a 2x2 block
- Can be repeated
Computational Thinking¶
The ability to say "I can write a computer program to solve that problem."