Hacking secret ciphers with PYthon这书质量很好

最近再看这本书，感觉这书的作者知识面很广．写的书都是以实际的例子教人写代码．
可以从中学到不少知识．　例如求最大公约数欧几里得定律以及扩展的欧几里得定律．
参看这个页面：

http://invpy.com/euclid/

有这两个函数．

def gcd(a, b):
    #return the GCD of a and b using Euclid's Algorithm

    while a != 0:
        a, b = b % a, a
    return b



def findModInverse(a, m):
    #return the modular inverse of a % m , which is the
    #number x such that a * x % m = 1

    if gcd (a, m ) != 1:
        return None
        #no mod inverse if a & m are not relatively prime

    #calculating using the Extended Euclidean Algorithm

    u1, u2, u3 = 1, 0, a
    v1, v2, v3 = 0, 1, m

    while v3 != 0:
        q = u3 // v3 #// is the integer division operator
        v1, v2, v3 , u1, u2, u3 = (u1 - q * v1),(u2 - q * v2), (u3 - q * v3),v1,v2,v3

    return u1 % m

２．我倒是发现有个很奇怪的地方．在SimpleSubCipher如果使用不同的LETTERS会影响最后的Hack代码例如：
这个代码中的LETTERS只有２６个大写字母．

import pyperclip
import sys
import random

LETTERS = "ABCDEFGHIJKLMNOQPRSTUVWXYZ"

#LETTERS = r""" !'#$%&"()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~""" # note the space at the front

def main():

    myMessage = "If a man is offered a fact which goes against his instincts, he will scrutinize it closely, and unless the evidence is overwhelming, he will refuse to believe it. If, on the other hand, he is offered something which affords a reason for acting in accordance to his instincts, he will accept it even on the slightest evidence. The origin of myths is explained in this way. -Bertrand Russell"

    #myKey = "LFWOAYUISVKMNXPBDCRJTQEGHZ"
    myKey = getRandomKey()

    myMode = "encrypt"
    checkValidKey(myKey)

    if myMode == "encrypt":
        translated = encryptMessage(myKey, myMessage)
    elif myMode == "decrypt":
        translated = decryptMessage(myKey, myMessage)

    print("Using key {}\n".format(myKey))
    print("The {0}ed message is ".format(myMode))

    print(translated)
    pyperclip.copy(translated)
    print()
    print("This messsage has been copied to the clipboard.")

def checkValidKey(key):
    keyList = list(key)
    lettersList = list(LETTERS)
    keyList.sort()
    lettersList.sort()
    if keyList != lettersList:
        sys.exit("There is an error in the key or symbol set.")

def encryptMessage(key, message):
    return translateMessage(key, message, "encrypt")

def decryptMessage(key, message):
    return translateMessage(key, message, "decrypt")


def translateMessage(key, message, mode):
    translated = ""
    charsA = LETTERS
    charsB = key
    if mode == "decrypt":
        #For decrypting, we can use the same code as encrypting,
        #we just need to swap the key and LETTERS strings are used
        charsA, charsB = charsB, charsA
    #loop through each symbol in the message
    for symbol in message:
        if symbol.upper() in charsA:
            #encrypt/decrypt the symbol
            symIndex = charsA.find(symbol.upper())
            if symbol.isupper():
                translated += charsB[symIndex].upper()
            else:
                translated += charsB[symIndex].lower()
        else:
            #symbol is not in LETTERS, just add it
            translated += symbol

        """
        if symbol in charsA:
            symIndex = charsA.find(symbol)
            translated += charsB[symIndex]
        """
    return translated

def getRandomKey():
    key = list(LETTERS)
    random.shuffle(key)
    return "".join(key)

if __name__== "__main__"
    main()

这是破解SimpleSub　cipher的代码：

import os
import re
import copy
import pprint
import pyperclip
import simpleSubCipher
import makeWordPatterns

if not os.path.exists("wordPatterns.py"):
    #create the wordPatterns.py file
    makeWordPatterns.main()

import wordPatterns
LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
nonLettersOrSpacePattern = re.compile("[^A-Z\s]")

