From: Neil Smith Date: Fri, 24 Oct 2014 07:53:36 +0000 (+0100) Subject: Done railfence ciphers X-Git-Url: https://git.njae.me.uk/?a=commitdiff_plain;h=159c157fee78d4370a0e603de450bd8e2def305b;p=cipher-tools.git Done railfence ciphers --- diff --git a/cipher.py b/cipher.py index c5d542b..f291511 100644 --- a/cipher.py +++ b/cipher.py @@ -1,16 +1,10 @@ import string import collections -import logging import math +from enum import Enum from itertools import zip_longest, cycle, chain from language_models import * -logger = logging.getLogger(__name__) -logger.addHandler(logging.FileHandler('cipher.log')) -logger.setLevel(logging.WARNING) -#logger.setLevel(logging.INFO) -#logger.setLevel(logging.DEBUG) - modular_division_table = [[0]*26 for _ in range(26)] for a in range(26): @@ -33,7 +27,7 @@ def every_nth(text, n, fillvalue=''): >>> every_nth(string.ascii_lowercase, 5, fillvalue='!') ['afkpuz', 'bglqv!', 'chmrw!', 'dinsx!', 'ejoty!'] """ - split_text = [text[i:i+n] for i in range(0, len(text), n)] + split_text = chunks(text, n, fillvalue) return [''.join(l) for l in zip_longest(*split_text, fillvalue=fillvalue)] def combine_every_nth(split_text): @@ -99,7 +93,7 @@ def deduplicate(text): return list(collections.OrderedDict.fromkeys(text)) -def caesar_encipher_letter(letter, shift): +def caesar_encipher_letter(accented_letter, shift): """Encipher a letter, given a shift amount >>> caesar_encipher_letter('a', 1) @@ -118,7 +112,12 @@ def caesar_encipher_letter(letter, shift): 'y' >>> caesar_encipher_letter('a', -1) 'z' + >>> caesar_encipher_letter('A', 1) + 'B' + >>> 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') @@ -150,12 +149,14 @@ def caesar_encipher(message, shift): 'cdezab' >>> caesar_encipher('ab cx yz', 2) 'cd ez ab' + >>> caesar_encipher('Héllo World!', 2) + 'Jgnnq Yqtnf!' """ enciphered = [caesar_encipher_letter(l, shift) for l in message] return ''.join(enciphered) def caesar_decipher(message, shift): - """Encipher a message with the Caesar cipher of given shift + """Decipher a message with the Caesar cipher of given shift >>> caesar_decipher('bcd', 1) 'abc' @@ -163,10 +164,12 @@ def caesar_decipher(message, shift): 'abc' >>> caesar_decipher('cd ez ab', 2) 'ab cx yz' + >>> caesar_decipher('Jgnnq Yqtnf!', 2) + 'Hello World!' """ return caesar_encipher(message, -shift) -def affine_encipher_letter(letter, multiplier=1, adder=0, one_based=True): +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) \ @@ -176,6 +179,7 @@ def affine_encipher_letter(letter, multiplier=1, adder=0, one_based=True): for l in string.ascii_uppercase]) 'FILORUXADGJMPSVYBEHKNQTWZC' """ + letter = unaccent(accented_letter) if letter in string.ascii_letters: if letter in string.ascii_uppercase: alphabet_start = ord('A') @@ -208,7 +212,7 @@ def affine_decipher_letter(letter, multiplier=1, adder=0, one_based=True): if one_based: cipher_number += 1 plaintext_number = ( modular_division_table[multiplier] - [(cipher_number - adder) % 26] ) + [(cipher_number - adder) % 26]) if one_based: plaintext_number -= 1 return chr(plaintext_number % 26 + alphabet_start) else: @@ -237,28 +241,31 @@ def affine_decipher(message, multiplier=1, adder=0, one_based=True): return ''.join(enciphered) -def keyword_cipher_alphabet_of(keyword, wrap_alphabet=0): +class KeywordWrapAlphabet(Enum): + from_a = 1 + from_last = 2 + from_largest = 3 + + +def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a): """Find the cipher alphabet given a keyword. wrap_alphabet controls how the rest of the alphabet is added after the keyword. - 0 : from 'a' - 1 : from the last letter in the sanitised keyword - 2 : from the largest letter in the sanitised keyword >>> keyword_cipher_alphabet_of('bayes') 'bayescdfghijklmnopqrtuvwxz' - >>> keyword_cipher_alphabet_of('bayes', 0) + >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_a) 'bayescdfghijklmnopqrtuvwxz' - >>> keyword_cipher_alphabet_of('bayes', 1) + >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_last) 'bayestuvwxzcdfghijklmnopqr' - >>> keyword_cipher_alphabet_of('bayes', 2) + >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_largest) 'bayeszcdfghijklmnopqrtuvwx' """ - if wrap_alphabet == 0: + if wrap_alphabet == KeywordWrapAlphabet.from_a: cipher_alphabet = ''.join(deduplicate(sanitise(keyword) + string.ascii_lowercase)) else: - if wrap_alphabet == 1: + if wrap_alphabet == KeywordWrapAlphabet.from_last: last_keyword_letter = deduplicate(sanitise(keyword))[-1] else: last_keyword_letter = sorted(sanitise(keyword))[-1] @@ -271,7 +278,7 @@ def keyword_cipher_alphabet_of(keyword, wrap_alphabet=0): return cipher_alphabet -def keyword_encipher(message, keyword, wrap_alphabet=0): +def keyword_encipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a): """Enciphers a message with a keyword substitution cipher. wrap_alphabet controls how the rest of the alphabet is added after the keyword. @@ -281,18 +288,18 @@ def keyword_encipher(message, keyword, wrap_alphabet=0): >>> keyword_encipher('test message', 'bayes') 'rsqr ksqqbds' - >>> keyword_encipher('test message', 'bayes', 0) + >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_a) 'rsqr ksqqbds' - >>> keyword_encipher('test message', 'bayes', 1) + >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_last) 'lskl dskkbus' - >>> keyword_encipher('test message', 'bayes', 2) + >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_largest) 'qspq jsppbcs' """ cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet) cipher_translation = ''.maketrans(string.ascii_lowercase, cipher_alphabet) - return message.lower().translate(cipher_translation) + return unaccent(message).lower().translate(cipher_translation) -def keyword_decipher(message, keyword, wrap_alphabet=0): +def keyword_decipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a): """Deciphers a message with a keyword substitution cipher. wrap_alphabet controls how the rest of the alphabet is added after the keyword. @@ -302,11 +309,11 @@ def keyword_decipher(message, keyword, wrap_alphabet=0): >>> keyword_decipher('rsqr ksqqbds', 'bayes') 'test message' - >>> keyword_decipher('rsqr ksqqbds', 'bayes', 0) + >>> keyword_decipher('rsqr ksqqbds', 'bayes', KeywordWrapAlphabet.from_a) 'test message' - >>> keyword_decipher('lskl dskkbus', 'bayes', 1) + >>> keyword_decipher('lskl dskkbus', 'bayes', KeywordWrapAlphabet.from_last) 'test message' - >>> keyword_decipher('qspq jsppbcs', 'bayes', 2) + >>> keyword_decipher('qspq jsppbcs', 'bayes', KeywordWrapAlphabet.from_largest) 'test message' """ cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet) @@ -464,15 +471,18 @@ def scytale_encipher(message, rows, fillvalue=' '): >>> scytale_encipher('thequickbrownfox', 4) 'tubnhirfecooqkwx' >>> scytale_encipher('thequickbrownfox', 5) - 'tubnhirfecooqkwx' + 'tubn hirf ecoo qkwx ' >>> scytale_encipher('thequickbrownfox', 6) 'tqcrnxhukof eibwo ' >>> scytale_encipher('thequickbrownfox', 7) - 'tqcrnxhukof eibwo ' + 'tqcrnx hukof eibwo ' """ - transpositions = [i for i in range(math.ceil(len(message) / rows))] + # transpositions = [i for i in range(math.ceil(len(message) / rows))] + # return column_transposition_encipher(message, transpositions, + # fillvalue=fillvalue, fillcolumnwise=False, emptycolumnwise=True) + transpositions = [i for i in range(rows)] return column_transposition_encipher(message, transpositions, - fillcolumnwise=False, emptycolumnwise=True) + fillvalue=fillvalue, fillcolumnwise=True, emptycolumnwise=False) def scytale_decipher(message, rows): """Deciphers using the scytale transposition cipher. @@ -482,18 +492,226 @@ def scytale_decipher(message, rows): 'thequickbrownfox ' >>> scytale_decipher('tubnhirfecooqkwx', 4) 'thequickbrownfox' - >>> scytale_decipher('tubnhirfecooqkwx', 5) - 'thequickbrownfox' + >>> scytale_decipher('tubn hirf ecoo qkwx ', 5) + 'thequickbrownfox ' >>> scytale_decipher('tqcrnxhukof eibwo ', 6) 'thequickbrownfox ' - >>> scytale_decipher('tqcrnxhukof eibwo ', 7) - 'thequickbrownfox ' + >>> scytale_decipher('tqcrnx hukof eibwo ', 7) + 'thequickbrownfox ' """ - transpositions = [i for i in range(math.ceil(len(message) / rows))] + # transpositions = [i for i in range(math.ceil(len(message) / rows))] + # return column_transposition_decipher(message, transpositions, + # fillcolumnwise=False, emptycolumnwise=True) + transpositions = [i for i in range(rows)] return column_transposition_decipher(message, transpositions, - fillcolumnwise=False, emptycolumnwise=True) + fillcolumnwise=True, emptycolumnwise=False) + + +def railfence_encipher(message, height, fillvalue=' '): + """Railfence cipher + + >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 2, fillvalue='!') + 'hlohraateerishsslnpeefetotsigaleccpeselteevsmhatetiiaogicotxfretnrifneihr!' + >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 3, fillvalue='!') + 'horaersslpeeosglcpselteevsmhatetiiaogicotxfretnrifneihr!!lhateihsnefttiaece!' + >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 5, fillvalue='!') + 'hresleogcseeemhetaocofrnrner!!lhateihsnefttiaece!!ltvsatiigitxetifih!!oarspeslp!' + >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 10, fillvalue='!') + 'hepisehagitnr!!lernesge!!lmtocerh!!otiletap!!tseaorii!!hassfolc!!evtitffe!!rahsetec!!eixn!' + """ + sections = chunks(message, (height - 1) * 2, fillvalue=fillvalue) + # Add the top row + rows = [s[0] for s in sections] + # process the middle rows of the grid + for r in range(1, height - 1): + rows += [s[r] + s[-r] for s in sections] + # process the bottom row + rows += [s[height - 1] for s in sections] + return ''.join(rows) + +def railfence_decipher(message, height): + """Railfence decipher. Assumes the message is already the correct length. + + >>> railfence_decipher('hlohraateerishsslnpeefetotsigaleccpeselteevsmhatetiiaogicotxfretnrifneihr!', 2).strip('!') + 'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers' + >>> railfence_decipher('horaersslpeeosglcpselteevsmhatetiiaogicotxfretnrifneihr!!lhateihsnefttiaece!', 3).strip('!') + 'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers' + >>> railfence_decipher('hresleogcseeemhetaocofrnrner!!lhateihsnefttiaece!!ltvsatiigitxetifih!!oarspeslp!', 5).strip('!') + 'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers' + >>> railfence_decipher('hepisehagitnr!!lernesge!!lmtocerh!!otiletap!!tseaorii!!hassfolc!!evtitffe!!rahsetec!!eixn!', 10).strip('!') + 'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers' + """ + n_secs = len(message) // ((height - 1) * 2) + downrows = [message[:n_secs]] + uprows = [] + for r in range(height-2): + midrow = message[(2 * r + 1) * n_secs:(2 * r + 1) * n_secs + n_secs * 2] + downrows += [''.join([midrow[i] for i in range(0, len(midrow), 2)])] + uprows = [''.join([midrow[i] for i in range(1, len(midrow), 2)])] + uprows + downrows += [message[-n_secs:]] + rows = downrows + uprows + return ''.join(letter for section in zip(*rows) for letter in section) + + +class PocketEnigma(object): + """A pocket enigma machine + The wheel is internally represented as a 26-element list self.wheel_map, + where wheel_map[i] == j shows that the position i places on from the arrow + maps to the position j places on. + """ + def __init__(self, wheel=1, position='a'): + """initialise the pocket enigma, including which wheel to use and the + starting position of the wheel. + + The wheel is either 1 or 2 (the predefined wheels) or a list of letter + pairs. + + The position is the letter pointed to by the arrow on the wheel. + + >>> pe.wheel_map + [25, 4, 23, 10, 1, 7, 9, 5, 12, 6, 3, 17, 8, 14, 13, 21, 19, 11, 20, 16, 18, 15, 24, 2, 22, 0] + >>> pe.position + 0 + """ + self.wheel1 = [('a', 'z'), ('b', 'e'), ('c', 'x'), ('d', 'k'), + ('f', 'h'), ('g', 'j'), ('i', 'm'), ('l', 'r'), ('n', 'o'), + ('p', 'v'), ('q', 't'), ('s', 'u'), ('w', 'y')] + self.wheel2 = [('a', 'c'), ('b', 'd'), ('e', 'w'), ('f', 'i'), + ('g', 'p'), ('h', 'm'), ('j', 'k'), ('l', 'n'), ('o', 'q'), + ('r', 'z'), ('s', 'u'), ('t', 'v'), ('x', 'y')] + if wheel == 1: + self.make_wheel_map(self.wheel1) + elif wheel == 2: + self.make_wheel_map(self.wheel2) + else: + self.validate_wheel_spec(wheel) + self.make_wheel_map(wheel) + if position in string.ascii_lowercase: + self.position = ord(position) - ord('a') + else: + self.position = position + + def make_wheel_map(self, wheel_spec): + """Expands a wheel specification from a list of letter-letter pairs + into a full wheel_map. + + >>> pe.make_wheel_map(pe.wheel2) + [2, 3, 0, 1, 22, 8, 15, 12, 5, 10, 9, 13, 7, 11, 16, 6, 14, 25, 20, 21, 18, 19, 4, 24, 23, 17] + """ + self.validate_wheel_spec(wheel_spec) + self.wheel_map = [0] * 26 + for p in wheel_spec: + self.wheel_map[ord(p[0]) - ord('a')] = ord(p[1]) - ord('a') + self.wheel_map[ord(p[1]) - ord('a')] = ord(p[0]) - ord('a') + return self.wheel_map + + def validate_wheel_spec(self, wheel_spec): + """Validates that a wheel specificaiton will turn into a valid wheel + map. + + >>> pe.validate_wheel_spec([]) + Traceback (most recent call last): + ... + ValueError: Wheel specification has 0 pairs, requires 13 + >>> pe.validate_wheel_spec([('a', 'b', 'c')]*13) + Traceback (most recent call last): + ... + ValueError: Not all mappings in wheel specificationhave two elements + >>> pe.validate_wheel_spec([('a', 'b')]*13) + Traceback (most recent call last): + ... + ValueError: Wheel specification does not contain 26 letters + """ + if len(wheel_spec) != 13: + raise ValueError("Wheel specification has {} pairs, requires 13". + format(len(wheel_spec))) + for p in wheel_spec: + if len(p) != 2: + raise ValueError("Not all mappings in wheel specification" + "have two elements") + if len(set([p[0] for p in wheel_spec] + + [p[1] for p in wheel_spec])) != 26: + raise ValueError("Wheel specification does not contain 26 letters") + + def encipher_letter(self, letter): + """Enciphers a single letter, by advancing the wheel before looking up + the letter on the wheel. + + >>> pe.set_position('f') + 5 + >>> pe.encipher_letter('k') + 'h' + """ + self.advance() + return self.lookup(letter) + decipher_letter = encipher_letter + + def lookup(self, letter): + """Look up what a letter enciphers to, without turning the wheel. + + >>> pe.set_position('f') + 5 + >>> ''.join([pe.lookup(l) for l in string.ascii_lowercase]) + 'udhbfejcpgmokrliwntsayqzvx' + >>> pe.lookup('A') + '' + """ + if letter in string.ascii_lowercase: + return chr( + (self.wheel_map[(ord(letter) - ord('a') - self.position) % 26] + + self.position) % 26 + + ord('a')) + else: + return '' + + def advance(self): + """Advances the wheel one position. + + >>> pe.set_position('f') + 5 + >>> pe.advance() + 6 + """ + self.position = (self.position + 1) % 26 + return self.position + + def encipher(self, message, starting_position=None): + """Enciphers a whole message. + + >>> pe.set_position('f') + 5 + >>> pe.encipher('helloworld') + 'kjsglcjoqc' + >>> pe.set_position('f') + 5 + >>> pe.encipher('kjsglcjoqc') + 'helloworld' + >>> pe.encipher('helloworld', starting_position = 'x') + 'egrekthnnf' + """ + if starting_position: + self.set_position(starting_position) + transformed = '' + for l in message: + transformed += self.encipher_letter(l) + return transformed + decipher = encipher + + def set_position(self, position): + """Sets the position of the wheel, by specifying the letter the arrow + points to. + + >>> pe.set_position('a') + 0 + >>> pe.set_position('m') + 12 + >>> pe.set_position('z') + 25 + """ + self.position = ord(position) - ord('a') + return self.position if __name__ == "__main__": import doctest - doctest.testmod() + doctest.testmod(extraglobs={'pe': PocketEnigma(1, 'a')}) diff --git a/cipherbreak.py b/cipherbreak.py index d2c35c9..6f4d2ae 100644 --- a/cipherbreak.py +++ b/cipherbreak.py @@ -1,14 +1,24 @@ +"""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 +logger = logging.getLogger(__name__) +logger.addHandler(logging.FileHandler('cipher.log')) +logger.setLevel(logging.WARNING) +#logger.setLevel(logging.INFO) +#logger.setLevel(logging.DEBUG) + from cipher import * from language_models import * @@ -25,50 +35,46 @@ for word in keywords: 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 +83,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 +95,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 +112,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 +198,81 @@ 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, + fitness=Pletters): + ciphertext = unaccent(message).lower() + alphabet = list(string.ascii_lowercase) + random.shuffle(alphabet) + alphabet = ''.join(alphabet) + return monoalphabetic_break_hillclimbing_worker(ciphertext, alphabet, + max_iterations, fitness) + +def monoalphabetic_break_hillclimbing_mp(message, workers=10, + max_iterations = 10000000, fitness=Pletters, chunksize=1): + worker_args = [] + ciphertext = unaccent(message).lower() + for i in range(workers): + alphabet = list(string.ascii_lowercase) + random.shuffle(alphabet) + alphabet = ''.join(alphabet) + worker_args.append((ciphertext, alphabet, 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 - - -def vigenere_keyword_break(message, wordlist=keywords, fitness=Pletters): - """Breaks a vigenere cipher using a dictionary and - frequency analysis - - >>> 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 + 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.9479167030...) + ('cat', -52.947271216...) """ 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 +282,21 @@ 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.5473096791...) """ - best_fit = float("-inf") - best_key = '' - sanitised_message = sanitise(message) - for trial_length in range(1, 20): - splits = every_nth(sanitised_message, trial_length) + def worker(message, key_length, fitness): + splits = every_nth(sanitised_message, key_length) key = ''.join([chr(caesar_break(s)[0] + ord('a')) for s in splits]) - plaintext = vigenere_decipher(sanitised_message, key) + plaintext = vigenere_decipher(message, key) fit = fitness(plaintext) - logger.debug('Vigenere 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('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])) - return best_key, best_fit - -def beaufort_frequency_break(message, fitness=Pletters): + 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 " \ @@ -376,28 +306,192 @@ 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(sanitised_message, key_length) + key = ''.join([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) - 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 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.keys() + 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=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) - 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 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]) + 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 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())) @@ -413,4 +507,3 @@ def plot_frequency_histogram(freqs, sort_key=None): if __name__ == "__main__": import doctest doctest.testmod() -