替换密码

替代密码是指先建立一个替换表，加密时将需要加密的明文依次通过查表，替换为相应的字符，明文字符被逐个替换后，生成无任何意义的字符串，即密文，替代密码的密钥就是其替换表 。

分为单表替换与多表替换，此处讨论单表替换

加密解密实例：

# Simple Substitution Cipher
# http://inventwithpython.com/hacking (BSD Licensed)

import pyperclip, sys, random


LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

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'
    myMode = 'encrypt' # set to 'encrypt' or 'decrypt'

    checkValidKey(myKey)

    if myMode == 'encrypt':
        translated = encryptMessage(myKey, myMessage)
    elif myMode == 'decrypt':
        translated = decryptMessage(myKey, myMessage)
    print('Using key %s' % (myKey))
    print('The %sed message is:' % (myMode))
    print(translated)
    pyperclip.copy(translated)
    print()
    print('This message 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 where 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

    return translated


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


if __name__ == '__main__':
    main()

破译方法：

对于单表替换密文与原文字母的字母是 一 一 对应的，所以可以统计出每个每个单词的格式 如：name:0,1,2,3   apple:0,1,1,2,3。 此处称为单词模式

从词典得到单词结构，再与密文单词相互对应，最终统计到每一个密文与原文的对应关系

1. 找出密文里每个单词的单词模式
2. 找出每个密词可以解密成哪些英文单词
3. 使用密词的候选单词列表为每个密词创建一个密字映射。（密字映射是字典值）
4. 计算所有的密字交集，得到唯一的交集映射
5. 从交集密字映射移除任何已破解的字母

消息越长越有可能被破译

# Makes the wordPatterns.py File
# http://inventwithpython.com/hacking (BSD Licensed)

# Creates wordPatterns.py based on the words in our dictionary
# text file, dictionary.txt. (Download this file from
# http://invpy.com/dictionary.txt)

import pprint


def getWordPattern(word):
    # Returns a string of the pattern form of the given word.
    # e.g. '0.1.2.3.4.1.2.3.5.6' for 'DUSTBUSTER'
    word = word.upper()
    nextNum = 0
    letterNums = {}
    wordPattern = []

    for letter in word:
        if letter not in letterNums:
            letterNums[letter] = str(nextNum)
            nextNum += 1
        wordPattern.append(letterNums[letter])
    return '.'.join(wordPattern)


def main():
    allPatterns = {}

    fo = open('dictionary.txt')
    wordList = fo.read().split('
')
    fo.close()

    for word in wordList:
        # Get the pattern for each string in wordList.
        pattern = getWordPattern(word)

        if pattern not in allPatterns:
            allPatterns[pattern] = [word]
        else:
            allPatterns[pattern].append(word)

    # This is code that writes code. The wordPatterns.py file contains
    # one very, very large assignment statement.
    fo = open('wordPatterns.py', 'w')
    fo.write('allPatterns = ')
    fo.write(pprint.pformat(allPatterns))
    fo.close()


if __name__ == '__main__':
    main()

然后导入之前的文件并破解

# Simple Substitution Cipher Hacker
# http://inventwithpython.com/hacking (BSD Licensed)

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

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

LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
nonLettersOrSpacePattern = re.compile('[^A-Zs]')

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.
    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 simpleSubCipher.decryptMessage(key, ciphertext)


if __name__ == '__main__':
    main()

此方法密钥为一张对应表，不易记，可用一句话作为密钥，用程序处理后再用于加密

def makeSimpleSubKey(keyword):
    # create the key from the keyword
    newKey = ''
    keyword = keyword.upper()
    keyAlphabet = list(simpleSubCipher.LETTERS)
    for i in range(len(keyword)):
        if keyword[i] not in newKey:
            newKey += keyword[i]
            keyAlphabet.remove(keyword[i])
    key = newKey + ''.join(keyAlphabet)
    return key

# Simple Substitution Dictionary Hacker, http://inventwithpython.com/hacking (BSD Licensed)
import pyperclip, simpleSubKeyword, detectEnglish

SILENT_MODE = False

def main():
    myMessage = r"""SJITDOPIQR: JIR RIQMUNQRO AY P WDQC QCR NRSMRQN JT A SJITDORO QJ CRMNRGT AY S. -PHAMJNR ADRMSR"""

    brokenCiphertext = hackSimpleSubDictionary(myMessage)

    if brokenCiphertext == None:
        # hackSimpleSubDictionary() will return the None value if it was unable to hack the encryption.
        print('Hacking failed. Unable to hack this ciphertext.')
    else:
        # The plaintext is displayed on the screen. For the convenience of the user, we copy the text of the code to the clipboard.
        print('Copying broken ciphertext to clipboard:')
        print(brokenCiphertext)
        pyperclip.copy(brokenCiphertext)


def hackSimpleSubDictionary(message):
    print('Hacking with %s possible dictionary words...' % (len(detectEnglish.ENGLISH_WORDS) * 3))

    # Python programs can be stopped at any time by pressing Ctrl-C (on Windows) or Ctrl-D (on Mac and Linux)
    print('(Press Ctrl-C or Ctrl-D to quit at any time.)')

    tryNum = 1

    # brute-force by looping through every possible key
    for key in detectEnglish.ENGLISH_WORDS:
        if tryNum % 100 == 0 and not SILENT_MODE:
            print('%s keys tried. (%s)' % (tryNum, key))

        decryptedText = simpleSubKeyword.decryptMessage(key, message)

        if detectEnglish.getEnglishCount(decryptedText) > 0.20:
            # Check with the user to see if the decrypted key has been found.
            print()
            print('Possible encryption hack:')
            print('Key: ' + str(key))
            print('Decrypted message: ' + decryptedText[:100])
            print()
            print('Enter D for done, or just press Enter to continue hacking:')
            response = input('> ')

            if response.upper().startswith('D'):
                return decryptedText

        tryNum += 1
    return None

if __name__ == '__main__':
    main()

# Simple Substitution Cipher Editor, http://inventwithpython.com/hacking (BSD Licensed)

import textwrap, string, pyperclip

myMessage = ''
SYMBOLS = ''


def main(useText=None, useMapping=None):
    print('Simple Substitution Cipher Editor')

    while True:
        # Get the text to start editing:
        if useText == None:
            # start editing a new cipher
            print('Enter the cipher text you want to decrypt (or "quit"):')

            # Handle if the user wants to quit:
            ciphertext = input('> ').upper()
            if ciphertext == 'QUIT':
                return
        else:
            ciphertext = useText

        if useMapping == None:
            mapping = getBlankMapping() # start with a new, blank mapping.
        else:
            mapping = useMapping


        while True:
            # On each iteration of this loop, display the current translation
            # and let the user type in a command to perform.

            # Display the current translation:
            print('


')
            printMessage(ciphertext, mapping)
            printMapping(mapping)
            print('COMMANDS: Enter ciphertext letter to substitute, or "quit", "clear",')
            print('"copy message", "copy key", "enter key", or "new":')

            # Get a command from the user and perform it:
            command = input('> ').upper()
            if command == 'QUIT':
                return
            elif command == 'CLEAR':
                # reset the mapping to a new, blank mapping
                mapping = getBlankMapping()
            elif command == 'NEW':
                print('
' * 25) # print a huge gap
                break # break out of the inner loop
            elif command == 'COPY MESSAGE':
                pyperclip.copy(getTranslation(ciphertext, mapping))
                print('Copied the translated text to the clipboard.')
            elif command == 'COPY KEY':
                key = ''
                for letter in string.ascii_uppercase:
                    key += mapping[letter]
                pyperclip.copy(key)
                print('Copied the key to the clipboard.')
            elif command == 'ENTER KEY':
                pass # TODO
            else:
                # Assume the user is trying to suggest a ciphertext replacement:

                # get the ciphertext letter
                if len(command) != 1 or command not in string.ascii_uppercase:
                    print('Invalid character. Please specify a single letter.')
                    continue

                # get the letter that will replace this ciphertext letter
                print('Enter letter that %s should map to:' % command)
                mapToLetter = input('> ').upper()
                if mapToLetter == '':
                    # entering nothing means the user wants to reset that ciphertext letter
                    mapToLetter = '_'
                if len(mapToLetter) != 1 or mapToLetter not in string.ascii_uppercase + '_':
                    print('Invalid character. Please specify a single letter.')
                    continue

                # add this replacement letter to the current mapping
                mapping[command] = mapToLetter.lower()


def getTranslation(ciphertext, mapping):
    # Returns a string of the translation of ciphertext. Each character
    # in ciphertext is used as a key in mapping, and the returned
    # string uses the character that is the value for that key.
    result = ''
    for letter in ciphertext:
        if letter not in string.ascii_uppercase:
            result += letter
        else:
            result += mapping[letter]
    return result


def getBlankMapping():
    # Returns a dict with keys of the uppercase letters and values of
    # the string '_'.
    mapping = {}
    for letter in string.ascii_uppercase:
        mapping[letter] = '_'
    return mapping


def printMessage(ciphertext, mapping):
    # Print the cipher text, along with the translation according to the
    # current mapping. The text will never go past 80 characters in length
    # per line.

    # Split up the cipher text into lines of at most 80 characters in length,
    # and then put them in a list of these lines.
    wrappedText = textwrap.fill(ciphertext)
    lines = wrappedText.split('
')

    for line in lines:
        # Print each line of ciphertext, followed by its translation.
        print(line)
        print(getTranslation(line, mapping))
        print()


def printMapping(mapping):
    # Print the mapping in a user-friendly format.
    print('Current Key:')
    print('    ' + ' '.join(list(string.ascii_uppercase)))

    print('    ', end='')
    for letter in string.ascii_uppercase:
        print(mapping[letter] + ' ', end='')
    print()


if __name__ == '__main__':
    main()