logger = logging.getLogger(__name__)
logger.addHandler(logging.FileHandler('cipher.log'))
-# logging.basicConfig(filename='cipher.log',level=logging.WARNING)
-logger.setLevel(logging.INFO)
+logger.setLevel(logging.WARNING)
+#logger.setLevel(logging.INFO)
english_counts = collections.defaultdict(int)
with open('count_1l.txt', 'r') as f:
english_counts[letter] = int(count)
normalised_english_counts = norms.normalise(english_counts)
+keywords = []
+with open('words.txt', 'r') as f:
+ keywords = [line.rstrip() for line in f]
+
modular_division_table = [[0]*26 for x in range(26)]
for a in range(26):
c = (a * b) % 26
modular_division_table[b][c] = a
+modular_division_table_one_based = [[0]*27 for x in range(27)]
+for a in range(27):
+ for b in range(27):
+ c = ((a * b)-1) % 26 + 1
+ modular_division_table_one_based[b][c] = a
+
+
def sanitise(text):
"""Remove all non-alphabetic characters and convert the text to lowercase
return ''.join(sanitised)
def ngrams(text, n):
+ """Returns all n-grams of a text
+
+ >>> ngrams(sanitise('the quick brown fox'), 2)
+ [('t', 'h'), ('h', 'e'), ('e', 'q'), ('q', 'u'), ('u', 'i'), ('i', 'c'), ('c', 'k'), ('k', 'b'), ('b', 'r'), ('r', 'o'), ('o', 'w'), ('w', 'n'), ('n', 'f'), ('f', 'o'), ('o', 'x')]
+ >>> ngrams(sanitise('the quick brown fox'), 4)
+ [('t', 'h', 'e', 'q'), ('h', 'e', 'q', 'u'), ('e', 'q', 'u', 'i'), ('q', 'u', 'i', 'c'), ('u', 'i', 'c', 'k'), ('i', 'c', 'k', 'b'), ('c', 'k', 'b', 'r'), ('k', 'b', 'r', 'o'), ('b', 'r', 'o', 'w'), ('r', 'o', 'w', 'n'), ('o', 'w', 'n', 'f'), ('w', 'n', 'f', 'o'), ('n', 'f', 'o', 'x')]
+ """
return [tuple(text[i:i+n]) for i in range(len(text)-n+1)]
def letter_frequencies(text):
counts[c] += 1
return counts
+def deduplicate(text):
+ return list(collections.OrderedDict.fromkeys(text))
+
+
+
def caesar_encipher_letter(letter, shift):
"""Encipher a letter, given a shift amount
"""
return caesar_encipher(message, -shift)
-def affine_encipher_letter(letter, multiplier, adder, multiply_then_add=True):
+def affine_encipher_letter(letter, multiplier=1, adder=0, one_based=True):
+ """Encipher a letter, given a multiplier and adder
+
+ >>> ''.join([affine_encipher_letter(l, 3, 5, True) for l in string.ascii_uppercase])
+ 'HKNQTWZCFILORUXADGJMPSVYBE'
+ >>> ''.join([affine_encipher_letter(l, 3, 5, False) for l in string.ascii_uppercase])
+ 'FILORUXADGJMPSVYBEHKNQTWZC'
+ """
if letter in string.ascii_letters:
if letter in string.ascii_uppercase:
alphabet_start = ord('A')
else:
alphabet_start = ord('a')
letter_number = ord(letter) - alphabet_start
+ if one_based: letter_number += 1
+ raw_cipher_number = (letter_number * multiplier + adder)
cipher_number = 0
- if multiply_then_add:
- cipher_number = (letter_number * multiplier + adder) % 26
+ if one_based:
+ cipher_number = (raw_cipher_number - 1) % 26
else:
- cipher_number = ((letter_number + adder) * multiplier) % 26
+ cipher_number = raw_cipher_number % 26
return chr(cipher_number + alphabet_start)
else:
return letter
-def affine_decipher_letter(letter, multiplier, adder, multiply_then_add=True):
+def affine_decipher_letter(letter, multiplier=1, adder=0, one_based=True):
+ """Encipher a letter, given a multiplier and adder
+
+ >>> ''.join([affine_decipher_letter(l, 3, 5, True) for l in 'HKNQTWZCFILORUXADGJMPSVYBE'])
+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+ >>> ''.join([affine_decipher_letter(l, 3, 5, False) for l in 'FILORUXADGJMPSVYBEHKNQTWZC'])
+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+ """
if letter in string.ascii_letters:
if letter in string.ascii_uppercase:
alphabet_start = ord('A')
else:
alphabet_start = ord('a')
cipher_number = ord(letter) - alphabet_start
+ if one_based: cipher_number += 1
plaintext_number = 0
- if multiply_then_add:
- plaintext_number = modular_division_table[multiplier][(cipher_number - adder + 26) % 26]
+ if one_based:
+ plaintext_number = (modular_division_table_one_based[multiplier][(cipher_number - adder + 26) % 26] - 1) % 26
else:
- plaintext_number = (modular_division_table[multiplier][cipher_number] - adder) % 26
+ #plaintext_number = (modular_division_table[multiplier][cipher_number] - adder) % 26
+ plaintext_number = modular_division_table[multiplier][(cipher_number - adder + 26) % 26]
return chr(plaintext_number + alphabet_start)
else:
return letter
-def affine_encipher(message, multiplier, adder, multiply_then_add=True):
- enciphered = [affine_encipher_letter(l, multiplier, adder, multiply_then_add) for l in message]
+def affine_encipher(message, multiplier=1, adder=0, one_based=True):
+ """Encipher a message
+
+ >>> affine_encipher('hours passed during which jerico tried every trick he could think of', 15, 22, True)
+ 'lmyfu bkuusd dyfaxw claol psfaom jfasd snsfg jfaoe ls omytd jlaxe mh'
+ """
+
+ enciphered = [affine_encipher_letter(l, multiplier, adder, one_based) for l in message]
return ''.join(enciphered)
-def affine_decipher(message, multiplier, adder, multiply_then_add=True):
- enciphered = [affine_decipher_letter(l, multiplier, adder, multiply_then_add) for l in message]
+def affine_decipher(message, multiplier=1, adder=0, one_based=True):
+ """Decipher a message
+
+ >>> affine_decipher('lmyfu bkuusd dyfaxw claol psfaom jfasd snsfg jfaoe ls omytd jlaxe mh', 15, 22, True)
+ 'hours passed during which jerico tried every trick he could think of'
+ """
+ enciphered = [affine_decipher_letter(l, multiplier, adder, one_based) for l in message]
return ''.join(enciphered)
+def keyword_cipher_alphabet_of(keyword, wrap_alphabet=False):
+ """Find the cipher alphabet given a keyword
+
+ >>> keyword_cipher_alphabet_of('harry')
+ 'harybcdefgijklmnopqstuvwxz'
+ >>> keyword_cipher_alphabet_of('harry', True)
+ 'haryzbcdefgijklmnopqstuvwx'
+ >>> keyword_cipher_alphabet_of('harry', False)
+ 'harybcdefgijklmnopqstuvwxz'
+ """
+ cipher_alphabet = ''
+ if wrap_alphabet:
+ last_keyword_letter = deduplicate(sanitise(keyword))[-1]
+ last_keyword_position = string.ascii_lowercase.find(last_keyword_letter) + 1
+ cipher_alphabet = ''.join(deduplicate(sanitise(keyword) + string.ascii_lowercase[last_keyword_position:] + string.ascii_lowercase))
+ else:
+ cipher_alphabet = ''.join(deduplicate(sanitise(keyword) + string.ascii_lowercase))
+ return cipher_alphabet
+
+
+def keyword_encipher(message, keyword, wrap_alphabet=False):
+ """Enciphers a message with a keyword substitution cipher
+
+ >>> keyword_encipher('test message', 'harry')
+ 'sbqs kbqqhdb'
+ >>> keyword_encipher('test message', 'harry', True)
+ 'qzpq jzpphcz'
+ >>> keyword_encipher('test message', 'harry', False)
+ 'sbqs kbqqhdb'
+ """
+ cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
+ cipher_translation = ''.maketrans(string.ascii_lowercase, cipher_alphabet)
+ return message.lower().translate(cipher_translation)
+
+def keyword_decipher(message, keyword, wrap_alphabet=False):
+ """Deciphers a message with a keyword substitution cipher
+
+ >>> keyword_decipher('sbqs kbqqhdb', 'harry')
+ 'test message'
+ >>> keyword_decipher('qzpq jzpphcz', 'harry', True)
+ 'test message'
+ >>> keyword_decipher('sbqs kbqqhdb', 'harry', False)
+ 'test message'
+ """
+ cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
+ cipher_translation = ''.maketrans(cipher_alphabet, string.ascii_lowercase)
+ return message.lower().translate(cipher_translation)
+
+
def caesar_break(message, metric=norms.euclidean_distance, target_frequencies=normalised_english_counts, message_frequency_scaling=norms.normalise):
"""Breaks a Caesar cipher using frequency analysis
- >>> caesar_break('ibxcsyorsaqcheyklxivoexlevmrimwxsfiqevvmihrsasrxliwyrhecjsppsamrkwleppfmergefifvmhixscsymjcsyqeoixlm')
- (4, 0.3186395289018361)
- >>> caesar_break('wxwmaxdgheetgwuxztgptedbgznitgwwhpguxyhkxbmhvvtlbhgteeraxlmhiixweblmxgxwmhmaxybkbgztgwztsxwbgmxgmert')
- (19, 0.4215290123583277)
- >>> caesar_break('yltbbqnqnzvguvaxurorgenafsbezqvagbnornfgsbevpnaabjurersvaquvzyvxrnznazlybequrvfohgriraabjtbaruraprur')
- (13, 0.31602920807545154)
+ >>> caesar_break('ibxcsyorsaqcheyklxivoexlevmrimwxsfiqevvmihrsasrxliwyrhecjsppsamrkwleppfmergefifvmhixscsymjcsyqeoixlm') # doctest: +ELLIPSIS
+ (4, 0.31863952890183...)
+ >>> caesar_break('wxwmaxdgheetgwuxztgptedbgznitgwwhpguxyhkxbmhvvtlbhgteeraxlmhiixweblmxgxwmhmaxybkbgztgwztsxwbgmxgmert') # doctest: +ELLIPSIS
+ (19, 0.42152901235832...)
+ >>> caesar_break('yltbbqnqnzvguvaxurorgenafsbezqvagbnornfgsbevpnaabjurersvaquvzyvxrnznazlybequrvfohgriraabjtbaruraprur') # doctest: +ELLIPSIS
+ (13, 0.316029208075451...)
"""
sanitised_message = sanitise(message)
best_shift = 0
plaintext = caesar_decipher(sanitised_message, shift)
frequencies = message_frequency_scaling(letter_frequencies(plaintext))
fit = metric(target_frequencies, frequencies)
- logger.info('Caesar break attempt using key {0} gives fit of {1} and decrypt starting: {2}'.format(shift, fit, plaintext[:50]))
+ logger.debug('Caesar break attempt using key {0} gives fit of {1} and decrypt starting: {2}'.format(shift, fit, plaintext[:50]))
if fit < best_fit:
best_fit = fit
best_shift = shift
def affine_break(message, metric=norms.euclidean_distance, target_frequencies=normalised_english_counts, message_frequency_scaling=norms.normalise):
"""Breaks an affine cipher using frequency analysis
+
+ >>> affine_break('lmyfu bkuusd dyfaxw claol psfaom jfasd snsfg jfaoe ls omytd jlaxe mh jm bfmibj umis hfsul axubafkjamx. ls kffkxwsd jls ofgbjmwfkiu olfmxmtmwaokttg jlsx ls kffkxwsd jlsi zg tsxwjl. jlsx ls umfjsd jlsi zg hfsqysxog. ls dmmdtsd mx jls bats mh bkbsf. ls bfmctsd kfmyxd jls lyj, mztanamyu xmc jm clm cku tmmeaxw kj lai kxd clm ckuxj.') # doctest: +ELLIPSIS
+ ((15, 22, True), 0.23570361818655...)
"""
sanitised_message = sanitise(message)
best_multiplier = 0
best_adder = 0
- best_multiply_then_add = True
+ best_one_based = True
best_fit = float("inf")
- for multiply_then_add in [True, False]:
+ for one_based in [True, False]:
for multiplier in range(1, 26, 2):
for adder in range(26):
- plaintext = affine_decipher(sanitised_message, multiplier, adder, multiply_then_add)
+ plaintext = affine_decipher(sanitised_message, multiplier, adder, one_based)
frequencies = message_frequency_scaling(letter_frequencies(plaintext))
fit = metric(target_frequencies, frequencies)
- logger.info('Affine break attempt using key {0}x+{1} ({2}) gives fit of {3} and decrypt starting: {4}'.format(multiplier, adder, multiply_then_add, fit, plaintext[:50]))
+ logger.debug('Affine break attempt using key {0}x+{1} ({2}) gives fit of {3} and decrypt starting: {4}'.format(multiplier, adder, one_based, fit, plaintext[:50]))
if fit < best_fit:
best_fit = fit
best_multiplier = multiplier
best_adder = adder
- best_multiply_then_add = multiply_then_add
- logger.info('Affine break best fit with key {0}x+{1} ({2}) gives fit of {3} and decrypt starting: {4}'.format(best_multiplier, best_adder, best_multiply_then_add, best_fit, affine_decipher(sanitised_message, best_multiplier, best_adder, best_multiply_then_add)[:50]))
- return (best_multiplier, best_adder, best_multiply_then_add), best_fit
+ best_one_based = one_based
+ logger.info('Affine break best fit with key {0}x+{1} ({2}) gives fit of {3} and decrypt starting: {4}'.format(best_multiplier, best_adder, best_one_based, best_fit, affine_decipher(sanitised_message, best_multiplier, best_adder, best_one_based)[:50]))
+ return (best_multiplier, best_adder, best_one_based), best_fit
+
+
+def keyword_break(message, wordlist=keywords, metric=norms.euclidean_distance, target_frequencies=normalised_english_counts, message_frequency_scaling=norms.normalise):
+ """Breaks a keyword substitution cipher using a dictionary and frequency analysis
+
+ >>> keyword_break(keyword_encipher('this is a test message for the keyword decipherment', 'elephant', True))
+ (('elephant', True), 0.41643991598441...) # doctest: +ELLIPSIS
+ """
+ best_keyword = ''
+ best_wrap_alphabet = True
+ best_fit = float("inf")
+ for wrap_alphabet in [True, False]:
+ for keyword in wordlist:
+ plaintext = keyword_decipher(message, keyword, wrap_alphabet)
+ frequencies = message_frequency_scaling(letter_frequencies(plaintext))
+ fit = metric(target_frequencies, frequencies)
+ logger.debug('Keyword break attempt using key {0} ({1}) gives fit of {2} and decrypt starting: {3}'.format(keyword, wrap_alphabet, fit, sanitise(plaintext)[:50]))
+ if fit < best_fit:
+ best_fit = fit
+ best_keyword = keyword
+ best_wrap_alphabet = wrap_alphabet
+ logger.info('Keyword break best fit with key {0} ({1}) gives fit of {2} and decrypt starting: {3}'.format(best_keyword, best_wrap_alphabet, best_fit, sanitise(keyword_decipher(message, best_keyword))[:50]))
+ return (best_keyword, best_wrap_alphabet), best_fit
if __name__ == "__main__":
projects / cipher-tools.git / blobdiff