https://projecteuler.net/problem=59
Each character on a computer is assigned a unique code and the preferred standard is ASCII (American Standard Code for Information Interchange). For example, uppercase A = 65, asterisk (*) = 42, and lowercase k = 107.
A modern encryption method is to take a text file, convert the bytes to ASCII, then XOR each byte with a given value, taken from a secret key. The advantage with the XOR function is that using the same encryption key on the cipher text, restores the plain text; for example, 65 XOR 42 = 107, then 107 XOR 42 = 65.
For unbreakable encryption, the key is the same length as the plain text message, and the key is made up of random bytes. The user would keep the encrypted message and the encryption key in different locations, and without both "halves", it is impossible to decrypt the message.
Unfortunately, this method is impractical for most users, so the modified method is to use a password as a key. If the password is shorter than the message, which is likely, the key is repeated cyclically throughout the message. The balance for this method is using a sufficiently long password key for security, but short enough to be memorable.
Your task has been made easy, as the encryption key consists of three lower case characters. Using cipher.txt (in this directory), a file containing the encrypted ASCII codes, and the knowledge that the plain text must contain common English words, decrypt the message and find the sum of the ASCII values in the original text.
The following cell shows examples of how to perform XOR in Python and how to go back and forth between characters and integers:
In [ ]:
assert 65 ^ 42 == 107
assert 107 ^ 42 == 65
assert ord('a') == 97
assert chr(97) == 'a'
Certain functions in the itertools module may be useful for computing permutations:
In [17]:
from itertools import *
In [1]:
encrypted=open("cipher.txt","r")
message=encrypted.read().split(",")
encrypted.close()
In [36]:
def key_cycler(cycles):
for n in range(cycles): #will repeat key for every index of message this won't translate very last character since length in 400.33
u1=key[0]^int(message[3*n])
unencrypted.insert(3*n,u1) #inserts into corresponding spot in unencrypted list
u2=key[1]^int(message[(3*n)+1])
unencrypted.insert((3*n)+1,u2)
u3=key[2]^int(message[(3*n)+2]) #XOR each message interger against its corresponding key value
unencrypted.insert((3*n)+2,u3)
The below is what I think should work however it takes a while to run so I end up interrupting kernel so I don't bog down system. Finding all the values of the key doesn't take long so it must be an error in my method of cycling through the message with each key value that takes too much time. I have been trying to figure out how to possibly use cycle() or repeat() function to run key against encrypted message. I am going to submit now but still attempt to fix problem then resubmit
In [ ]:
length=len(message)
print(length)
repeat_times=1201/3 #gives me estimate of number of times to cycle through
print(repeat_times)
for a in range(97,123): #the values of lower case letters
for b in range(97,123):
for c in range(97,123):
key=[a,b,c] #iterates through all key values for 3 lowercase letters
unencrypted=[]
key_cycler(400) #cycles key through message and puts into unencrypted
english=[]
for i in unencrypted:
e=chr(i)
english.append(e) #converts from ACSII to character string
english="".join(english) #converts to whole string
if " the " in english: #checks to see if " the " is in message . Like suggested in the Gitter Chat I am assuming this won't appear if not correct key
print(english) # if it does appear for incorrect keys then I can remove the break and print all instance where
print(key) #" the " appears and then select which key produces a completely legible message
break #prints the key that made instance of message and then breaks the for loop so only first message with
# instances of " the " occuring is printed
Test of lower half of code by using a set key
In [ ]:
key=[97,97,97] #iterates through all key values for 3 lowercase letters
unencrypted=[]
key_cycler(400) #cycles key through message and puts into unencrypted
english=[]
for i in unencrypted:
e=chr(i)
english.append(e) #converts from ACSII to character string
english="".join(english) #converts to whole string
print(english)
However this still takes too long to finish so must be an erro in the key_cycler function
In [ ]:
# This cell will be used for grading, leave it at the end of the notebook.