X-Git-Url: https://git.njae.me.uk/?a=blobdiff_plain;f=cipherbreak.py;h=7c609ab5c16aa1e56d0529172e4733daf33b81ec;hb=1bf8b88bd6c6f03de0736d4b7b278f6f76bc0180;hp=d2c35c93ed77b1c693dd68fd98bce7989b108066;hpb=394bcd0c89bbc6de8e9473002a27c673ee8daa43;p=cipher-tools.git diff --git a/cipherbreak.py b/cipherbreak.py index d2c35c9..7c609ab 100644 --- a/cipherbreak.py +++ b/cipherbreak.py @@ -1,14 +1,35 @@ +"""A set of functions to break the ciphers give in ciphers.py. +""" + import string import collections import norms import logging -from itertools import zip_longest, cycle, permutations +import random +import math +from itertools import starmap from segment import segment from multiprocessing import Pool -from math import log10 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 * @@ -19,56 +40,64 @@ from language_models import * # 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) + +def index_of_coincidence(text): + stext = sanitise(text) + counts = collections.Counter(stext) + denom = len(stext) * (len(text) - 1) / 26 + return ( + sum(max(counts[l] * counts[l] - 1, 0) for l in string.ascii_lowercase) + / + denom + ) + + 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), + [(' ', 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), + [(' ', 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... ' \ + >>> 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), + [('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 """ - #counts = collections.defaultdict(int) - #for c in text: - # counts[c] += 1 - #return counts 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.849890899...) + (4, -130.849989015...) >>> caesar_break('wxwmaxdgheetgwuxztgptedbgznitgwwhpguxyhkxbmhvvtlbhgtee' \ 'raxlmhiixweblmxgxwmhmaxybkbgztgwztsxwbgmxgmert') # doctest: +ELLIPSIS - (19, -128.82516920...) + (19, -128.82410410...) >>> caesar_break('yltbbqnqnzvguvaxurorgenafsbezqvagbnornfgsbevpnaabjurer' \ 'svaquvzyvxrnznazlybequrvfohgriraabjtbaruraprur') # doctest: +ELLIPSIS - (13, -126.25233502...) + (13, -126.25403935...) """ sanitised_message = sanitise(message) best_shift = 0 @@ -77,7 +106,8 @@ def caesar_break(message, fitness=Pletters): 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])) + 'and decrypt starting: {2}'.format(shift, fit, + plaintext[:50])) if fit > best_fit: best_fit = fit best_shift = shift @@ -88,14 +118,14 @@ def caesar_break(message, fitness=Pletters): 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.611412245...) + ((15, 22, True), -340.601181913...) """ sanitised_message = sanitise(message) best_multiplier = 0 @@ -105,72 +135,83 @@ def affine_break(message, fitness=Pletters): 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, + 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, + 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])) + 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 + """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', 1), \ + 'keyword decipherment', 'elephant', KeywordWrapAlphabet.from_last), \ wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS - (('elephant', 1), -52.8345642265...) + (('elephant', ), -52.834575011...) """ best_keyword = '' best_wrap_alphabet = True best_fit = float("-inf") - for wrap_alphabet in range(3): + 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, + 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, + '{2} and decrypt starting: {3}'.format(best_keyword, best_wrap_alphabet, best_fit, sanitise( - keyword_decipher(message, best_keyword, + 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, chunksize=500): - """Breaks a keyword substitution cipher using a dictionary and +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', 1), \ + 'keyword decipherment', 'elephant', KeywordWrapAlphabet.from_last), \ wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS - (('elephant', 1), -52.834564226507...) + (('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 range(3)] - # Gotcha: the helper function here needs to be defined at the top level + 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) - return max(breaks, key=lambda k: k[1]) + 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) @@ -180,162 +221,199 @@ def keyword_break_worker(message, keyword, wrap_alphabet, fitness): wrap_alphabet, fit, sanitise(plaintext)[:50])) return (keyword, wrap_alphabet), fit -def scytale_break(message, fitness=Pbigrams): - """Breaks a Scytale cipher - - >>> scytale_break('tfeulchtrtteehwahsdehneoifeayfsondmwpltmaoalhikotoere' \ - 'dcweatehiplwxsnhooacgorrcrcraotohsgullasenylrendaianeplscdriioto' \ - 'aek') # doctest: +ELLIPSIS - (6, -281.276219108...) - """ - best_key = 0 - best_fit = float("-inf") - for key in range(1, 20): - if len(message) % key == 0: - plaintext = scytale_decipher(message, key) - fit = fitness(sanitise(plaintext)) - logger.debug('Scytale break attempt using key {0} gives fit of ' - '{1} and decrypt starting: {2}'.format(key, - fit, sanitise(plaintext)[:50])) - if fit > best_fit: - best_fit = fit - best_key = key - logger.info('Scytale break best fit with key {0} gives fit of {1} and ' - 'decrypt starting: {2}'.format(best_key, best_fit, - sanitise(scytale_decipher(message, best_key))[:50])) - return best_key, best_fit - - -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), 0.0628106372...) - # >>> 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']}, \ - # target_counts=normalised_english_trigram_counts) # doctest: +ELLIPSIS - # (((2, 0, 5, 3, 1, 4, 6), False), 0.0592259560...) - # """ +# 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(best_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[:50]) +# return best_alphabet, best_fitness + + +def monoalphabetic_break_hillclimbing(message, + max_iterations=20000, + plain_alphabet=None, + cipher_alphabet=None, + fitness=Pletters, chunksize=1): + return simulated_annealing_break(message, + workers=1, + initial_temperature=0, + max_iterations=max_iterations, + plain_alphabet=plain_alphabet, + cipher_alphabet=cipher_alphabet, + fitness=fitness, chunksize=chunksize) + + +def monoalphabetic_break_hillclimbing_mp(message, + workers=10, + max_iterations=20000, + plain_alphabet=None, + cipher_alphabet=None, + fitness=Pletters, chunksize=1): + return simulated_annealing_break(message, + workers=workers, + initial_temperature=0, + max_iterations=max_iterations, + plain_alphabet=plain_alphabet, + cipher_alphabet=cipher_alphabet, + fitness=fitness, chunksize=chunksize) + + +def simulated_annealing_break(message, workers=10, + initial_temperature=200, + max_iterations=20000, + plain_alphabet=None, + cipher_alphabet=None, + fitness=Pletters, chunksize=1): + worker_args = [] + ciphertext = sanitise(message) + for i in range(workers): + if not plain_alphabet: + plain_alphabet = string.ascii_lowercase + if not cipher_alphabet: + cipher_alphabet = list(string.ascii_lowercase) + random.shuffle(cipher_alphabet) + cipher_alphabet = cat(cipher_alphabet) + worker_args.append((ciphertext, plain_alphabet, cipher_alphabet, + initial_temperature, max_iterations, fitness)) with Pool() as pool: - helper_args = [(message, trans, columnwise, fitness) - for trans in translist.keys() - for columnwise 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, columnwise, - fitness): - plaintext = column_transposition_decipher(message, transposition, columnwise=columnwise) - 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, columnwise), fit - - -def transposition_break_exhaustive(message, fitness=Pbigrams): - best_transposition = '' - best_pw = float('-inf') - for keylength in range(1, 21): - if len(message) % keylength == 0: - for transposition in permutations(range(keylength)): - for columnwise in [True, False]: - plaintext = column_transposition_decipher(message, - transposition, columnwise=columnwise) - fit=fitness(plaintext) - logger.debug('Column transposition break attempt using key {0} {1} ' - 'gives fit of {2} and decrypt starting: {3}'.format( - transposition, columnwise, pw, - sanitise(plaintext)[:50])) - if fit > best_fit: - best_transposition = transposition - best_columnwise = columnwise - best_fit = fit - return (best_transposition, best_columnwise), best_pw - + breaks = pool.starmap(simulated_annealing_break_worker, + worker_args, chunksize) + return max(breaks, key=lambda k: k[1]) + + +def simulated_annealing_break_worker(message, plain_alphabet, cipher_alphabet, + t0, 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:]) + + temperature = t0 -def vigenere_keyword_break(message, wordlist=keywords, fitness=Pletters): - """Breaks a vigenere cipher using a dictionary and - frequency analysis + dt = t0 / (0.9 * max_iterations) - >>> vigenere_keyword_break(vigenere_encipher(sanitise('this is a test ' \ - 'message for the vigenere decipherment'), 'cat'), \ - wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS - ('cat', -52.9479167030...) - """ - best_keyword = '' - best_fit = float("-inf") - for keyword in wordlist: - plaintext = vigenere_decipher(message, keyword) - fit = fitness(plaintext) - logger.debug('Vigenere break attempt using key {0} ' - 'gives fit of {1} and decrypt starting: {2}'.format( - keyword, fit, - sanitise(plaintext)[:50])) - if fit > best_fit: - best_fit = fit - best_keyword = keyword - logger.info('Vigenere break best fit with key {0} gives fit ' - 'of {1} and decrypt starting: {2}'.format(best_keyword, - best_fit, sanitise( - vigenere_decipher(message, best_keyword))[:50])) - return best_keyword, best_fit - -def vigenere_keyword_break_mp(message, wordlist=keywords, fitness=Pletters, - chunksize=500): - """Breaks a vigenere cipher using a dictionary and - frequency analysis + current_alphabet = cipher_alphabet + alphabet = current_alphabet + cipher_translation = ''.maketrans(current_alphabet, plain_alphabet) + plaintext = message.translate(cipher_translation) + current_fitness = fitness(plaintext) + + best_alphabet = current_alphabet + best_fitness = current_fitness + best_plaintext = plaintext + + # print('starting for', max_iterations) + for i in range(max_iterations): + swap_a = random.randrange(26) + swap_b = (swap_a + int(random.gauss(0, 4))) % 26 + alphabet = swap(current_alphabet, swap_a, swap_b) + cipher_translation = ''.maketrans(alphabet, plain_alphabet) + plaintext = message.translate(cipher_translation) + new_fitness = fitness(plaintext) + try: + sa_chance = math.exp((new_fitness - current_fitness) / temperature) + except (OverflowError, ZeroDivisionError): + # print('exception triggered: new_fit {}, current_fit {}, temp {}'.format(new_fitness, current_fitness, temperature)) + sa_chance = 0 + if (new_fitness > current_fitness or random.random() < sa_chance): + # logger.debug('Simulated annealing: iteration {}, temperature {}, ' + # 'current alphabet {}, current_fitness {}, ' + # 'best_plaintext {}'.format(i, temperature, current_alphabet, + # current_fitness, best_plaintext[:50])) + + # logger.debug('new_fit {}, current_fit {}, temp {}, sa_chance {}'.format(new_fitness, current_fitness, temperature, sa_chance)) + current_fitness = new_fitness + current_alphabet = alphabet + + if current_fitness > best_fitness: + best_alphabet = current_alphabet + best_fitness = current_fitness + best_plaintext = plaintext + if i % 500 == 0: + logger.debug('Simulated annealing: iteration {}, temperature {}, ' + 'current alphabet {}, current_fitness {}, ' + 'best_plaintext {}'.format(i, temperature, current_alphabet, + current_fitness, plaintext[:50])) + temperature = max(temperature - dt, 0.001) + + return best_alphabet, best_fitness # current_alphabet, current_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.9479167030...) + ('cat', -52.9472712...) """ with Pool() as pool: - helper_args = [(message, word, fitness) + helper_args = [(message, word, fitness) for word in wordlist] - # Gotcha: the helper function here needs to be defined at the top level + # 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) + 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, + '{1} and decrypt starting: {2}'.format(keyword, fit, sanitise(plaintext)[:50])) return keyword, fit - -def vigenere_frequency_break(message, fitness=Pletters): +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 " \ @@ -345,28 +423,48 @@ def vigenere_frequency_break(message, fitness=Pletters): "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.5549865898...) + ('florence', -307.5473096...) """ - best_fit = float("-inf") - best_key = '' + def worker(message, key_length, fitness): + splits = every_nth(sanitised_message, key_length) + key = cat([unpos(caesar_break(s)[0]) for s in splits]) + plaintext = vigenere_decipher(message, key) + fit = fitness(plaintext) + return key, fit sanitised_message = sanitise(message) - for trial_length in range(1, 20): - splits = every_nth(sanitised_message, trial_length) - key = ''.join([chr(caesar_break(s)[0] + ord('a')) for s in splits]) - plaintext = vigenere_decipher(sanitised_message, key) + 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_sub_break(message, fitness=Pletters): + """Breaks one chunk of a Beaufort cipher with frequency analysis + + >>> beaufort_sub_break('samwpplggnnmmyaazgympjapopnwiywwomwspgpjmefwmawx' \ + 'jafjhxwwwdigxshnlywiamhyshtasxptwueahhytjwsn') # doctest: +ELLIPSIS + (0, -117.4492...) + >>> beaufort_sub_break('eyprzjjzznxymrygryjqmqhznjrjjapenejznawngnnezgza' \ + 'dgndknaogpdjneadadazlhkhxkryevrronrmdjnndjlo') # doctest: +ELLIPSIS + (17, -114.9598...) + """ + best_shift = 0 + best_fit = float('-inf') + for key in range(26): + plaintext = [unpos(key - pos(l)) for l in message] fit = fitness(plaintext) - logger.debug('Vigenere key length of {0} ({1}) gives fit of {2}'. - format(trial_length, key, fit)) + logger.debug('Beaufort sub break attempt using key {0} gives fit of {1} ' + 'and decrypt starting: {2}'.format(key, fit, + plaintext[:50])) if fit > best_fit: best_fit = fit best_key = key - logger.info('Vigenere break best fit with key {0} gives fit ' - 'of {1} and decrypt starting: {2}'.format(best_key, - best_fit, sanitise( - vigenere_decipher(message, best_key))[:50])) + logger.info('Beaufort sub break best fit: key {0} gives fit of {1} and ' + 'decrypt starting: {2}'.format(best_key, best_fit, + cat([unpos(best_key - pos(l)) for l in message[:50]]))) return best_key, best_fit -def beaufort_frequency_break(message, fitness=Pletters): + +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 " \ @@ -376,41 +474,509 @@ def beaufort_frequency_break(message, fitness=Pletters): "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.5549865898...) + ('florence', -307.5473096791...) """ - best_fit = float("-inf") - best_key = '' + def worker(message, key_length, fitness): + splits = every_nth(message, key_length) + key = cat([unpos(beaufort_sub_break(s)[0]) for s in splits]) + plaintext = beaufort_decipher(message, key) + fit = fitness(plaintext) + return key, fit sanitised_message = sanitise(message) - for trial_length in range(1, 20): - splits = every_nth(sanitised_message, trial_length) - key = ''.join([chr(-caesar_break(s)[0] % 26 + ord('a')) for s in splits]) - plaintext = beaufort_decipher(sanitised_message, key) + 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_variant_frequency_break(message, max_key_length=20, fitness=Pletters): + """Breaks a Beaufort cipher with frequency analysis + + >>> beaufort_variant_frequency_break(beaufort_variant_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([unpos(-caesar_break(s)[0]) for s in splits]) + plaintext = beaufort_variant_decipher(message, key) fit = fitness(plaintext) - logger.debug('Beaufort key length of {0} ({1}) gives fit of {2}'. - format(trial_length, key, fit)) - if fit > best_fit: - best_fit = fit - best_key = key - logger.info('Beaufort break best fit with key {0} gives fit ' - 'of {1} and decrypt starting: {2}'.format(best_key, - best_fit, sanitise( - beaufort_decipher(message, best_key))[:50])) - return best_key, best_fit + 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 polybius_break_mp(message, column_labels, row_labels, + letters_to_merge=None, + wordlist=keywords, fitness=Pletters, + number_of_solutions=1, chunksize=500): + """Breaks a Polybius substitution cipher using a dictionary and + frequency analysis + + >>> polybius_break_mp(polybius_encipher('this is a test message for the ' \ + 'polybius decipherment', 'elephant', 'abcde', 'abcde'), \ + 'abcde', 'abcde', \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE + (('elephant', , 'abcde', 'abcde', False), \ + -54.53880...) + >>> polybius_break_mp(polybius_encipher('this is a test message for the ' \ + 'polybius decipherment', 'elephant', 'abcde', 'abcde', column_first=True), \ + 'abcde', 'abcde', \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE + (('elephant', , 'abcde', 'abcde', True), \ + -54.53880...) + >>> polybius_break_mp(polybius_encipher('this is a test message for the ' \ + 'polybius decipherment', 'elephant', 'abcde', 'abcde', column_first=False), \ + 'abcde', 'abcde', \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE + (('elephant', , 'abcde', 'abcde', False), \ + -54.53880...) + >>> polybius_break_mp(polybius_encipher('this is a test message for the ' \ + 'polybius decipherment', 'elephant', 'abcde', 'pqrst', column_first=True), \ + 'abcde', 'pqrst', \ + wordlist=['cat', 'elephant', 'kangaroo']) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE + (('elephant', , 'abcde', 'pqrst', True), \ + -54.53880...) + """ + if letters_to_merge is None: + letters_to_merge = {'j': 'i'} + with Pool() as pool: + helper_args = [(message, word, wrap, + column_labels, row_labels, column_first, + letters_to_merge, + fitness) + for word in wordlist + for wrap in KeywordWrapAlphabet + for column_first in [False, True]] + # Gotcha: the helper function here needs to be defined at the top level + # (limitation of Pool.starmap) + breaks = pool.starmap(polybius_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 polybius_break_worker(message, keyword, wrap_alphabet, + column_order, row_order, column_first, + letters_to_merge, + fitness): + plaintext = polybius_decipher(message, keyword, + column_order, row_order, + column_first=column_first, + letters_to_merge=letters_to_merge, + wrap_alphabet=wrap_alphabet) + if plaintext: + fit = fitness(plaintext) + else: + fit = float('-inf') + logger.debug('Polybius break attempt using key {0} (wrap={1}, merging {2}), ' + 'columns as {3}, rows as {4} (column_first={5}) ' + 'gives fit of {6} and decrypt starting: ' + '{7}'.format(keyword, wrap_alphabet, letters_to_merge, + column_order, row_order, column_first, + fit, sanitise(plaintext)[:50])) + return (keyword, wrap_alphabet, column_order, row_order, column_first), fit + + +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 railfence 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, max_period=10, + 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', , 0), -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', , 0), -52.834575011...), + (('elephant', , 0), -52.834575011...)] + """ + with Pool() as pool: + helper_args = [(message, word, wrap, period, fitness) + for word in wordlist + for wrap in KeywordWrapAlphabet + for period in range(max_period+1)] + # 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, period, fitness): + plaintext = bifid_decipher(message, keyword, wrap_alphabet, period=period) + 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, period), fit + + +def autokey_sa_break( message + , min_keylength=2 + , max_keylength=20 + , workers=10 + , initial_temperature=200 + , max_iterations=20000 + , fitness=Pletters + , chunksize=1 + , result_count=1 + ): + """Break an autokey cipher by simulated annealing + """ + worker_args = [] + ciphertext = sanitise(message) + for keylength in range(min_keylength, max_keylength+1): + for i in range(workers): + key = cat(random.choice(string.ascii_lowercase) for _ in range(keylength)) + worker_args.append((ciphertext, key, + initial_temperature, max_iterations, fitness)) + + with Pool() as pool: + breaks = pool.starmap(autokey_sa_break_worker, + worker_args, chunksize) + if result_count <= 1: + return max(breaks, key=lambda k: k[1]) + else: + return sorted(set(breaks), key=lambda k: k[1], reverse=True)[:result_count] + + +def autokey_sa_break_worker(message, key, + t0, max_iterations, fitness): + + temperature = t0 + + dt = t0 / (0.9 * max_iterations) + + plaintext = autokey_decipher(message, key) + current_fitness = fitness(plaintext) + current_key = key + + best_key = current_key + best_fitness = current_fitness + best_plaintext = plaintext + + # print('starting for', max_iterations) + for i in range(max_iterations): + swap_pos = random.randrange(len(current_key)) + swap_char = random.choice(string.ascii_lowercase) + + new_key = current_key[:swap_pos] + swap_char + current_key[swap_pos+1:] + + plaintext = autokey_decipher(message, new_key) + new_fitness = fitness(plaintext) + try: + sa_chance = math.exp((new_fitness - current_fitness) / temperature) + except (OverflowError, ZeroDivisionError): + # print('exception triggered: new_fit {}, current_fit {}, temp {}'.format(new_fitness, current_fitness, temperature)) + sa_chance = 0 + if (new_fitness > current_fitness or random.random() < sa_chance): + # logger.debug('Simulated annealing: iteration {}, temperature {}, ' + # 'current alphabet {}, current_fitness {}, ' + # 'best_plaintext {}'.format(i, temperature, current_alphabet, + # current_fitness, best_plaintext[:50])) + + # logger.debug('new_fit {}, current_fit {}, temp {}, sa_chance {}'.format(new_fitness, current_fitness, temperature, sa_chance)) +# print(new_fitness, new_key, plaintext[:100]) + current_fitness = new_fitness + current_key = new_key + + if current_fitness > best_fitness: + best_key = current_key + best_fitness = current_fitness + best_plaintext = plaintext + if i % 500 == 0: + logger.debug('Simulated annealing: iteration {}, temperature {}, ' + 'current key {}, current_fitness {}, ' + 'best_plaintext {}'.format(i, temperature, current_key, + current_fitness, plaintext[:50])) + temperature = max(temperature - dt, 0.001) + +# print(best_key, best_fitness, best_plaintext[:70]) + return best_key, best_fitness # current_alphabet, current_fitness + + +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.keys())) - y = [freqs[l] for l in sorted(freqs.keys(), key=sort_key)] + 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.keys(), key=sort_key)) + ax.set_xticklabels(sorted(freqs, key=sort_key)) f.show() if __name__ == "__main__": import doctest doctest.testmod() -