第二章——古典密码学及算法实现

凯撒加密

凯撒加密算法实现：

# 凯撒密码加密函数
def caesar_encrypt():
    string = ['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']
    # 密文列表
    cipher_text_list = []
    cipher = int(input("请输入你的密钥:"))
    plain_text = input("请输入你的明文:")

    length = len(plain_text)

    print("加密后的密文是：")
    for i in range(0,length):
        cipher_text_list.append(string[string.index(plain_text[i])+cipher])
        print(cipher_text_list[i],end="")

# 凯撒密码解密函数
def caesar_decrypt():
    string = ['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']
    # 明文列表
    plain_text_list = []
    cipher = int(input("请输入你的密钥："))
    ciphertext = input("请输入你的密文:")
    length = len(ciphertext)

    print("解密后的明文是：")
    for i in range(0,length):
        plain_text_list.append(string[string.index(ciphertext[i])-cipher])
        print(plain_text_list[i],end="")

Playfair密码（流密码）

基于一个5×5字母矩阵。
该矩阵使用一个关键词（密钥）来构造。
构造方法：从左至右，从上至下依次填入关键词的字母（去除重复的字母），然后再以字母表顺序依次填入其他的字母。字母I和J被算作一个字母。

原理

P1、P2同行：对应的C1和C2分别是紧靠P1、P2右端的字母。其中第一列被看作是最后一列的右方。（解密时反向）
P1、P2同列：对应的C1和C2分别是紧靠P1、P2下方的字母。其中第一行看作是最后一行的下方。（解密时反向）
P1、P2不同行、不同列：C1和C2是由P1和P2确定的矩形的其它两角的字母，并且C1和P1、C2和P2同行。（解密时处理方法相同）
P1＝P2：则插入一个字母于重复字母之间，并用前述方法处理。
若明文字母数为奇数时：则在明文的末端添加某个事先约定的字母作为填充。

Playfair密码—例子

密钥是：PLAYFAIR IS A DIGRAM CIPHER。
如果明文是：P＝playfair cipher
明文两个一组： pl ay fa ir ci ph er
对应密文为: LA YF PY RS MR AM CD

Playfair密码的解密

Playfair密码，加密时把字母i和j看作是同一个字符，解密时通过解密时得到明文的意义来区别字母i和j。

Playfair密码的特点：

1.有676（26*26）种双字母组合，因此识别各种双字母组合要困难得多。

2.各个字母组的频率要比单字母呈现出大得多的范围，使得频率分析困难得多。

3.Playfair密码仍然使许多明文语言的结构保存完好，使得密码分析者能够利用。

Playfair加密算法实现：

# Playfair密码
 
#（创建密钥矩阵的算法小部分参考了其他人的做法，具体加解密核心代码则为原创）
# 字母表
letter_list = 'ABCDEFGHIKLMNOPQRSTUVWXYZ'
 
# 移除字符串中重复的字母
def remove_duplicates(key):
    key = key.upper()   # 转成大写字母组成的字符串
    _key = ''
    for ch in key:
        if ch == 'J':
            ch = 'I'
        if ch in _key:
            continue
        else:
            _key += ch
    return _key
 