def main():
    message = "Sy l nlx sr pyyacao l ylwj eiswi upar lulsxrj isr sxrjsxwjr, ia esmm rwctjsxsza sj wmpramh, lxo txmarr jia aqsoaxwa sr pqaceiamnsxu, ia esmm caytra jp famsaqa sj. Sy, px jia pjiac ilxo, ia sr pyyacao rpnajisxu eiswi lyypcor l calrpx ypc lwjsxu sx lwwpcolxwa jp isr sxrjsxwjr, ia esmm lwwabj sj aqax px jia rmsuijarj aqsoaxwa. Jia pcsusx py nhjir sr agbmlsxao sx jisr elh. -Facjclxo Ctrramm"
    print("Hacking...")
    letterMapping = hackSimpleSub(message)

    #Display the results to the user
    print("Mapping:")
    pprint.pprint(letterMapping)
    print()
    print("Original ciphertext:")
    print(message)
    print()
    print("Copying hacked message to clipboard:")
    hackedMessage = decryptWithCipherletterMapping(message, letterMapping)
    pyperclip.copy(hackedMessage)

    print("hackedMessage :{}".format(hackedMessage))


def getBlankCipherletterMapping():
    #Returns a dictionary value that is a blank cipher mapping
    """
    LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    dict1 = {}
    for letter in LETTERS:
        dict1[letter]=[]
    return dict1
    """
    return {"A": [], "B": [], "C": [], "D": [], "E": [], "F": [], "G": [], "H": [], "I":
    [], "J": [], "K": [], "L": [], "M": [], "N": [], "O": [], "P": [], "Q": [], "R": [], "S": [],
    "T": [], "U": [], "V": [], "W": [], "X": [], "Y": [], "Z": []}

def addLettersToMapping(letterMapping, cipherword, candidate):
    """
    The letterMapping: is a "cipherletter mapping" dictionary
    value that the return value of this function starts as a copy
    of.
    the cipherword: is a string value of the ciphertext
    word.
    The candidate: is a possible English word that the cipherword
    could decrypt to.
    This function adds the letters of the candidate as potential
    decryption letters for the cipherletters in the cipherletter
    mapping.
    """

    letterMapping = copy.deepcopy(letterMapping)
    for i in range(len(cipherword)):
        if candidate[i] not in letterMapping[cipherword[i]]:
            letterMapping[cipherword[i]].append(candidate[i])
    return letterMapping

def intersectMapping(mapA, mapB):
    #To intersect two maps, create a blank map, then add only the
    #potential decryption letters if they exist in BOTH maps

    intersectedMapping = getBlankCipherletterMapping()
    for letter in LETTERS:
        #An empty list means "any letter is possible", in this case just
        #copy the other map entirely
        if mapA[letter] == []:
            intersectedMapping[letter] = copy.deepcopy(mapB[letter])
        elif mapB[letter] == []:
            intersectedMapping[letter] = copy.deepcopy(mapA[letter])
        else:
            #if a letter in mapA[letter] exists in mapB[letter], and
            #that letter to insertsectedMapping[letter]
            for mappedLetter in mapA[letter]:
                if mappedLetter in mapB[letter]:
                    intersectedMapping[letter].append(mappedLetter)

    return intersectedMapping

def removeSolvedLettersFromMapping(letterMapping):
    #Cipher letters in the mapping that map to only one letter are
    #"solved" and can be removed from the other letters
    #For example if "A" mamps to potential letters["M","N"] and
    #"B" maps to ["N"] , then we know that "B" must map to "N",
    #so we can remove "N" from the list of what "A" could map to,
    #so "A" then map to ["M"], Note that now that "A" maps to only
    #one letter, we can remove "M" from the list of letters for every
    #other letter.
    #That is why there is a loop that keeps reducing the map.

    letterMapping = copy.deepcopy(letterMapping)

    loopAgain = True
    while loopAgain:
        #First assume that we will not loop again
        loopAgain = False

        #solvedLetters will be a list of uppercase letters have one
        #and only one possible mapping in letterMapping
        solvedLetters = []
        for cipherletter in LETTERS:
            if len(letterMapping[cipherletter])== 1:
                solvedLetters.append(letterMapping[cipherletter][0])

        #if a letter is solved, that it can not possibly a potential
        #decryption letter for a different ciphertext letter,
        #so we should remove it from those other lists
        for cipherletter in LETTERS:
            for s in solvedLetters:
                if len(letterMapping[cipherletter]) != 1 and s in letterMapping[cipherletter]:
                    letterMapping[cipherletter].remove(s)
                    if len(letterMapping[cipherletter]) == 1:
                        #A new letter is now solved, so loop again
                        loopAgain = True

    return letterMapping

