Vigenere密码破解

Vigenere Cipher Crack Report

Vigenere Cipher System

Plaintext $P=(p_1,p_2,\cdots ,p_n)$
Ciphertext $C=(c_1,c_2,\cdots ,c_n)$
Key $K=(k_1,k_2,\cdots ,k_n)$

Encryption:
$$c_i=E_{k,i}(p_i)=(p_i+k_i)\mathrm{m}\mathrm{o}\mathrm{d}26$$

Decryption:
$$p_i=D_{k,i}(c_i)=(c_i-k_i)\mathrm{m}\mathrm{o}\mathrm{d}26$$

Crack steps

The Vigenere Cipher is a special form of the Caesar Cipher, so it can be cracked using word frequency analysis.

FREQ = [0.08167, 0.01492, 0.02782, 0.04253, 0.12702, 0.02228, 0.02015,
        0.06094, 0.06966, 0.00153, 0.00772, 0.04025, 0.02406, 0.06749,
        0.07507, 0.01929, 0.00095, 0.05987, 0.06327, 0.09056, 0.02758,
        0.00978, 0.02360, 0.00150, 0.01974, 0.00074]

Determine key length

Let’s assume a language consist of $n$ letters, for example english consists of 26 letters. The probability of each letter occurring is $P_i$, then the coincidence index is the sum of the probabilities that two random elements are the same, denoted as $\text{CI}={\sum }_{i=1}^n{P}_i^2$. For example, totally random English text’s $\text{CI}={\sum }_{i=1}^{26}{\frac{1}{26}}^2=0.0385$. However, according to the frequency table above, a meaningful English text’s $\text{CI}=0.065$. So, for the cipher text of length $L$, $\text{CI}={\sum }_{i=1}^{26}\frac{f_i}{L}\cdot \frac{f_i-1}{L-1}$, where $f_i$ is the number of occurrences of the i-th letter.

def CoincidenceIndex(cipherText):
    N = len(cipherText)
    fsum = 0
    for letter in ALPHABET:
        num = cipherText.count(letter)
        fsum += num*(num-1)
    CI = fsum/(N*(N-1))
    return CI

We use the Coincidence Index method to determine the length. If the key has length of $K$, then we can split the cipher text into $K$ parts, and compute the $\text{CI}$ respectively, which will generate $K^{\prime }s$ $\text{CI}$. We choose the key whose mean of $\text{CI}$s closest to 0.065. However, sometimes, when the key length is $K$, the key of length $2K$ may also have the similar result, so we choose the top 2 closest to 0.065, if they’re divisible, choose the smaller one as the key length. In fact, if we only want to decrypt the encrypted ciphertext, there is no different whether the key length is $K$, $2K$, or $nK$.

def inferenceLength(cipherText):
    CIs = np.zeros(MAXLENGTH, dtype=np.float32)
    for l in range(1, MAXLENGTH+1):
        CI = 0
        for i in range(l):
            CI += CoincidenceIndex(cipherText[i::l])
        CIs[l-1] = CI/l
    indices = np.argsort(np.fabs(0.065 - CIs), axis=0)+1
    top_1, top_2 = indices[:2]
    if (top_1%top_2==0):
        return top_2
    return top_1

Determine key

Now with the length of key, we can crack the specific key contents with CI method. For the key of length $K$, we can split the cipher text to $K$ parts, and each part is a simple Caesar Cipher. We only need to determine the shift one by one part. For a single Caesar Cipher, we can use $\text{CI}={\sum }_{i=1}^{26}\frac{f_i}{L}{F}_i$ to determine shift, where $F_i$ is the i-th letter’s frequency of FREQ table above.

def CIfreq(sequence, shift=0):
    CI = 0
    freq = [*FREQ[-shift:], *FREQ[:-shift]]
    for letter in ALPHABET:
        num = sequence.count(letter)
        CI += num*freq[ord(letter)-ord('a')]
    return CI

For each cipher text part, we sequential cyclic shift the FREQ table and record the corresponding $\text{CI}$. We choose the largest one’s shift as offset or key. Strictly speaking, it should be the one closest to 0.065, however, the value will not exceed 0.065 theoretically.

def inferenceKey(cipherText):
    length = inferenceLength(cipherText)
    key = ""
    for i in range(length):
        CIs = np.zeros(26, dtype=np.float32)
        for _ in range(26):
            CIs[_] = CIfreq(cipherText[i::length], _)
        key += chr(ord("a")+CIs.argmax())
    return key

Now, we get the KEY, which means we have cracked the Vigenere Cipher System. Then simply apply decryption operation to get plain text.

keyLen = len(key)
result = []
i = 0
for c in cipherText:
    if "a"<=c<="z":
        p = (ord(c) - ord(key[i%keyLen]) + 26)%26 + ord("a")
        result.append(chr(p))
        i += 1
    else:
        result.append(c)