# 根据密钥建立密码表
def create_matrix(key):
    key = remove_duplicates(key)  # 移除密钥中的重复字母
    key = key.replace(' ', '')  # 去除密钥中的空格
 
    for ch in letter_list:  # 根据密钥获取新组合的字母表
        if ch not in key:
            key += ch
    # 密码表
    keys = [[i for j in range(5)] for i in range(5)]
    for i in range(len(key)):  # 将新的字母表里的字母逐个填入密码表中，组成5*5的矩阵
        keys[i // 5][i % 5] = key[i]  # j用来定位字母表的行
    return keys
 
# 获取字符在密码表中的位置
def get_matrix_index(ch, keys):
    for i in range(5):
        for j in range(5):
            if ch == keys[i][j]:
                return i, j   # i为行，j为列
 
def get_ctext(ch1, ch2, keys):
    index1 = get_matrix_index(ch1, keys)
    index2 = get_matrix_index(ch2, keys)
    r1, c1, r2, c2 = index1[0], index1[1], index2[0], index2[1]
    if r1 == r2:
        ch1 = keys[r1][(c1+1) % 5]
        ch2 = keys[r2][(c2+1) % 5]
    elif c1 == c2:
        ch1 = keys[(r1+1) % 5][c1]
        ch2 = keys[(r2+1) % 5][c2]
    else:
        ch1 = keys[r1][c2]
        ch2 = keys[r2][c1]
    text = ''
    text += ch1
    text += ch2
    return text
 
def get_ptext(ch1, ch2, keys):
    index1 = get_matrix_index(ch1, keys)
    index2 = get_matrix_index(ch2, keys)
    r1, c1, r2, c2 = index1[0], index1[1], index2[0], index2[1]
    if r1 == r2:
        ch1 = keys[r1][(c1-1) % 5]
        ch2 = keys[r2][(c2-1) % 5]
    elif c1 == c2:
        ch1 = keys[(r1-1) % 5][c1]
        ch2 = keys[(r2-1) % 5][c2]
    else:
        ch1 = keys[r1][c2]
        ch2 = keys[r2][c1]
    text = ''
    text += ch1
    text += ch2
    return text
 
def playfair_encode(plaintext, key):
    plaintext = plaintext.replace(" ", "")
    plaintext = plaintext.upper()
    plaintext = plaintext.replace("J", "I")
    plaintext = list(plaintext)
    plaintext.append('#')
    plaintext.append('#')
 
    keys = create_matrix(key)
    ciphertext = ''
    i = 0
    while plaintext[i] != '#':
        if plaintext[i] == plaintext[i+1]:
            plaintext.insert(i+1, 'X')
        if plaintext[i+1] == '#':
            plaintext[i+1] = 'X'
        ciphertext += get_ctext(plaintext[i], plaintext[i+1], keys)
        i += 2
    return ciphertext
 
def playfair_decode(ciphertext, key):
    keys = create_matrix(key)
    i = 0
    plaintext = ''
    while i < len(ciphertext):
        plaintext += get_ptext(ciphertext[i], ciphertext[i+1], keys)
        i += 2
    _plaintext = ''
    _plaintext += plaintext[0]
    for i in range(1, len(plaintext)-1):
        if plaintext[i] != 'X':
            _plaintext += plaintext[i]
        elif plaintext[i] == 'X':
            if plaintext[i-1] != plaintext[i+1]:
                _plaintext += plaintext[i]
    _plaintext += plaintext[-1]
    _plaintext = _plaintext.lower()
    return _plaintext
 
 
# plaintext = 'balloon'
# key = 'monarchy'
plaintext = input('明文：')
key = input('密钥：')
ciphertext = playfair_encode(plaintext, key)
print('加密后的密文：' + ciphertext)
plaintext = playfair_decode(ciphertext, key)
print('解密后的明文：' + plaintext)

Vigenere密码（流密码）

原理

16世纪法国数学家Blaise de Vigenere于1568年发明的，是著名的多表代替密码的例子

使用一个词组作为密钥，密钥中的每一个字母用来确定一个代替表，每一个密钥字母被用来加密一个明文字母。等所有的密钥字母使用完后，密钥再循环使用.

若明文序列为

密钥序列为：

则密文序列为:

这也是序列密码的一般加密形式

Vigenere密码——例子

明文：She is listening.
密钥：Pascal。

Vigenere密码可以看做若干个加法密码的联合

Vigenere密码加解密算法实现：

ef VigenereEncrypto(message, key):
    msLen = len(message)
    keyLen = len(key)
    message = message.upper()
    key = key.upper()
    raw = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"# 明文空间
    # 定义加密后的字符串
    ciphertext = ""
    # 开始加密
    for i in range(0, msLen):
        # 轮询key的字符
        j = i % keyLen
        # 判断字符是否为英文字符，不是则直接向后面追加且继续
        if message[i] not in raw:
            ciphertext += message[i]
            continue
        encodechr = chr((ord(message[i]) - ord("A") + ord(key[j]) - ord("A")) % 26 + ord("A"))
        # 追加字符
        ciphertext += encodechr
    # 返回加密后的字符串
    return ciphertext
if __name__ == "__main__":
    message = "Hello, World!"
    key = "key"
    text = VigenereEncrypto(message, key)
    print(text)
def VigenereDecrypto(ciphertext, key):
    msLen = len(ciphertext)
    keyLen = len(key)
    key = key.upper()
    raw = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"# 密文空间
    plaintext = ""
    for i in range(0, msLen):# 开始解密
        # 轮询key的字符
        j = i % keyLen
        # 判断字符是否为英文字符，不是则直接向后面追加且继续
        if ciphertext[i] not in raw:
            plaintext += ciphertext[i]
            continue
        decodechr = chr((ord(ciphertext[i]) - ord("A") - ord(key[j]) - ord("A")) % 26 + ord("A"))
        # 追加字符
        plaintext += decodechr
    # 返回加密后的字符串
    return plaintext
if __name__=="__main__":
    ciphertext = "RIJVS, AMBPB!"
    key = "key"
    text = VigenereDecrypto(ciphertext, key)
    print(text)
import VigenereDecrypto
import VigenereEncrypto
def main():
    info = '''==========********=========='''# 开始加密
    print(info, "\n------维吉尼亚加密算法------")
    print(info)
    # 读取测试文本文档
    message = open("test.txt","r+").read()
    print("读取测试文本文档:test.txt")
    print("开始加密！")
    # 输入key
    key = input("请输入密钥：")
    # 进入加密算法
    CipherText = VigenereEncrypto.VigenereEncrypto(message, key)
    # 写入密文文本文档
    C = open("CipherText.txt", "w+")
    C.write(CipherText)
    C.close()
    print("加密后得到的密文是: \n" + CipherText)
    # 开始解密
    print(info, "\n------维吉尼亚解密算法------")
    print(info)
    # 读取加密文本文档
    print("读取密文文本文档：CipherText.txt")
    Ciphertext = open("CipherText.txt", "r+").read()
    # 进入解密算法
    print("开始解密！")
    Plaintext = VigenereDecrypto.VigenereDecrypto(Ciphertext, key)
    P = open("PlainText.txt", "w+")
    # 写入解密文本文档
    P.write(Plaintext)
    P.close()
    print("解密后得到的明文是 : \n" + Plaintext)
if __name__=="__main__":
    main()

Hill密码：（分组密码）

原理：

1.输入矩阵K
2.求det(K)取mod 26, 即K1=mod(det(K),26)=25
3.求K1的逆元，即25-1mod26=25
4.求伴随矩阵，K2=inv(K)*det(K)
5.求逆矩阵, K3=K2.*25 (这里K1-1mod26=25)
6.取模 mod(K3,26)

疑问：既然能直接能函数求逆矩阵，那为什么还要用（行列式逆元*伴随矩阵）求逆矩阵呢？

由公式1可以知道求逆矩阵时需要用到行列式逆元，但是公式用的是行列式的倒数（线性代数），所以需要多求一下。

Hill加密算法实现：

# -*- coding: utf-8 -*-
"""
Created on Tue Oct 10 16:09:37 2023

@author: lenovo
"""

import numpy as np

# 求在模m下任意一个数的乘法逆元
def Multi_Inverse(x,m):
    # 输入：求一个数x在模m下的乘法逆元
    # y的取值范围为[0,m)
    y = 0
    while(y < m):
        res = (x * y) % m
        if res == 1:
            print("在模%d下,加密密钥行列式值为%d，它的乘法逆元为%d" % (m,x,y))
            break
        else:
            y = y + 1
            if y == m:
                print(x,"在模",m,"下，不存在乘法逆元!")
                return 0
    return y

# 求伴随矩阵
def Adjoint_Mat(K,K_det,m):
    # 输入：矩阵K，矩阵的行列式值K_det，模m
    # 对K矩阵求逆，得到K的逆矩阵K1
    K1 = np.linalg.inv(K)
    # 求K矩阵的伴随矩阵
    K2 = K1 * K_det % m
    # 由于伴随矩阵得到的可能是浮点数矩阵，故需要对其进行四舍五入取整
    # 并将每个元素成员强制转换为int类型
    K2 = np.around(K2)
    K2 = K2.astype(np.int)
    return K2

# 求解密密钥k
def Decrypt_Key(K,m):
    # 求K矩阵的行列式值det(K)，模m
    K_det = np.linalg.det(K)
    K2 = Adjoint_Mat(K, K_det, m)
    # 求det(K)在模26下的乘法逆元
    y = Multi_Inverse(K_det, m)
    # 求Hill加密的解密秘钥
    K3 = y * K2 % m
    return K3

# 将矩阵(二维数组)ascii码转字符
def ascii2_char(array1):
    plaintext = ''
    row = array1.shape[0]
    col = array1.shape[1]
    for i in range(row):
        for j in range(col):
            plaintext = plaintext + chr(array1[i][j])
    return plaintext

# 将明文转换为ascii码值矩阵，行数与加密密钥保持一致
def char2ascii2(plaintext,row,m):
    # 输入：明文plaintext，加密矩阵的行数row,模m
    l1 = [0,0,0]
    l2 = []
    for i in range(len(plaintext)):
        j = i % row  #多少行（一列多少个元素）说明每个分组有多少个元素
        if (i > 0 and i % row == 0):
            l2.append(l1)
            l1 = [0, 0, 0]
        l1[j] = ord(plaintext[i])
    print('中间变量l1：',l1)
    l2.append(l1)
    print('中间变量l2：',l2)
    m1 = np.array(l2)
# =============================================================================
#   np.array()的作用就是把列表转化为数组，也可以说是用来产生数组
# =============================================================================
    print('中间变量m1：',m1)
    m1 = np.reshape(m1,(m1.shape[1],m1.shape[0]))
# =============================================================================
#   reshape函数：将二维数组m1转换成另一个二维数组，形状为（m1.shape[1],m1.shape[0]）即（3，10）
# =============================================================================
    print('中间变量m1_',m1)
    m1 = m1 % m
    return m1

if __name__ == "__main__":
    # K矩阵,即加密密钥
    K = np.array([[17,17,5],[21,18,21],[2,2,19]], dtype=int)
    # 解密密钥k，模m
    m = 256
    k = Decrypt_Key(K,m)
    print("Hill密码的解密秘钥为:\n",k)

    # 明文
    plaintext = 'Programming is a happy thing'
    print("原始明文内容:\n",plaintext)

    
    row = K.shape[0] # shape()函数求加密密钥矩阵K的行数row
    # 将明文转换为ascii码值矩阵，行数与加密密钥保持一致
    # m1为明文ascii码值矩阵
    m1 = char2ascii2(plaintext,row,m)
    print('明文矩阵:\n',m1)
    # 加密过程，m2为加密后的矩阵
    m2 = np.dot(K,m1) % 256
# =============================================================================
#     矩阵积计算不遵循交换律，np.dot(a,b)和np.dot(b,a)得到的结果是不同的
# =============================================================================
    Ciphertext = ascii2_char(m2)
    print("密文内容:\n",Ciphertext)

    # 解密过程，m3为加密后的矩阵
    m3 = np.dot(k,m2) % 256
    decrypt_text = ascii2_char(m3)
    print("解密结果:\n", decrypt_text)

明文矩阵过程类似下面，但上面代码中明文字符排列顺序为：从左到右，从上到下

下面例子中明文字符排列顺序为：从上到下，从左到右