def hackSimpleSub(message):
    intersectedMap = getBlankCipherletterMapping()
    cipherwordList = nonLettersOrSpacePattern.sub("", message.upper()).split()
    for cipherword in cipherwordList:
        #get a new cipherletter mapping for each ciphertext word
        newMap = getBlankCipherletterMapping()

        wordPattern = makeWordPatterns.getWordPattern(cipherword)
        if wordPattern not in wordPatterns.allPatterns:
            #This word was not in our dictionary, so continue
            continue

        #and the letters of each candidate to the mapping
        for candidate in wordPatterns.allPatterns[wordPattern]:
            newMap = addLettersToMapping(newMap, cipherword, candidate)

        #intersect the new mapping with the existing intersected mapping
        intersectedMap = intersectMapping(intersectedMap, newMap)

    #remove any solved letters from the other lists
    return removeSolvedLettersFromMapping(intersectedMap)

def decryptWithCipherletterMapping(ciphertext, letterMapping):
    #return a string of the ciphertext decrypted with the letter mapping
    #with any ambiguous decrypted letters replaced with an _ underscore.

    #First create a simple sub key from the letterMapping mapping
    key = ["x"] * len(LETTERS)
    for cipherletter in LETTERS:
        if len(letterMapping[cipherletter])==1:
            #if there is only one letter, add it to the key
            keyIndex = LETTERS.find(letterMapping[cipherletter][0])
            key[keyIndex]= cipherletter
        else:
            ciphertext = ciphertext.replace(cipherletter.lower(), "_")
            ciphertext = ciphertext.replace(cipherletter.upper(), "_")
    key = "".join(key)

    #with the key we have created, decrypt the cipher text

    return simpleSubCipher.decryptMessage(key, ciphertext)

if __name__== "__main__":
    main()

注意这里面的代码用的常量LETTERS是２６个大写字母，因而是可以工作的．

./simpleSubHacker.py
Hacking...
Mapping:
{'A': ['E'],
 'B': ['Y', 'P', 'B'],
 'C': ['R'],
 'D': [],
 'E': ['W'],
 'F': ['B', 'P'],
 'G': ['B', 'Q', 'X', 'P', 'Y'],
 'H': ['P', 'Y', 'K', 'X', 'B'],
 'I': ['H'],
 'J': ['T'],
 'K': [],
 'L': ['A'],
 'M': ['L'],
 'N': ['M'],
 'O': ['D'],
 'P': ['O'],
 'Q': ['V'],
 'R': ['S'],
 'S': ['I'],
 'T': ['U'],
 'U': ['G'],
 'V': [],
 'W': ['C'],
 'X': ['N'],
 'Y': ['F'],
 'Z': ['Z']}

Original ciphertext:
Sy l nlx sr pyyacao l ylwj eiswi upar lulsxrj isr sxrjsxwjr, ia esmm rwctjsxsza sj wmpramh, lxo txmarr jia aqsoaxwa sr pqaceiamnsxu, ia esmm caytra jp famsaqa sj. Sy, px jia pjiac ilxo, ia sr pyyacao rpnajisxu eiswi lyypcor l calrpx ypc lwjsxu sx lwwpcolxwa jp isr sxrjsxwjr, ia esmm lwwabj sj aqax px jia rmsuijarj aqsoaxwa. Jia pcsusx py nhjir sr agbmlsxao sx jisr elh. -Facjclxo Ctrramm

Copying hacked message to clipboard:
hackedMessage :If a man is offered a fact which goes against his instincts, he will scrutinize it closel_, and unless the evidence is overwhelming, he will refuse to _elieve it. If, on the other hand, he is offered something which affords a reason for acting in accordance to his instincts, he will acce_t it even on the slightest evidence. The origin of m_ths is e__lained in this wa_. -_ertrand Russell

