目录

A

1、 题目

2、 基本假设

3、 算法

4、 加密过程

5、 解密过程

6、 测试及结果

附录：

1、 A

A

1. 题目

1. 基本假设

1.字母a-z分别对应1-26.

2.meet会被转化为2个2维的列矩阵。

3.加密解密只考虑字母a-z，并不包含其他符号，将计算得到的矩阵的每一个元素模26。

1. 算法

希尔密码的加密步骤:

1.将明文转化为数字矩阵

第一步是将给定的明文转化为明文数字矩阵，首先按照a-z分别映射到1-26的方式，将原文字母映射为数字，并且将得到的数字序列根据密钥的维度排列成明文矩阵。

2.计算矩阵乘法

第二步，做矩阵模乘法，即现将两矩阵相乘，再将所得结果每个元素均除N取余，加密字符集仅涉及26个字母.

3 将密文矩阵转化为密文

希尔密码的解密

1 计算密钥矩阵的模N行列式

计算给定的密钥矩阵K KK的行列式，然后将所得行列式的值除以N取余。

2 计算行列式模N乘法逆元

3 计算密钥矩阵的伴随矩阵

4 计算密钥矩阵的模N逆矩阵

5 解密:让密文乘上一步骤中解得的逆矩阵，就可以得到解密的明文

1. 加密过程

1. 解密过程

1. 测试及结果

利用python算法进行解密和加密：

import numpy as np

key = np.array(
    [[1, 0],
    [2, 5]], dtype=np.int16
)
dim_key = 2


# 字母转化为数字（不区分大小写）
def char2int(c):
    a = ord(c)
    if ord('a') <= a <= ord('z'):
        return a-96
    else:
        return a-64


# 数字转化为大写字母
def int2char(c):
    return chr(c+64)


def encrypt(s):
    col_p = dim_key
    row_p = len(s) // dim_key
    if len(s) % dim_key != 0:
        row_p += 1

    # 转化为矩阵，不足补零
    p = np.zeros((row_p, col_p), dtype=np.int16)
    for i in range(len(s)):
        p[i//col_p, i%col_p] = char2int(s[i])

    c = np.matmul(p, key) % 26

    result = ""
    for i in range(row_p):
        for j in range(col_p):
            result += int2char(c[i, j])
    return result


def modular_inv(a, p):
    x, y, m = 1, 0, p
    while a > 1:
        q = a // m
        t = m

        m = np.mod(a, m)
        a = t
        t = y

        y, x = x - np.int64(q) * np.int64(y), t

        if x < 0:
            x = np.mod(x, p)
    return np.mod(x, p)


def decode(s):
    col_c = dim_key
    row_c = len(s) // dim_key

    # 转化为矩阵，不足补零
    c = np.zeros((row_c, col_c), dtype=np.int16)
    for i in range(len(s)):
        c[i // col_c, i % col_c] = char2int(s[i])

    det_k = np.linalg.det(key)
    det_k_inv = modular_inv(det_k % 26, 26)

    k_ = np.linalg.inv(key)
    k_ = np.around(k_ * det_k).astype(np.int64)

    k_inv = (det_k_inv * k_) % 26

    p = np.matmul(c, k_inv) % 26

    result = ""
    for i in range(row_c):
        for j in range(col_c):
            result += int2char(p[i, j])
    return result


if __name__ == "__main__":
    c = encrypt("meet")
    print(c)

    p = decode(c)
    print(p)

加密以及解密结果：

图1 meet的加密以及解密结果

附录：

1. A

1.利用python算法进行解密和加密：

import numpy as np

key = np.array(
    [[1, 0],
    [2, 5]], dtype=np.int16
)
dim_key = 2


# 字母转化为数字（不区分大小写）
def char2int(c):
    a = ord(c)
    if ord('a') <= a <= ord('z'):
        return a-96
    else:
        return a-64


# 数字转化为大写字母
def int2char(c):
    return chr(c+64)


def encrypt(s):
    col_p = dim_key
    row_p = len(s) // dim_key
    if len(s) % dim_key != 0:
        row_p += 1

    # 转化为矩阵，不足补零
    p = np.zeros((row_p, col_p), dtype=np.int16)
    for i in range(len(s)):
        p[i//col_p, i%col_p] = char2int(s[i])

    c = np.matmul(p, key) % 26

    result = ""
    for i in range(row_p):
        for j in range(col_p):
            result += int2char(c[i, j])
    return result


def modular_inv(a, p):
    x, y, m = 1, 0, p
    while a > 1:
        q = a // m
        t = m

        m = np.mod(a, m)
        a = t
        t = y

        y, x = x - np.int64(q) * np.int64(y), t

        if x < 0:
            x = np.mod(x, p)
    return np.mod(x, p)


def decode(s):
    col_c = dim_key
    row_c = len(s) // dim_key

    # 转化为矩阵，不足补零
    c = np.zeros((row_c, col_c), dtype=np.int16)
    for i in range(len(s)):
        c[i // col_c, i % col_c] = char2int(s[i])

    det_k = np.linalg.det(key)
    det_k_inv = modular_inv(det_k % 26, 26)

    k_ = np.linalg.inv(key)
    k_ = np.around(k_ * det_k).astype(np.int64)

    k_inv = (det_k_inv * k_) % 26

    p = np.matmul(c, k_inv) % 26

    result = ""
    for i in range(row_c):
        for j in range(col_c):
            result += int2char(p[i, j])
    return result


if __name__ == "__main__":
    c = encrypt("meet")
    print(c)

    p = decode(c)
    print(p)