From: Neil Smith Date: Fri, 16 Dec 2016 15:25:47 +0000 (+0000) Subject: Bifid ciphers from development branch X-Git-Url: https://git.njae.me.uk/?a=commitdiff_plain;h=88c3487722ee0931062953c84c8409ac7c25b2f6;p=cipher-training.git Bifid ciphers from development branch --- diff --git a/cipher.py b/cipher.py index 266237a..1c71b5c 100644 --- a/cipher.py +++ b/cipher.py @@ -7,6 +7,22 @@ import numpy as np from numpy import matrix from numpy import linalg from language_models import * +import pprint + + +## Utility functions +cat = ''.join +wcat = ' '.join + +def pos(letter): + if letter in string.ascii_lowercase: + return ord(letter) - ord('a') + elif letter in string.ascii_uppercase: + return ord(letter) - ord('A') + else: + return '' + +def unpos(number): return chr(number % 26 + ord('a')) modular_division_table = [[0]*26 for _ in range(26)] @@ -31,7 +47,7 @@ def every_nth(text, n, fillvalue=''): ['afkpuz', 'bglqv!', 'chmrw!', 'dinsx!', 'ejoty!'] """ split_text = chunks(text, n, fillvalue) - return [''.join(l) for l in zip_longest(*split_text, fillvalue=fillvalue)] + return [cat(l) for l in zip_longest(*split_text, fillvalue=fillvalue)] def combine_every_nth(split_text): """Reforms a text split into every_nth strings @@ -43,7 +59,7 @@ def combine_every_nth(split_text): >>> combine_every_nth(every_nth(string.ascii_lowercase, 26)) 'abcdefghijklmnopqrstuvwxyz' """ - return ''.join([''.join(l) + return cat([cat(l) for l in zip_longest(*split_text, fillvalue='')]) def chunks(text, n, fillvalue=None): @@ -120,14 +136,24 @@ def caesar_encipher_letter(accented_letter, shift): >>> caesar_encipher_letter('é', 1) 'f' """ + # letter = unaccent(accented_letter) + # if letter in string.ascii_letters: + # if letter in string.ascii_uppercase: + # alphabet_start = ord('A') + # else: + # alphabet_start = ord('a') + # return chr(((ord(letter) - alphabet_start + shift) % 26) + + # alphabet_start) + # else: + # return letter + letter = unaccent(accented_letter) if letter in string.ascii_letters: + cipherletter = unpos(pos(letter) + shift) if letter in string.ascii_uppercase: - alphabet_start = ord('A') + return cipherletter.upper() else: - alphabet_start = ord('a') - return chr(((ord(letter) - alphabet_start + shift) % 26) + - alphabet_start) + return cipherletter else: return letter @@ -156,7 +182,7 @@ def caesar_encipher(message, shift): 'Jgnnq Yqtnf!' """ enciphered = [caesar_encipher_letter(l, shift) for l in message] - return ''.join(enciphered) + return cat(enciphered) def caesar_decipher(message, shift): """Decipher a message with the Caesar cipher of given shift @@ -175,49 +201,74 @@ def caesar_decipher(message, shift): def affine_encipher_letter(accented_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' + >>> cat(affine_encipher_letter(l, 3, 5, True) \ + for l in string.ascii_letters) + 'hknqtwzcfiloruxadgjmpsvybeHKNQTWZCFILORUXADGJMPSVYBE' + >>> cat(affine_encipher_letter(l, 3, 5, False) \ + for l in string.ascii_letters) + 'filoruxadgjmpsvybehknqtwzcFILORUXADGJMPSVYBEHKNQTWZC' """ + # letter = unaccent(accented_letter) + # 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 + # cipher_number = (letter_number * multiplier + adder) % 26 + # if one_based: cipher_number -= 1 + # return chr(cipher_number % 26 + alphabet_start) + # else: + # return letter letter = unaccent(accented_letter) 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 + letter_number = pos(letter) if one_based: letter_number += 1 cipher_number = (letter_number * multiplier + adder) % 26 if one_based: cipher_number -= 1 - return chr(cipher_number % 26 + alphabet_start) + if letter in string.ascii_uppercase: + return unpos(cipher_number).upper() + else: + return unpos(cipher_number) else: return letter 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' + >>> cat(affine_decipher_letter(l, 3, 5, True) \ + for l in 'hknqtwzcfiloruxadgjmpsvybeHKNQTWZCFILORUXADGJMPSVYBE') + 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' + >>> cat(affine_decipher_letter(l, 3, 5, False) \ + for l in 'filoruxadgjmpsvybehknqtwzcFILORUXADGJMPSVYBEHKNQTWZC') + 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' """ + # 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 = ( + # modular_division_table[multiplier] + # [(cipher_number - adder) % 26]) + # if one_based: plaintext_number -= 1 + # return chr(plaintext_number % 26 + alphabet_start) + # else: + # return letter 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 + cipher_number = pos(letter) if one_based: cipher_number += 1 plaintext_number = ( modular_division_table[multiplier] [(cipher_number - adder) % 26]) if one_based: plaintext_number -= 1 - return chr(plaintext_number % 26 + alphabet_start) + if letter in string.ascii_uppercase: + return unpos(plaintext_number).upper() + else: + return unpos(plaintext_number) else: return letter @@ -230,7 +281,7 @@ def affine_encipher(message, multiplier=1, adder=0, one_based=True): """ enciphered = [affine_encipher_letter(l, multiplier, adder, one_based) for l in message] - return ''.join(enciphered) + return cat(enciphered) def affine_decipher(message, multiplier=1, adder=0, one_based=True): """Decipher a message @@ -241,7 +292,7 @@ def affine_decipher(message, multiplier=1, adder=0, one_based=True): """ enciphered = [affine_decipher_letter(l, multiplier, adder, one_based) for l in message] - return ''.join(enciphered) + return cat(enciphered) class KeywordWrapAlphabet(Enum): @@ -265,7 +316,7 @@ def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a 'bayeszcdfghijklmnopqrtuvwx' """ if wrap_alphabet == KeywordWrapAlphabet.from_a: - cipher_alphabet = ''.join(deduplicate(sanitise(keyword) + + cipher_alphabet = cat(deduplicate(sanitise(keyword) + string.ascii_lowercase)) else: if wrap_alphabet == KeywordWrapAlphabet.from_last: @@ -274,7 +325,7 @@ def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a last_keyword_letter = sorted(sanitise(keyword))[-1] last_keyword_position = string.ascii_lowercase.find( last_keyword_letter) + 1 - cipher_alphabet = ''.join( + cipher_alphabet = cat( deduplicate(sanitise(keyword) + string.ascii_lowercase[last_keyword_position:] + string.ascii_lowercase)) @@ -332,7 +383,7 @@ def vigenere_encipher(message, keyword): """ shifts = [ord(l) - ord('a') for l in sanitise(keyword)] pairs = zip(message, cycle(shifts)) - return ''.join([caesar_encipher_letter(l, k) for l, k in pairs]) + return cat([caesar_encipher_letter(l, k) for l, k in pairs]) def vigenere_decipher(message, keyword): """Vigenere decipher @@ -342,7 +393,7 @@ def vigenere_decipher(message, keyword): """ shifts = [ord(l) - ord('a') for l in sanitise(keyword)] pairs = zip(message, cycle(shifts)) - return ''.join([caesar_decipher_letter(l, k) for l, k in pairs]) + return cat([caesar_decipher_letter(l, k) for l, k in pairs]) beaufort_encipher=vigenere_decipher beaufort_decipher=vigenere_encipher @@ -428,7 +479,7 @@ def column_transposition_encipher(message, keyword, fillvalue=' ', if emptycolumnwise: return combine_every_nth(transposed) else: - return ''.join(chain(*transposed)) + return cat(chain(*transposed)) def column_transposition_decipher(message, keyword, fillvalue=' ', fillcolumnwise=False, @@ -463,7 +514,7 @@ def column_transposition_decipher(message, keyword, fillvalue=' ', if fillcolumnwise: return combine_every_nth(untransposed) else: - return ''.join(chain(*untransposed)) + return cat(chain(*untransposed)) def scytale_encipher(message, rows, fillvalue=' '): """Enciphers using the scytale transposition cipher. @@ -544,14 +595,14 @@ def railfence_encipher(message, height, fillvalue=''): sections = chunks(message, (height - 1) * 2, fillvalue=fillvalue) n_sections = len(sections) # Add the top row - rows = [''.join([s[0] for s in sections])] + rows = [cat([s[0] for s in sections])] # process the middle rows of the grid for r in range(1, height-1): - rows += [''.join([s[r:r+1] + s[height*2-r-2:height*2-r-1] for s in sections])] + rows += [cat([s[r:r+1] + s[height*2-r-2:height*2-r-1] for s in sections])] # process the bottom row - rows += [''.join([s[height - 1:height] for s in sections])] - # rows += [' '.join([s[height - 1] for s in sections])] - return ''.join(rows) + rows += [cat([s[height - 1:height] for s in sections])] + # rows += [wcat([s[height - 1] for s in sections])] + return cat(rows) def railfence_decipher(message, height, fillvalue=''): """Railfence decipher. @@ -626,11 +677,11 @@ def railfence_decipher(message, height, fillvalue=''): down_rows = [rows[0]] up_rows = [] for i in range(1, height-1): - down_rows += [''.join([c for n, c in enumerate(rows[i]) if n % 2 == 0])] - up_rows += [''.join([c for n, c in enumerate(rows[i]) if n % 2 == 1])] + down_rows += [cat([c for n, c in enumerate(rows[i]) if n % 2 == 0])] + up_rows += [cat([c for n, c in enumerate(rows[i]) if n % 2 == 1])] down_rows += [rows[-1]] up_rows.reverse() - return ''.join(c for r in zip_longest(*(down_rows + up_rows), fillvalue='') for c in r) + return cat(c for r in zip_longest(*(down_rows + up_rows), fillvalue='') for c in r) def make_cadenus_keycolumn(doubled_letters = 'vw', start='a', reverse=False): """Makes the key column for a Cadenus cipher (the column down between the @@ -666,7 +717,7 @@ def make_cadenus_keycolumn(doubled_letters = 'vw', start='a', reverse=False): index_to_remove = string.ascii_lowercase.find(doubled_letters[0]) short_alphabet = string.ascii_lowercase[:index_to_remove] + string.ascii_lowercase[index_to_remove+1:] if reverse: - short_alphabet = ''.join(reversed(short_alphabet)) + short_alphabet = cat(reversed(short_alphabet)) start_pos = short_alphabet.find(start) rotated_alphabet = short_alphabet[start_pos:] + short_alphabet[:start_pos] keycolumn = {l: i for i, l in enumerate(rotated_alphabet)} @@ -695,7 +746,7 @@ def cadenus_encipher(message, keyword, keycolumn, fillvalue='a'): rotated_rows = zip(*rotated_columns) transpositions = transpositions_of(keyword) transposed = [transpose(r, transpositions) for r in rotated_rows] - return ''.join(chain(*transposed)) + return cat(chain(*transposed)) def cadenus_decipher(message, keyword, keycolumn, fillvalue='a'): """ @@ -717,7 +768,7 @@ def cadenus_decipher(message, keyword, keycolumn, fillvalue='a'): rotated_columns = [col[-start:] + col[:-start] for start, col in zip([keycolumn[l] for l in keyword], columns)] rotated_rows = zip(*rotated_columns) # return rotated_columns - return ''.join(chain(*rotated_rows)) + return cat(chain(*rotated_rows)) def hill_encipher(matrix, message_letters, fillvalue='a'): @@ -740,7 +791,7 @@ def hill_encipher(matrix, message_letters, fillvalue='a'): # message_chunks = chunks(message, len(matrix), fillvalue=None) enciphered_chunks = [((matrix * np.matrix(c).T).T).tolist()[0] for c in message_chunks] - return ''.join([chr(int(round(l)) % 26 + ord('a')) + return cat([chr(int(round(l)) % 26 + ord('a')) for l in sum(enciphered_chunks, [])]) def hill_decipher(matrix, message, fillvalue='a'): @@ -889,8 +940,84 @@ def amsco_transposition_decipher(message, keyword, for slice in transposed_sections: plaintext_list[slice.index] = message[current_pos:current_pos-slice.start+slice.end][:len(message[slice.start:slice.end])] current_pos += len(message[slice.start:slice.end]) - return ''.join(plaintext_list) + return cat(plaintext_list) + + +def bifid_grid(keyword, wrap_alphabet, letter_mapping): + """Create the grids for a Bifid cipher + """ + cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet) + if letter_mapping is None: + letter_mapping = {'j': 'i'} + translation = ''.maketrans(letter_mapping) + cipher_alphabet = cat(collections.OrderedDict.fromkeys(cipher_alphabet.translate(translation))) + f_grid = {k: ((i // 5) + 1, (i % 5) + 1) + for i, k in enumerate(cipher_alphabet)} + r_grid = {((i // 5) + 1, (i % 5) + 1): k + for i, k in enumerate(cipher_alphabet)} + return translation, f_grid, r_grid + +def bifid_encipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a, + letter_mapping=None, period=None, fillvalue=None): + """Bifid cipher + + >>> bifid_encipher("indiajelly", 'iguana') + 'ibidonhprm' + >>> bifid_encipher("indiacurry", 'iguana', period=4) + 'ibnhgaqltm' + >>> bifid_encipher("indiacurry", 'iguana', period=4, fillvalue='x') + 'ibnhgaqltzml' + """ + translation, f_grid, r_grid = bifid_grid(keyword, wrap_alphabet, letter_mapping) + + t_message = message.translate(translation) + pairs0 = [f_grid[l] for l in sanitise(t_message)] + if period: + chunked_pairs = [pairs0[i:i+period] for i in range(0, len(pairs0), period)] + if len(chunked_pairs[-1]) < period and fillvalue: + chunked_pairs[-1] += [f_grid[fillvalue]] * (period - len(chunked_pairs[-1])) + else: + chunked_pairs = [pairs0] + + pairs1 = [] + for c in chunked_pairs: + items = sum(list(list(i) for i in zip(*c)), []) + p = [(items[i], items[i+1]) for i in range(0, len(items), 2)] + pairs1 += p + + return cat(r_grid[p] for p in pairs1) + + +def bifid_decipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a, + letter_mapping=None, period=None, fillvalue=None): + """Decipher with bifid cipher + + >>> bifid_decipher('ibidonhprm', 'iguana') + 'indiaielly' + >>> bifid_decipher("ibnhgaqltm", 'iguana', period=4) + 'indiacurry' + >>> bifid_decipher("ibnhgaqltzml", 'iguana', period=4) + 'indiacurryxx' + """ + translation, f_grid, r_grid = bifid_grid(keyword, wrap_alphabet, letter_mapping) + + t_message = message.translate(translation) + pairs0 = [f_grid[l] for l in sanitise(t_message)] + if period: + chunked_pairs = [pairs0[i:i+period] for i in range(0, len(pairs0), period)] + if len(chunked_pairs[-1]) < period and fillvalue: + chunked_pairs[-1] += [f_grid[fillvalue]] * (period - len(chunked_pairs[-1])) + else: + chunked_pairs = [pairs0] + + pairs1 = [] + for c in chunked_pairs: + items = [j for i in c for j in i] + gap = len(c) + p = [(items[i], items[i+gap]) for i in range(gap)] + pairs1 += p + return cat(r_grid[p] for p in pairs1) class PocketEnigma(object): """A pocket enigma machine @@ -990,7 +1117,7 @@ class PocketEnigma(object): >>> pe.set_position('f') 5 - >>> ''.join([pe.lookup(l) for l in string.ascii_lowercase]) + >>> cat([pe.lookup(l) for l in string.ascii_lowercase]) 'udhbfejcpgmokrliwntsayqzvx' >>> pe.lookup('A') '' diff --git a/cipherbreak.py b/cipherbreak.py new file mode 100644 index 0000000..0ca4606 --- /dev/null +++ b/cipherbreak.py @@ -0,0 +1,650 @@ +"""A set of functions to break the ciphers give in ciphers.py. +""" + +import string +import collections +import norms +import logging +import random +import math +from itertools import starmap +from segment import segment +from multiprocessing import Pool + +import matplotlib.pyplot as plt + +# logging.basicConfig(filename="cipher.log", level=logging.INFO) +# logger = logging.getLogger(__name__) + +logger = logging.getLogger('cipherbreak') +logger.setLevel(logging.WARNING) +# logger.setLevel(logging.INFO) +# logger.setLevel(logging.DEBUG) + +# create the logging file handler +fh = logging.FileHandler("cipher.log") +formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') +fh.setFormatter(formatter) + +# add handler to logger object +logger.addHandler(fh) + + +from cipher import * +from language_models import * + +# To time a run: +# +# import timeit +# c5a = open('2012/5a.ciphertext', 'r').read() +# timeit.timeit('keyword_break(c5a)', setup='gc.enable() ; from __main__ import c5a ; from cipher import keyword_break', number=1) +# timeit.repeat('keyword_break_mp(c5a, chunksize=500)', setup='gc.enable() ; from __main__ import c5a ; from cipher import keyword_break_mp', repeat=5, number=1) + +transpositions = collections.defaultdict(list) +for word in keywords: + transpositions[transpositions_of(word)] += [word] + +def frequencies(text): + """Count the number of occurrences of each character in text + + >>> sorted(frequencies('abcdefabc').items()) + [('a', 2), ('b', 2), ('c', 2), ('d', 1), ('e', 1), ('f', 1)] + >>> sorted(frequencies('the quick brown fox jumped over the lazy ' \ + 'dog').items()) # doctest: +NORMALIZE_WHITESPACE + [(' ', 8), ('a', 1), ('b', 1), ('c', 1), ('d', 2), ('e', 4), ('f', 1), + ('g', 1), ('h', 2), ('i', 1), ('j', 1), ('k', 1), ('l', 1), ('m', 1), + ('n', 1), ('o', 4), ('p', 1), ('q', 1), ('r', 2), ('t', 2), ('u', 2), + ('v', 1), ('w', 1), ('x', 1), ('y', 1), ('z', 1)] + >>> sorted(frequencies('The Quick BROWN fox jumped! over... the ' \ + '(9lazy) DOG').items()) # doctest: +NORMALIZE_WHITESPACE + [(' ', 8), ('!', 1), ('(', 1), (')', 1), ('.', 3), ('9', 1), ('B', 1), + ('D', 1), ('G', 1), ('N', 1), ('O', 2), ('Q', 1), ('R', 1), ('T', 1), + ('W', 1), ('a', 1), ('c', 1), ('d', 1), ('e', 4), ('f', 1), ('h', 2), + ('i', 1), ('j', 1), ('k', 1), ('l', 1), ('m', 1), ('o', 2), ('p', 1), + ('r', 1), ('t', 1), ('u', 2), ('v', 1), ('x', 1), ('y', 1), ('z', 1)] + >>> sorted(frequencies(sanitise('The Quick BROWN fox jumped! over... '\ + 'the (9lazy) DOG')).items()) # doctest: +NORMALIZE_WHITESPACE + [('a', 1), ('b', 1), ('c', 1), ('d', 2), ('e', 4), ('f', 1), ('g', 1), + ('h', 2), ('i', 1), ('j', 1), ('k', 1), ('l', 1), ('m', 1), ('n', 1), + ('o', 4), ('p', 1), ('q', 1), ('r', 2), ('t', 2), ('u', 2), ('v', 1), + ('w', 1), ('x', 1), ('y', 1), ('z', 1)] + >>> frequencies('abcdefabcdef')['x'] + 0 + """ + return collections.Counter(c for c in text) + + +def caesar_break(message, fitness=Pletters): + """Breaks a Caesar cipher using frequency analysis + + >>> caesar_break('ibxcsyorsaqcheyklxivoexlevmrimwxsfiqevvmihrsasrxliwyrh' \ + 'ecjsppsamrkwleppfmergefifvmhixscsymjcsyqeoixlm') # doctest: +ELLIPSIS + (4, -130.849989015...) + >>> caesar_break('wxwmaxdgheetgwuxztgptedbgznitgwwhpguxyhkxbmhvvtlbhgtee' \ + 'raxlmhiixweblmxgxwmhmaxybkbgztgwztsxwbgmxgmert') # doctest: +ELLIPSIS + (19, -128.82410410...) + >>> caesar_break('yltbbqnqnzvguvaxurorgenafsbezqvagbnornfgsbevpnaabjurer' \ + 'svaquvzyvxrnznazlybequrvfohgriraabjtbaruraprur') # doctest: +ELLIPSIS + (13, -126.25403935...) + """ + sanitised_message = sanitise(message) + best_shift = 0 + best_fit = float('-inf') + for shift in range(26): + plaintext = caesar_decipher(sanitised_message, shift) + fit = fitness(plaintext) + 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 + logger.info('Caesar break best fit: key {0} gives fit of {1} and ' + 'decrypt starting: {2}'.format(best_shift, best_fit, + caesar_decipher(sanitised_message, best_shift)[:50])) + return best_shift, best_fit + +def affine_break(message, fitness=Pletters): + """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), -340.601181913...) + """ + sanitised_message = sanitise(message) + best_multiplier = 0 + best_adder = 0 + best_one_based = True + best_fit = float("-inf") + for one_based in [True, False]: + for multiplier in [x for x in range(1, 26, 2) if x != 13]: + for adder in range(26): + plaintext = affine_decipher(sanitised_message, + multiplier, adder, one_based) + fit = fitness(plaintext) + 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_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, fitness=Pletters): + """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', KeywordWrapAlphabet.from_last), \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS + (('elephant', ), -52.834575011...) + """ + best_keyword = '' + best_wrap_alphabet = True + best_fit = float("-inf") + for wrap_alphabet in KeywordWrapAlphabet: + for keyword in wordlist: + plaintext = keyword_decipher(message, keyword, wrap_alphabet) + fit = fitness(plaintext) + logger.debug('Keyword break attempt using key {0} (wrap={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} (wrap={1}) gives fit of ' + '{2} and decrypt starting: {3}'.format(best_keyword, + best_wrap_alphabet, best_fit, sanitise( + keyword_decipher(message, best_keyword, + best_wrap_alphabet))[:50])) + return (best_keyword, best_wrap_alphabet), best_fit + +def keyword_break_mp(message, wordlist=keywords, fitness=Pletters, + number_of_solutions=1, chunksize=500): + """Breaks a keyword substitution cipher using a dictionary and + frequency analysis + + >>> keyword_break_mp(keyword_encipher('this is a test message for the ' \ + 'keyword decipherment', 'elephant', KeywordWrapAlphabet.from_last), \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS + (('elephant', ), -52.834575011...) + >>> keyword_break_mp(keyword_encipher('this is a test message for the ' \ + 'keyword decipherment', 'elephant', KeywordWrapAlphabet.from_last), \ + wordlist=['cat', 'elephant', 'kangaroo'], \ + number_of_solutions=2) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE + [(('elephant', ), -52.834575011...), + (('elephant', ), -52.834575011...)] + """ + with Pool() as pool: + helper_args = [(message, word, wrap, fitness) + for word in wordlist + for wrap in KeywordWrapAlphabet] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(keyword_break_worker, helper_args, chunksize) + if number_of_solutions == 1: + return max(breaks, key=lambda k: k[1]) + else: + return sorted(breaks, key=lambda k: k[1], reverse=True)[:number_of_solutions] + +def keyword_break_worker(message, keyword, wrap_alphabet, fitness): + plaintext = keyword_decipher(message, keyword, wrap_alphabet) + fit = fitness(plaintext) + logger.debug('Keyword break attempt using key {0} (wrap={1}) gives fit of ' + '{2} and decrypt starting: {3}'.format(keyword, + wrap_alphabet, fit, sanitise(plaintext)[:50])) + return (keyword, wrap_alphabet), fit + +def monoalphabetic_break_hillclimbing(message, max_iterations=10000000, + alphabet=None, fitness=Pletters): + ciphertext = unaccent(message).lower() + if not alphabet: + alphabet = list(string.ascii_lowercase) + random.shuffle(alphabet) + alphabet = cat(alphabet) + return monoalphabetic_break_hillclimbing_worker(ciphertext, alphabet, + max_iterations, fitness) + +def monoalphabetic_break_hillclimbing_mp(message, workers=10, + max_iterations = 10000000, alphabet=None, fitness=Pletters, chunksize=1): + worker_args = [] + ciphertext = unaccent(message).lower() + for i in range(workers): + if alphabet: + this_alphabet = alphabet + else: + this_alphabet = list(string.ascii_lowercase) + random.shuffle(this_alphabet) + this_alphabet = cat(this_alphabet) + worker_args.append((ciphertext, this_alphabet, max_iterations, fitness)) + with Pool() as pool: + breaks = pool.starmap(monoalphabetic_break_hillclimbing_worker, + worker_args, chunksize) + return max(breaks, key=lambda k: k[1]) + +def monoalphabetic_break_hillclimbing_worker(message, alphabet, + max_iterations, fitness): + def swap(letters, i, j): + if i > j: + i, j = j, i + if i == j: + return letters + else: + return (letters[:i] + letters[j] + letters[i+1:j] + letters[i] + + letters[j+1:]) + best_alphabet = alphabet + best_fitness = float('-inf') + for i in range(max_iterations): + alphabet = swap(alphabet, random.randrange(26), random.randrange(26)) + cipher_translation = ''.maketrans(string.ascii_lowercase, alphabet) + plaintext = message.translate(cipher_translation) + if fitness(plaintext) > best_fitness: + best_fitness = fitness(plaintext) + best_alphabet = alphabet + print(i, best_alphabet, best_fitness, plaintext) + return best_alphabet, best_fitness + + +def vigenere_keyword_break_mp(message, wordlist=keywords, fitness=Pletters, + chunksize=500): + """Breaks a vigenere cipher using a dictionary and frequency analysis. + + >>> vigenere_keyword_break_mp(vigenere_encipher(sanitise('this is a test ' \ + 'message for the vigenere decipherment'), 'cat'), \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS + ('cat', -52.947271216...) + """ + with Pool() as pool: + helper_args = [(message, word, fitness) + for word in wordlist] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(vigenere_keyword_break_worker, helper_args, + chunksize) + return max(breaks, key=lambda k: k[1]) +vigenere_keyword_break = vigenere_keyword_break_mp + +def vigenere_keyword_break_worker(message, keyword, fitness): + plaintext = vigenere_decipher(message, keyword) + fit = fitness(plaintext) + logger.debug('Vigenere keyword break attempt using key {0} gives fit of ' + '{1} and decrypt starting: {2}'.format(keyword, + fit, sanitise(plaintext)[:50])) + return keyword, fit + + +def vigenere_frequency_break(message, max_key_length=20, fitness=Pletters): + """Breaks a Vigenere cipher with frequency analysis + + >>> vigenere_frequency_break(vigenere_encipher(sanitise("It is time to " \ + "run. She is ready and so am I. I stole Daniel's pocketbook this " \ + "afternoon when he left his jacket hanging on the easel in the " \ + "attic. I jump every time I hear a footstep on the stairs, " \ + "certain that the theft has been discovered and that I will " \ + "be caught. The SS officer visits less often now that he is " \ + "sure"), 'florence')) # doctest: +ELLIPSIS + ('florence', -307.5473096791...) + """ + def worker(message, key_length, fitness): + splits = every_nth(sanitised_message, key_length) + key = cat([chr(caesar_break(s)[0] + ord('a')) for s in splits]) + plaintext = vigenere_decipher(message, key) + fit = fitness(plaintext) + return key, fit + sanitised_message = sanitise(message) + results = starmap(worker, [(sanitised_message, i, fitness) + for i in range(1, max_key_length+1)]) + return max(results, key=lambda k: k[1]) + + +def beaufort_frequency_break(message, max_key_length=20, fitness=Pletters): + """Breaks a Beaufort cipher with frequency analysis + + >>> beaufort_frequency_break(beaufort_encipher(sanitise("It is time to " \ + "run. She is ready and so am I. I stole Daniel's pocketbook this " \ + "afternoon when he left his jacket hanging on the easel in the " \ + "attic. I jump every time I hear a footstep on the stairs, " \ + "certain that the theft has been discovered and that I will " \ + "be caught. The SS officer visits less often now " \ + "that he is sure"), 'florence')) # doctest: +ELLIPSIS + ('florence', -307.5473096791...) + """ + def worker(message, key_length, fitness): + splits = every_nth(sanitised_message, key_length) + key = cat([chr(-caesar_break(s)[0] % 26 + ord('a')) + for s in splits]) + plaintext = beaufort_decipher(message, key) + fit = fitness(plaintext) + return key, fit + sanitised_message = sanitise(message) + results = starmap(worker, [(sanitised_message, i, fitness) + for i in range(1, max_key_length+1)]) + return max(results, key=lambda k: k[1]) + + +def column_transposition_break_mp(message, translist=transpositions, + fitness=Pbigrams, chunksize=500): + """Breaks a column transposition cipher using a dictionary and + n-gram frequency analysis + + >>> column_transposition_break_mp(column_transposition_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 'encipher'), \ + translist={(2, 0, 5, 3, 1, 4, 6): ['encipher'], \ + (5, 0, 6, 1, 3, 4, 2): ['fourteen'], \ + (6, 1, 0, 4, 5, 3, 2): ['keyword']}) # doctest: +ELLIPSIS + (((2, 0, 5, 3, 1, 4, 6), False, False), -709.4646722...) + >>> column_transposition_break_mp(column_transposition_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 'encipher'), \ + translist={(2, 0, 5, 3, 1, 4, 6): ['encipher'], \ + (5, 0, 6, 1, 3, 4, 2): ['fourteen'], \ + (6, 1, 0, 4, 5, 3, 2): ['keyword']}, \ + fitness=Ptrigrams) # doctest: +ELLIPSIS + (((2, 0, 5, 3, 1, 4, 6), False, False), -997.0129085...) + """ + with Pool() as pool: + helper_args = [(message, trans, fillcolumnwise, emptycolumnwise, + fitness) + for trans in translist + for fillcolumnwise in [True, False] + for emptycolumnwise in [True, False]] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(column_transposition_break_worker, + helper_args, chunksize) + return max(breaks, key=lambda k: k[1]) +column_transposition_break = column_transposition_break_mp + +def column_transposition_break_worker(message, transposition, + fillcolumnwise, emptycolumnwise, fitness): + plaintext = column_transposition_decipher(message, transposition, + fillcolumnwise=fillcolumnwise, emptycolumnwise=emptycolumnwise) + fit = fitness(sanitise(plaintext)) + logger.debug('Column transposition break attempt using key {0} ' + 'gives fit of {1} and decrypt starting: {2}'.format( + transposition, fit, + sanitise(plaintext)[:50])) + return (transposition, fillcolumnwise, emptycolumnwise), fit + + +def scytale_break_mp(message, max_key_length=20, + fitness=Pbigrams, chunksize=500): + """Breaks a scytale cipher using a range of lengths and + n-gram frequency analysis + + >>> scytale_break_mp(scytale_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 5)) # doctest: +ELLIPSIS + (5, -709.4646722...) + >>> scytale_break_mp(scytale_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 5), \ + fitness=Ptrigrams) # doctest: +ELLIPSIS + (5, -997.0129085...) + """ + with Pool() as pool: + helper_args = [(message, trans, False, True, fitness) + for trans in + [[col for col in range(math.ceil(len(message)/rows))] + for rows in range(1,max_key_length+1)]] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(column_transposition_break_worker, + helper_args, chunksize) + best = max(breaks, key=lambda k: k[1]) + return math.trunc(len(message) / len(best[0][0])), best[1] +scytale_break = scytale_break_mp + + +def railfence_break(message, max_key_length=20, + fitness=Pletters, chunksize=500): + """Breaks a hill cipher using a matrix of given rank and letter frequencies + + + """ + + sanitised_message = sanitise(message) + results = starmap(worker, [(sanitised_message, i, fitness) + for i in range(2, max_key_length+1)]) + return max(results, key=lambda k: k[1]) + + +def railfence_break(message, max_key_length=20, + fitness=Pbigrams, chunksize=500): + """Breaks a railfence cipher using a range of lengths and + n-gram frequency analysis + + >>> railfence_break(railfence_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 7)) # doctest: +ELLIPSIS + (7, -709.46467226...) + >>> railfence_break(railfence_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 7), \ + fitness=Ptrigrams) # doctest: +ELLIPSIS + (7, -997.0129085...) + """ + def worker(message, height, fitness): + plaintext = railfence_decipher(message, height) + fit = fitness(plaintext) + return height, fit + + sanitised_message = sanitise(message) + results = starmap(worker, [(sanitised_message, i, fitness) + for i in range(2, max_key_length+1)]) + return max(results, key=lambda k: k[1]) + +def amsco_break(message, translist=transpositions, patterns = [(1, 2), (2, 1)], + fillstyles = [AmscoFillStyle.continuous, + AmscoFillStyle.same_each_row, + AmscoFillStyle.reverse_each_row], + fitness=Pbigrams, + chunksize=500): + """Breaks an AMSCO transposition cipher using a dictionary and + n-gram frequency analysis + + >>> amsco_break(amsco_transposition_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 'encipher'), \ + translist={(2, 0, 5, 3, 1, 4, 6): ['encipher'], \ + (5, 0, 6, 1, 3, 4, 2): ['fourteen'], \ + (6, 1, 0, 4, 5, 3, 2): ['keyword']}, \ + patterns=[(1, 2)]) # doctest: +ELLIPSIS + (((2, 0, 5, 3, 1, 4, 6), (1, 2), ), -709.4646722...) + >>> amsco_break(amsco_transposition_encipher(sanitise( \ + "It is a truth universally acknowledged, that a single man in \ + possession of a good fortune, must be in want of a wife. However \ + little known the feelings or views of such a man may be on his \ + first entering a neighbourhood, this truth is so well fixed in \ + the minds of the surrounding families, that he is considered the \ + rightful property of some one or other of their daughters."), \ + 'encipher', fillpattern=(2, 1)), \ + translist={(2, 0, 5, 3, 1, 4, 6): ['encipher'], \ + (5, 0, 6, 1, 3, 4, 2): ['fourteen'], \ + (6, 1, 0, 4, 5, 3, 2): ['keyword']}, \ + patterns=[(1, 2), (2, 1)], fitness=Ptrigrams) # doctest: +ELLIPSIS + (((2, 0, 5, 3, 1, 4, 6), (2, 1), ), -997.0129085...) + """ + with Pool() as pool: + helper_args = [(message, trans, pattern, fillstyle, fitness) + for trans in translist + for pattern in patterns + for fillstyle in fillstyles] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(amsco_break_worker, helper_args, chunksize) + return max(breaks, key=lambda k: k[1]) + +def amsco_break_worker(message, transposition, + pattern, fillstyle, fitness): + plaintext = amsco_transposition_decipher(message, transposition, + fillpattern=pattern, fillstyle=fillstyle) + fit = fitness(sanitise(plaintext)) + logger.debug('AMSCO transposition break attempt using key {0} and pattern' + '{1} ({2}) gives fit of {3} and decrypt starting: ' + '{4}'.format( + transposition, pattern, fillstyle, fit, + sanitise(plaintext)[:50])) + return (transposition, pattern, fillstyle), fit + + +def hill_break(message, matrix_size=2, fitness=Pletters, + number_of_solutions=1, chunksize=500): + + all_matrices = [np.matrix(list(m)) + for m in itertools.product([list(r) + for r in itertools.product(range(26), repeat=matrix_size)], + repeat=matrix_size)] + valid_matrices = [m for m, d in + zip(all_matrices, (int(round(linalg.det(m))) for m in all_matrices)) + if d != 0 + if d % 2 != 0 + if d % 13 != 0 ] + with Pool() as pool: + helper_args = [(message, matrix, fitness) + for matrix in valid_matrices] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(hill_break_worker, helper_args, chunksize) + if number_of_solutions == 1: + return max(breaks, key=lambda k: k[1]) + else: + return sorted(breaks, key=lambda k: k[1], reverse=True)[:number_of_solutions] + +def hill_break_worker(message, matrix, fitness): + plaintext = hill_decipher(matrix, message) + fit = fitness(plaintext) + logger.debug('Hill cipher break attempt using key {0} gives fit of ' + '{1} and decrypt starting: {2}'.format(matrix, + fit, sanitise(plaintext)[:50])) + return matrix, fit + +def bifid_break_mp(message, wordlist=keywords, fitness=Pletters, + number_of_solutions=1, chunksize=500): + """Breaks a keyword substitution cipher using a dictionary and + frequency analysis + + >>> bifid_break_mp(bifid_encipher('this is a test message for the ' \ + 'keyword decipherment', 'elephant', wrap_alphabet=KeywordWrapAlphabet.from_last), \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS + (('elephant', ), -52.834575011...) + >>> bifid_break_mp(bifid_encipher('this is a test message for the ' \ + 'keyword decipherment', 'elephant', wrap_alphabet=KeywordWrapAlphabet.from_last), \ + wordlist=['cat', 'elephant', 'kangaroo'], \ + number_of_solutions=2) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE + [(('elephant', ), -52.834575011...), + (('elephant', ), -52.834575011...)] + """ + with Pool() as pool: + helper_args = [(message, word, wrap, fitness) + for word in wordlist + for wrap in KeywordWrapAlphabet] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(bifid_break_worker, helper_args, chunksize) + if number_of_solutions == 1: + return max(breaks, key=lambda k: k[1]) + else: + return sorted(breaks, key=lambda k: k[1], reverse=True)[:number_of_solutions] + +def bifid_break_worker(message, keyword, wrap_alphabet, fitness): + plaintext = bifid_decipher(message, keyword, wrap_alphabet) + fit = fitness(plaintext) + logger.debug('Keyword break attempt using key {0} (wrap={1}) gives fit of ' + '{2} and decrypt starting: {3}'.format(keyword, + wrap_alphabet, fit, sanitise(plaintext)[:50])) + return (keyword, wrap_alphabet), fit + + +def pocket_enigma_break_by_crib(message, wheel_spec, crib, crib_position): + """Break a pocket enigma using a crib (some plaintext that's expected to + be in a certain position). Returns a list of possible starting wheel + positions that could produce the crib. + + >>> pocket_enigma_break_by_crib('kzpjlzmoga', 1, 'h', 0) + ['a', 'f', 'q'] + >>> pocket_enigma_break_by_crib('kzpjlzmoga', 1, 'he', 0) + ['a'] + >>> pocket_enigma_break_by_crib('kzpjlzmoga', 1, 'll', 2) + ['a'] + >>> pocket_enigma_break_by_crib('kzpjlzmoga', 1, 'l', 2) + ['a'] + >>> pocket_enigma_break_by_crib('kzpjlzmoga', 1, 'l', 3) + ['a', 'j', 'n'] + >>> pocket_enigma_break_by_crib('aaaaa', 1, 'l', 3) + [] + """ + pe = PocketEnigma(wheel=wheel_spec) + possible_positions = [] + for p in string.ascii_lowercase: + pe.set_position(p) + plaintext = pe.decipher(message) + if plaintext[crib_position:crib_position+len(crib)] == crib: + possible_positions += [p] + return possible_positions + + +def plot_frequency_histogram(freqs, sort_key=None): + x = range(len(freqs)) + y = [freqs[l] for l in sorted(freqs, key=sort_key)] + f = plt.figure() + ax = f.add_axes([0.1, 0.1, 0.9, 0.9]) + ax.bar(x, y, align='center') + ax.set_xticks(x) + ax.set_xticklabels(sorted(freqs, key=sort_key)) + f.show() + + +if __name__ == "__main__": + import doctest + doctest.testmod()