然后我把常量LETTERS改成了９５个可见字符：

import pyperclip
import sys
import random

#LETTERS = "ABCDEFGHIJKLMNOQPRSTUVWXYZ"

LETTERS = r""" !'#$%&"()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~""" # note the space at the front

def main():

    myMessage = "If a man is offered a fact which goes against his instincts, he will scrutinize it closely, and unless the evidence is overwhelming, he will refuse to believe it. If, on the other hand, he is offered something which affords a reason for acting in accordance to his instincts, he will accept it even on the slightest evidence. The origin of myths is explained in this way. -Bertrand Russell"

    #myKey = "LFWOAYUISVKMNXPBDCRJTQEGHZ"
    myKey = getRandomKey()

    myMode = "encrypt"
    checkValidKey(myKey)

    if myMode == "encrypt":
        translated = encryptMessage(myKey, myMessage)
    elif myMode == "decrypt":
        translated = decryptMessage(myKey, myMessage)

    print("Using key {}\n".format(myKey))
    print("The {0}ed message is ".format(myMode))

    print(translated)
    pyperclip.copy(translated)
    print()
    print("This messsage has been copied to the clipboard.")

def checkValidKey(key):
    keyList = list(key)
    lettersList = list(LETTERS)
    keyList.sort()
    lettersList.sort()
    if keyList != lettersList:
        sys.exit("There is an error in the key or symbol set.")

def encryptMessage(key, message):
    return translateMessage(key, message, "encrypt")

def decryptMessage(key, message):
    return translateMessage(key, message, "decrypt")


def translateMessage(key, message, mode):
    translated = ""
    charsA = LETTERS
    charsB = key
    if mode == "decrypt":
        #For decrypting, we can use the same code as encrypting,
        #we just need to swap the key and LETTERS strings are used
        charsA, charsB = charsB, charsA
    #loop through each symbol in the message
    for symbol in message:
        """
        if symbol.upper() in charsA:
            #encrypt/decrypt the symbol
            symIndex = charsA.find(symbol.upper())
            if symbol.isupper():
                translated += charsB[symIndex].upper()
            else:
                translated += charsB[symIndex].lower()
        else:
            #symbol is not in LETTERS, just add it
            translated += symbol
        """
        if symbol in charsA:
            symIndex = charsA.find(symbol)
            translated += charsB[symIndex]

    return translated

def getRandomKey():
    key = list(LETTERS)
    random.shuffle(key)
    return "".join(key)

if __name__== "__main__"
    main()

再看simpleSubHacker2.py

import os, re, copy, pprint, pyperclip, simpleSubCipher2, makeWordPatterns

if not os.path.exists("wordPatterns.py"):
    makeWordPatterns.main() # create the wordPatterns.py file
import wordPatterns

#LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
LETTERS = r""" !'#$%&"()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~""" # note the space at the front
nonLettersOrSpacePattern = re.compile("[^A-Z\s]")

def main():
    message = "Sy l nlx sr pyyacao l ylwj eiswi upar lulsxrj isr sxrjsxwjr, ia esmm rwctjsxsza sj wmpramh, lxo txmarr jia aqsoaxwa sr pqaceiamnsxu, ia esmm caytra jp famsaqa sj. Sy, px jia pjiac ilxo, ia sr pyyacao rpnajisxu eiswi lyypcor l calrpx ypc lwjsxu sx lwwpcolxwa jp isr sxrjsxwjr, ia esmm lwwabj sj aqax px jia rmsuijarj aqsoaxwa. Jia pcsusx py nhjir sr agbmlsxao sx jisr elh. -Facjclxo Ctrramm"

    # Determine the possible valid ciphertext translations.
    print("Hacking...")
    letterMapping = hackSimpleSub(message)

    # Display the results to the user.
    print("Mapping:")
    pprint.pprint(letterMapping)
    print()
    print("Original ciphertext:")
    print(message)
    print()
    print("Copying hacked message to clipboard:")
    hackedMessage = decryptWithCipherletterMapping(message, letterMapping)
    pyperclip.copy(hackedMessage)
    print(hackedMessage)


def getBlankCipherletterMapping():
    # Returns a dictionary value that is a blank cipherletter mapping.
    dict1 = {}
    for i in LETTERS:
        dict1[i]=[]
    return dict1
    """
    return {"A": [], "B": [], "C": [], "D": [], "E": [], "F": [], "G": [], "H": [], "I": [], "J": [], "K": [], "L": [], "M": [], "N": [], "O": [], "P": [], "Q": [], "R": [], "S": [], "T": [], "U": [], "V": [], "W": [], "X": [], "Y": [], "Z": []}
    """

def addLettersToMapping(letterMapping, cipherword, candidate):
    # The letterMapping parameter is a "cipherletter mapping" dictionary
    # value that the return value of this function starts as a copy of.
    # The cipherword parameter is a string value of the ciphertext word.
    # The candidate parameter is a possible English word that the
    # cipherword could decrypt to.

    # This function adds the letters of the candidate as potential
    # decryption letters for the cipherletters in the cipherletter
    # mapping.

    letterMapping = copy.deepcopy(letterMapping)
    for i in range(len(cipherword)):
        if candidate[i] not in letterMapping[cipherword[i]]:
            letterMapping[cipherword[i]].append(candidate[i])
    return letterMapping


def intersectMappings(mapA, mapB):
    # To intersect two maps, create a blank map, and then add only the
    # potential decryption letters if they exist in BOTH maps.
    intersectedMapping = getBlankCipherletterMapping()
    for letter in LETTERS:

        # An empty list means "any letter is possible". In this case just
        # copy the other map entirely.
        if mapA[letter] == []:
            intersectedMapping[letter] = copy.deepcopy(mapB[letter])
        elif mapB[letter] == []:
            intersectedMapping[letter] = copy.deepcopy(mapA[letter])
        else:
            # If a letter in mapA[letter] exists in mapB[letter], add
            # that letter to intersectedMapping[letter].
            for mappedLetter in mapA[letter]:
                if mappedLetter in mapB[letter]:
                    intersectedMapping[letter].append(mappedLetter)

    return intersectedMapping


def removeSolvedLettersFromMapping(letterMapping):
    # Cipher letters in the mapping that map to only one letter are
    # "solved" and can be removed from the other letters.
    # For example, if "A" maps to potential letters ["M", "N"], and "B"
    # maps to ["N"], then we know that "B" must map to "N", so we can
    # remove "N" from the list of what "A" could map to. So "A" then maps
    # to ["M"]. Note that now that "A" maps to only one letter, we can
    # remove "M" from the list of letters for every other
    # letter. (This is why there is a loop that keeps reducing the map.)
    letterMapping = copy.deepcopy(letterMapping)
    loopAgain = True
    while loopAgain:
        # First assume that we will not loop again:
        loopAgain = False

        # solvedLetters will be a list of uppercase letters that have one
        # and only one possible mapping in letterMapping
        solvedLetters = []
        for cipherletter in LETTERS:
            if len(letterMapping[cipherletter]) == 1:
                solvedLetters.append(letterMapping[cipherletter][0])

        # If a letter is solved, than it cannot possibly be a potential
        # decryption letter for a different ciphertext letter, so we
        # should remove it from those other lists.
        for cipherletter in LETTERS:
            for s in solvedLetters:
                if len(letterMapping[cipherletter]) != 1 and s in letterMapping[cipherletter]:
                    letterMapping[cipherletter].remove(s)
                    if len(letterMapping[cipherletter]) == 1:
                        # A new letter is now solved, so loop again.
                        loopAgain = True
    return letterMapping


def hackSimpleSub(message):
    intersectedMap = getBlankCipherletterMapping()
    cipherwordList = nonLettersOrSpacePattern.sub("", message.upper()).split()
    for cipherword in cipherwordList:
        # Get a new cipherletter mapping for each ciphertext word.
        newMap = getBlankCipherletterMapping()

        wordPattern = makeWordPatterns.getWordPattern(cipherword)
        if wordPattern not in wordPatterns.allPatterns:
            continue # This word was not in our dictionary, so continue.

        # Add the letters of each candidate to the mapping.
        for candidate in wordPatterns.allPatterns[wordPattern]:
            newMap = addLettersToMapping(newMap, cipherword, candidate)

        # Intersect the new mapping with the existing intersected mapping.
        intersectedMap = intersectMappings(intersectedMap, newMap)

    # Remove any solved letters from the other lists.
    return removeSolvedLettersFromMapping(intersectedMap)


def decryptWithCipherletterMapping(ciphertext, letterMapping):
    # Return a string of the ciphertext decrypted with the letter mapping,
    # with any ambiguous decrypted letters replaced with an _ underscore.

    # First create a simple sub key from the letterMapping mapping.
    key = ["x"] * len(LETTERS)
    for cipherletter in LETTERS:
        if len(letterMapping[cipherletter]) == 1:
            # If there"s only one letter, add it to the key.
            keyIndex = LETTERS.find(letterMapping[cipherletter][0])
            key[keyIndex] = cipherletter
        else:
            ciphertext = ciphertext.replace(cipherletter.lower(), "_")
            ciphertext = ciphertext.replace(cipherletter.upper(), "_")
    key = "".join(key)

    # With the key we"ve created, decrypt the ciphertext.
    return simpleSubCipher2.decryptMessage(key, ciphertext)


if __name__ == "__main__"
    main()

如果使用这个代码，就无法破解．
看我跑这段代码的结果．

./simpleSubHacker2.py
Hacking...
Mapping:
{' ': [],
 '!': [],
 '"': [],
 '#': [],
 '$': [],
 '%': [],
 '&': [],
 "'": [],
 '(': [],
 ')': [],
 '*': [],
 '+': [],
 ',': [],
 '-': [],
 '.': [],
 '/': [],
 '0': [],
 '1': [],
 '2': [],
 '3': [],
 '4': [],
 '5': [],
 '6': [],
 '7': [],
 '8': [],
 '9': [],
 ':': [],
 ';': [],
 '<': [],
 '=': [],
 '>': [],
 '?': [],
 '@': [],
 'A': ['E'],
 'B': ['Y', 'P', 'B'],
 'C': ['R'],
 'D': [],
 'E': ['W'],
 'F': ['B', 'P'],
 'G': ['B', 'Q', 'X', 'P', 'Y'],
 'H': ['P', 'Y', 'K', 'X', 'B'],
 'I': ['H'],
 'J': ['T'],
 'K': [],
 'L': ['A'],
 'M': ['L'],
 'N': ['M'],
 'O': ['D'],
 'P': ['O'],
 'Q': ['V'],
 'R': ['S'],
 'S': ['I'],
 'T': ['U'],
 'U': ['G'],
 'V': [],
 'W': ['C'],
 'X': ['N'],
 'Y': ['F'],
 'Z': ['Z'],
 '[': [],
 '\\': [],
 ']': [],
 '^': [],
 '_': [],
 '`': [],
 'a': [],
 'b': [],
 'c': [],
 'd': [],
 'e': [],
 'f': [],
 'g': [],
 'h': [],
 'i': [],
 'j': [],
 'k': [],
 'l': [],
 'm': [],
 'n': [],
 'o': [],
 'p': [],
 'q': [],
 'r': [],
 's': [],
 't': [],
 'u': [],
 'v': [],
 'w': [],
 'x': [],
 'y': [],
 'z': [],
 '{': [],
 '|': [],
 '}': [],
 '~': []}

Original ciphertext:
Sy l nlx sr pyyacao l ylwj eiswi upar lulsxrj isr sxrjsxwjr, ia esmm rwctjsxsza sj wmpramh, lxo txmarr jia aqsoaxwa sr pqaceiamnsxu, ia esmm caytra jp famsaqa sj. Sy, px jia pjiac ilxo, ia sr pyyacao rpnajisxu eiswi lyypcor l calrpx ypc lwjsxu sx lwwpcolxwa jp isr sxrjsxwjr, ia esmm lwwabj sj aqax px jia rmsuijarj aqsoaxwa. Jia pcsusx py nhjir sr agbmlsxao sx jisr elh. -Facjclxo Ctrramm

Copying hacked message to clipboard: