John neo's blog https://www.gravatar.com/avatar/72982b319641c2b0f34019dfda466b76 2026-04-11T15:18:34.256Z https://www.chaincipher.cn/ John neo 2094456563@qq.com Hexo 一次 HTTPS 证书过期引发的排障与修复实战 https://www.chaincipher.cn/posts/771daf74.html 2026-04-11T13:34:57.000Z 2026-04-11T15:18:34.256Z 背景

在维护个人博客（基于 Hexo + Flask + Nginx + Gunicorn 架构）过程中，发现网站突然出现“不安全”提示。
经检查发现 HTTPS 证书已经过期，导致浏览器拒绝信任连接。
本文记录一次完整的排障与修复过程，以及其中踩过的坑和经验总结。

问题现象

访问网站：

1
https://chaincipher.cn

浏览器提示：

  • 证书已过期
  • 连接不安全

服务器执行：

1
certbot certificates

直接报错：

1
AttributeError: module 'lib' has no attribute 'OpenSSL_add_all_algorithms'

问题分析

表面问题

  • HTTPS 证书过期
  • certbot 工具无法正常运行

深层原因

报错核心：

1
OpenSSL_add_all_algorithms

说明：

系统 OpenSSL 与 Python 依赖库（pyOpenSSL / cryptography）发生冲突

原因可能包括：

  • 使用 pip 安装过相关库
  • 系统升级导致依赖不兼容

解决方案

移除旧版本 certbot

1
2
sudo apt remove certbot -y
sudo apt autoremove -y

使用 snap 安装官方版本 certbot

1
2
3
4
sudo snap install core
sudo snap refresh core
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot

验证安装

1
certbot --version

确保版本为：

1
certbot 2.x.x

重新申请证书

1
sudo certbot --nginx -d chaincipher.cn -d www.chaincipher.cn

执行结果：

1
2
Successfully deployed certificate
Your existing certificate has been successfully renewed

验证结果

浏览器验证

  • HTTPS 正常
  • 无安全警告
  • 小锁恢复

证书有效期检查

1
openssl x509 -in /etc/letsencrypt/live/chaincipher.cn/fullchain.pem -noout -dates

安全增强（进阶优化）

启用 HSTS

在 Nginx 配置中添加：

1
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

作用：

  • 强制浏览器始终使用 HTTPS
  • 防止降级攻击

自动续期验证

1
sudo certbot renew --dry-run

确保自动续期机制正常。

踩坑总结

问题1：certbot 无法运行

原因：

  • Python 环境依赖冲突
    解决：
  • 使用 snap 隔离环境

问题2：证书未自动续期

原因：

  • 定时任务未生效
    解决：
  • 使用 snap 版本自带自动续期

问题3：下载速度慢

原因：

  • snap 使用国外源
    解决：
  • 等待或使用代理

经验总结

  1. HTTPS 证书有效期为 90 天，必须依赖自动续期
  2. 避免混用 apt 和 pip 安装系统工具
  3. snap 提供更稳定的隔离环境
  4. Web 服务必须定期检查证书状态

总结

本次问题从表面上看是证书过期，实质上是系统环境冲突导致工具失效。
通过重新安装 certbot 并采用 snap 管理，成功恢复 HTTPS 服务。
这次排障让我更加理解了：

  • Linux 环境依赖管理
  • HTTPS 证书机制
  • Web 服务稳定性保障

后记

对于线上服务来说：

“能运行”远远不够，“能稳定运行”才是关键。
未来将继续完善自动化监控与安全机制，提升系统可靠性。

]]> 一次 HTTPS 证书过期引发的排障与修复实战 SM3加密-基于python无第三方库 https://www.chaincipher.cn/posts/6bbc19a5.html 2025-01-06T04:38:38.000Z 2025-01-06T04:55:09.695Z SM3是中国自主研发的哈希算法，适合生成数据摘要，安全性较高。（单向加密，不可逆加密）

基础知识

SM3基础知识及加解密算法流程pdf下载

python实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
# -*- coding: utf-8 -*-
"""
Created on Sat Dec 14 21:40:07 2024

SM3   对输入的明文采用utf-8编码
        对输出的密文采用十六进制编码

"""
#常量T
def T(j):
    if j>=0 and j<=15:
        return 0x79cc4519
    elif j>=16 and j<=63:
        return 0x7a879d8a
#布尔函数FF
def FF(X, Y, Z, j):
    if j>=0 and j<=15:
        result=X^Y^Z
        return result # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
    else:
        result=(X & Y) | (X & Z) | (Y & Z)
        return result # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
#布尔函数GG
def GG(X, Y, Z, j):
    if j>=0 and j<=15:
        result=X^Y^Z
        return result # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
    else:
        result=(X & Y) | (~X & Z)
        return result # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
#循环左移
def circular_left_shift(x_int, n): #将整数x循环左移n位
    """
    对32位整数x进行n位的循环左移
    :param x: 输入的整数 (8位16进制数)
    :param n: 左移的位数
    :return: 循环左移后的结果
    """
    #因为n可能会大于32，此时相当于循环左移n%32位，所以提前对n进行处理
    n=n%32
#   x_int=int(x,16) #将x转化为整数 eg. x从'0a'变成了 10
    result=((x_int << n) & 0xFFFFFFFF) | (x_int >> (32 - n)) #将x循环左移n位
#    return f"{result:08x}" # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
    return result
#置换函数P
def P0(X):
    result=X^circular_left_shift(X,9)^circular_left_shift(X,17)
    return result 
def P1(X):
    result=X^circular_left_shift(X,15)^circular_left_shift(X,23)
    return result
#将明文字符串转换为二进制位串
def string_to_bitstring(s):
    """
    将字符串转换为二进制位串
    :param s: 输入字符串
    :return: 由每个字符转换成的 8 位二进制数拼接成的字符串
    """
    result=''.join(format(ord(char), '08b') for char in s)
    return result
#添加填充位。使数据位长度为 448 bit , 剩余的 64 bit用于表示原始明文字符串长度 eg abc，占三字节 24 bit，故末尾的 64 bit表示 24 
def add_padding_bits(bitstring):
    bitstring_padding=bitstring+'1' #先在明文二进制位串后面补上1
    if len(bitstring_padding)>448: #若数据长度大于等于448，继续填充
        rule=(len(bitstring_padding)//512+1)*512+448 #填充后的长度
        while len(bitstring_padding)!=rule: #若数据长度不足mod512后不为418，则补0，直至数据长度满足mod512后为448
            bitstring_padding+='0' 
    else: #若数据长度小于448,则补0，使数据长度为448
        while len(bitstring_padding)!=448:
            bitstring_padding+='0'
    bitstring_hex_list=[bitstring_padding[i:i+4] for i in range(0,len(bitstring_padding),4)] #截取每四位二进制数，存入列表，以便转为16进制
    bitstring_hex=''.join(hex(int(x,2))[2:] for x in bitstring_hex_list) #将二进制位串的数据转为十六进制串,因为只能是一位，所以不用zfill
    while len(bitstring_hex)%128!=0: #先将剩余的64bit全补为0,直至长度为512的整数倍
        bitstring_hex+='0'
    end_padding=hex(len(bitstring))[2:] #确定原始明文长度，十六进制，为了将原始明文长度添加到末尾,此处也不必zfill
    bitstring_hex=bitstring_hex[:-len(end_padding)]+end_padding #将原始明文长度添加到末尾
    return bitstring_hex
# 模 2**32 加法实现
def mod32_add(x, y, z, u):
    # 转换为整数并模 2**32，只保留低 32 位
    result = (x + y + z + u) & 0xFFFFFFFF
    # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
#    return f"{result:08x}"
    return result
#SM3杂凑函数
def sm3_encode(bitstring_hex):
    #将消息分组，每组128个十六进制，即512bit
    bitstring_hex_group=[bitstring_hex[i:i+128] for i in range(0,len(bitstring_hex),128)] #将128位一组分割
    #初始向量IV
    IV = [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e]
    #生成字 W,对每个分组都进行
    for bitstring_hex_i in bitstring_hex_group:
        w=[bitstring_hex_i[i:i+8] for i in range(0,len(bitstring_hex_i),8)] #将每四个字节，构成一个字，存储到 w[]中，共 16个字
        for j in range(16,68):
            w_tem=P1(int(w[j-16],16)^int(w[j-9],16)^circular_left_shift(int(w[j-3],16),15))^circular_left_shift(int(w[j-13],16),7)^int(w[j-6],16)
            w.append(format(w_tem, '08x')) #将w_tem转化为16进制字符串，并保持长度为 8 位（补零）
        for j in range(0,64): #从w列表的第68位开始，存储w0'，w1',...,w63'
            w_tem=int(w[j],16)^int(w[j+4],16)
            w.append(format(w_tem, '08x'))
        #迭代压缩
        A=[IV[len(IV)-8]]
        B=[IV[len(IV)-7]]
        C=[IV[len(IV)-6]]
        D=[IV[len(IV)-5]]
        E=[IV[len(IV)-4]]
        F=[IV[len(IV)-3]]
        G=[IV[len(IV)-2]]
        H=[IV[len(IV)-1]]
        for j in range(0,64):
            if j!=0:
                A=[int(i,16) for i in A]
                B=[int(i,16) for i in B]
                C=[int(i,16) for i in C]
                D=[int(i,16) for i in D]
                E=[int(i,16) for i in E]
                F=[int(i,16) for i in F]
                G=[int(i,16) for i in G]
                H=[int(i,16) for i in H]
            SS1=circular_left_shift(mod32_add(circular_left_shift(A[len(A)-1],12),E[len(E)-1],circular_left_shift(T(j),j),0),7)
            SS2=SS1^circular_left_shift(A[len(A)-1],12)
            TT1=mod32_add(FF(A[len(A)-1],B[len(B)-1],C[len(C)-1],j),D[len(D)-1],SS2,int(w[j+68],16))
            TT2=mod32_add(GG(E[len(E)-1],F[len(F)-1],G[len(G)-1],j),H[len(H)-1],SS1,int(w[j],16))
            D.append(C[len(C)-1])
            C.append(circular_left_shift(B[len(B)-1],9))
            B.append(A[len(A)-1])
            A.append(TT1)
            H.append(G[len(G)-1])
            G.append(circular_left_shift(F[len(F)-1],19))
            F.append(E[len(E)-1])
            E.append(P0(TT2))
            A=[format(i, '08x') for i in A]
            B=[format(i, '08x') for i in B]
            C=[format(i, '08x') for i in C]
            D=[format(i, '08x') for i in D]
            E=[format(i, '08x') for i in E]
            F=[format(i, '08x') for i in F]
            G=[format(i, '08x') for i in G]
            H=[format(i, '08x') for i in H]
        
        #更新IV
        A=[int(i,16) for i in A]
        B=[int(i,16) for i in B]
        C=[int(i,16) for i in C]
        D=[int(i,16) for i in D]
        E=[int(i,16) for i in E]
        F=[int(i,16) for i in F]
        G=[int(i,16) for i in G]
        H=[int(i,16) for i in H]
        IV.append(A[len(A)-1]^IV[len(IV)-8])
        IV.append(B[len(B)-1]^IV[len(IV)-8])
        IV.append(C[len(C)-1]^IV[len(IV)-8])
        IV.append(D[len(D)-1]^IV[len(IV)-8])
        IV.append(E[len(E)-1]^IV[len(IV)-8])
        IV.append(F[len(F)-1]^IV[len(IV)-8])
        IV.append(G[len(G)-1]^IV[len(IV)-8])
        IV.append(H[len(H)-1]^IV[len(IV)-8])
    #将IV转化为16进制字符串，并保持长度为 8 位（补零）
    IV=[format(i, '08x') for i in IV]
    #将IV_hex拼接成16进制字符串
    result=IV[len(IV)-8]+IV[len(IV)-7]+IV[len(IV)-6]+IV[len(IV)-5]+IV[len(IV)-4]+IV[len(IV)-3]+IV[len(IV)-2]+IV[len(IV)-1]
    return result
#主程序
def main():
    while True:
        print("==================== SM3 加密======================")
        print("[1] 加密")
        print("[0] 退出")
        print("====================================================")
        try:
            choice = int(input("请输入操作选项 (0 或 1 ): "))
            if choice == 0:
                print("\n\n程序已退出。感谢使用 SM3 加密工具！")
                break
            elif choice == 1:
                # 加密流程
                plaintext = input("请输入明文 (UTF-8 编码，任意长度): ")
                #明文转化为二进制位字符串
                bitstring = string_to_bitstring(plaintext)
                #填充为512位二进制，并转化为16进制，共128个字符
                bitstring_hex = add_padding_bits(bitstring)
                if not plaintext:
                    raise ValueError("明文不能为空！")
                #sha-1加密
                ciphertext=sm3_encode(bitstring_hex)
                print("\n加密结果 (十六进制):")
                print(ciphertext)
            else:
                raise ValueError("无效选项")
    
        except ValueError as e:
            print(f"输入错误: {e}")
        except Exception as e:
            print(f"发生错误: {e}")
# =============================================================================
# # 示例 密码书 P318
# #输入明文
# plaintext = "abc"
# #明文转化为二进制位字符串
# bitstring = string_to_bitstring(plaintext)
# #填充为512位二进制，并转化为16进制，共128个字符
# bitstring_hex = add_padding_bits(bitstring)
# #SM3加密
# ciphertext=sm3_encode(bitstring_hex)
# print(f"输入字符串: {plaintext}")
# print(f"密文串: {ciphertext}")
# =============================================================================
if __name__=="__main__":
    main()

]]> <p>SM3是中国自主研发的哈希算法，适合生成数据摘要，安全性较高。（单向加密，不可逆加密） </p> <h1 id="基础知识"><a href="#基础知识" class="headerlink" title="基础知识"></a>基础知识</h1><p><a href="/ SHA-1加密-基于python无第三方库 https://www.chaincipher.cn/posts/7c0e17a3.html 2025-01-06T03:08:37.000Z 2025-01-06T04:51:57.603Z SHA-1 是一种哈希算法，用于生成数据的摘要，但安全性较低，已不建议使用。(单向加密，不可逆加密)

基础知识

SHA-1基础知识及加解密算法流程pdf下载

python实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
# -*- coding: utf-8 -*-
"""
Created on Sat Dec 14 21:40:07 2024

SHA-1   对输入的明文采用utf-8编码
        对输出的密文采用十六进制编码

"""

#将明文字符串转换为二进制位串
def string_to_bitstring(s):
    """
    将字符串转换为二进制位串
    :param s: 输入字符串
    :return: 由每个字符转换成的 8 位二进制数拼接成的字符串
    """
    return ''.join(format(ord(char), '08b') for char in s)

#添加填充位。使数据位长度为 448 bit , 剩余的 64 bit用于表示原始明文字符串长度 eg abc，占三字节 24 bit，故末尾的 64 bit表示 24 
def add_padding_bits(bitstring):
    if len(bitstring) < 448: #若不够448位，则填充
        bitstring_padding=bitstring+'1' #先在明文二进制位串后面补上1
        while len(bitstring_padding)!=448:
            bitstring_padding+='0' #剩余的全补为0，直至数据长度为 448
        bitstring_hex_list=[bitstring_padding[i:i+4] for i in range(0,len(bitstring_padding),4)] #截取每四位二进制数，存入列表，以便转为16进制
    else: #若够448位，无需填充, 此时还有问题未解决，加密结果和正确的不一致
        print("明文字符串长度 >= 56, 尚未实现")
    bitstring_hex=''.join(hex(int(x,2))[2:] for x in bitstring_hex_list) #将二进制位串的数据转为十六进制串,因为只能是一位，所以不用zfill
    while len(bitstring_hex)!=128: #先将剩余的64bit全补为0
        bitstring_hex+='0'
    end_padding=hex(len(bitstring))[2:] #确定原始明文长度，十六进制，为了将原始明文长度添加到末尾,此处也不必zfill
    bitstring_hex=bitstring_hex[:-len(end_padding)]+end_padding #将原始明文长度添加到末尾
    return bitstring_hex

#循环左移
def circular_left_shift(x, n): #将整数x循环左移n位
    """
    对32位整数x进行n位的循环左移
    :param x: 输入的整数 (8位16进制数)
    :param n: 左移的位数
    :return: 循环左移后的结果
    """
    x_int=int(x,16) #将x转化为整数 eg. x从'0a'变成了 10
    result=((x_int << n) & 0xFFFFFFFF) | (x_int >> (32 - n)) #将x循环左移n位
    return f"{result:08x}" # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）

# 模 2**32 加法实现
def mod32_add(x, y, z, u, k):
    # 转换为整数并模 2**32，只保留低 32 位
    result = (int(x, 16) + int(y, 16) + int(z, 16) + int(u, 16) + int(k, 16)) & 0xFFFFFFFF
    # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）
    return f"{result:08x}"

#压缩函数 f1
def f1(X, Y, Z):
    result = (int(X, 16) & int(Y, 16)) | ((~int(X, 16)) & int(Z, 16)) # ~ 取反操作是按位取反，但为了避免补码带来的负数影响，并确保始终在 32 位范围内，使用 ~X & 0xFFFFFFFF 来取反
    return f"{result:08x}" # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）

#压缩函数 f2
def f2(X, Y, Z):
    result = int(X,16) ^ int(Y,16) ^ int(Z,16)
    return f"{result:08x}" # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）

#压缩函数 f3
def f3(X, Y, Z):
    result = (int(X,16) & int(Y,16)) | (int(X,16) & int(Z,16)) | (int(Y,16) & int(Z,16))
    return f"{result:08x}" # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）

#压缩函数 f4
def f4(X, Y, Z):
    result = int(X,16) ^ int(Y,16) ^ int(Z,16)
    return f"{result:08x}" # 转换为十六进制字符串，去掉前缀 '0x'，并保持长度为 8 位（补零）

#sha-1加密
def sha_1_encode(bitstring_hex):
    #初始化五个寄存器
    A=['67452301']
    B=['EFCDAB89']
    C=['98BADCFE']
    D=['10325476']
    E=['C3D2E1F0']
    #生成字 W
    w=[bitstring_hex[i:i+8] for i in range(0,len(bitstring_hex),8)] #将每四个字节，构成一个字，存储到 w[]中，共 16个字
    #固定常数
    K=['5a827999','6ed9eba1','8f1bbcdc','ca62c1d6']
    #存储压缩函数
    function=[f1,f2,f3,f4]
    for i in range(16,80): #共 80个字
        w_tem=''.join([hex(int(a,16) ^ int(b,16) ^ int(c,16) ^ int(d,16))[2:] for a,b,c,d in zip(w[i-16],w[i-14],w[i-8],w[i-3])]) #异或操作，这里的''.join是为了让该列表变为字符串
        w_tem=circular_left_shift(w_tem, 1) #循环左移 1位
        w.append(w_tem) #将生成的字添加到 w列表中
    #经过四轮，每轮20步
    for i in range(4):
        for t in range(i*20,(i+1)*20):
            A_tem=mod32_add(E[len(E)-1],function[i](B[len(B)-1],C[len(C)-1],D[len(D)-1]),circular_left_shift(A[len(A)-1], 5), w[t], K[i])
            A.append(A_tem)
            B.append(A[len(A)-2])
            C.append(circular_left_shift(B[len(B)-2], 30))
            D.append(C[len(C)-2])
            E.append(D[len(D)-2])
    #输出变换
    A.append(mod32_add(A[len(A)-1], A[len(A)-81], '0', '0', '0'))
    B.append(mod32_add(B[len(B)-1], B[len(B)-81], '0', '0', '0'))
    C.append(mod32_add(C[len(C)-1], C[len(C)-81], '0', '0', '0'))
    D.append(mod32_add(D[len(D)-1], D[len(D)-81], '0', '0', '0'))
    E.append(mod32_add(E[len(E)-1], E[len(E)-81], '0', '0', '0'))
    ciphertext=A[len(A)-1]+B[len(B)-1]+C[len(C)-1]+D[len(D)-1]+E[len(E)-1]
    return ciphertext

#主程序
def main():
    while True:
        print("==================== SHA-1 加密======================")
        print("[1] 加密")
        print("[0] 退出")
        print("====================================================")
        try:
            choice = int(input("请输入操作选项 (0 或 1 ): "))
            if choice == 0:
                print("\n\n程序已退出。感谢使用 SHA-1 加密工具！")
                break
            elif choice == 1:
                # 加密流程
                plaintext = input("请输入明文 (UTF-8 编码，目前只支持字符长度 <56): ")
                #明文转化为二进制位字符串
                bitstring = string_to_bitstring(plaintext)
                #填充为512位二进制，并转化为16进制，共128个字符
                bitstring_hex = add_padding_bits(bitstring)
                if not plaintext:
                    raise ValueError("明文不能为空！")
                #sha-1加密
                ciphertext=sha_1_encode(bitstring_hex)
                print("\n加密结果 (十六进制):")
                print(ciphertext)
            else:
                raise ValueError("无效选项")
    
        except ValueError as e:
            print(f"输入错误: {e}")
        except Exception as e:
            print(f"发生错误: {e}")
            
# 示例 密码书 P188
# =============================================================================
# #输入明文
# plaintext = "11111111111111111111111111111111111111111111111111111111"
# #明文转化为二进制位字符串
# bitstring = string_to_bitstring(plaintext)
# #填充为512位二进制，并转化为16进制，共128个字符
# bitstring_hex = add_padding_bits(bitstring)
# #sha-1加密
# ciphertext=sha_1_encode(bitstring_hex)
# print(f"输入字符串: {plaintext}")
# print(f"密文串: {ciphertext}")
# =============================================================================

if __name__=="__main__":
    main()

]]> SHA-1 是一种哈希算法，用于生成数据的摘要，但安全性较低，已不建议使用。(单向加密，不可逆加密) AES加解密-基于python无第三方库 https://www.chaincipher.cn/posts/baf8092.html 2025-01-05T08:12:06.000Z 2025-01-06T03:10:32.642Z AES加密算法是一种对称加密算法，它对原始数据进行加密，生成密文，只有知道密钥和算法，才能解密出原始数据。
本文将介绍AES加密算法的实现，并使用python语言实现AES加密和解密。

基础知识

AES基础知识及加解密算法流程pdf下载

python实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
#AES算法，密钥长度选择128位，轮数为10，明文和密钥采用UTF-8编码(一个字符代表一个字节，chr与ord转化即可)
#密文采用十六进制编码。
import numpy as np
import constant #constant 存有各种常量：S盒S_box，轮常量Rcon，对数表Log_table，
#反对数表Antilog_table，列混淆加密时的常数矩阵 mix_columns_en_matrix 等

#字节代换(S盒变换)
def subbytes(tai):  #参数传入tai，四乘四的矩阵，元素为十六进制字符串
    tai_tem=[[0]*4 for _ in range(4)] #储存临时tai
    for i in range(4):  #对每个元素进行查表替换
        for j in range(4):
            row=int(tai[i][j],16)//16 #获得S盒的行序号
            column=int(tai[i][j],16)%16 #获得S盒的列序号
            tai_tem[i][j]='0x'+hex(constant.S_box[row][column])[2:].zfill(2)  #S盒替换，
            #并将元素转化为十六进制字符串型，和初始元素类型一致
    tai_tem=np.array(tai_tem) #转化为矩阵
    return tai_tem  #字节代换完成，返回新tai

#逆字节代换(逆S盒变换)
def invsubbytes(tai):  #参数传入tai，四乘四的矩阵，元素为十六进制字符串
    tai_tem=[[0]*4 for _ in range(4)] #储存临时tai
    for i in range(4):  #对每个元素进行查表替换
        for j in range(4):
            row=int(tai[i][j],16)//16 #获得S盒的行序号
            column=int(tai[i][j],16)%16 #获得S盒的列序号
            tai_tem[i][j]='0x'+hex(constant.Inv_Sbox[row][column])[2:].zfill(2)  #逆S盒替换，
            #并将元素转化为十六进制字符串型，和初始元素类型一致
    tai_tem=np.array(tai_tem) #转化为矩阵
    return tai_tem  #字节代换完成，返回新tai

#轮密钥生成中的T函数
def T(matrix,i,rcon_matrix): #传入的i值用于判断轮数，以找到和第几轮的轮常量进行异或
    matrix = np.roll(matrix, -1) #循环左移一位
    for j in range(len(matrix)): #对每个元素进行S表替换
        j_int=int(matrix[j],16) #j_int存放每个元素的整数值，以方便获得索引调用S_box[][]
        row=j_int//16 #获得行索引
        column=j_int%16 #获得列索引
        matrix[j]='0x'+hex(constant.S_box[row][column])[2:].zfill(2) #S盒替换
#        matrix[j]=constant.S_box[row][column] #其实每个元素获得其int型即可，
         #因为异或操作函数只能进行元素都是整型的两个矩阵
#    matrix=matrix.astype(int) #发现还是字符型，搜索得知，需要重新定义矩阵数组的类型，
#        否则无法进行异或操作，这里将字符型转化为整型，#才能彻底变换元素的类型
    w_union_str='0x'+"".join([x[2:].zfill(2) for x in matrix]) #将matrix中的元素['0x12','0x34']
    #合成为['0x1234']存入w_union_str,仅举例说明
    w_union=np.array([w_union_str]) #转化为矩阵
    w_union_int=np.array([int(x,16) for x in w_union]) #将w_union中元素转化为整型,
    #w_union_int=array([907426859], dtype=int32)    
    w_union_int=np.bitwise_xor(w_union_int,rcon_matrix[i//4 - 1]) #将w_union_int与轮常数异或,
    #w_union_int=array([924204075], dtype=int32)
    w_int_hex=np.array(['0x'+hex(x)[2:].zfill(8) for x in w_union_int]) #w_int_hex=array(['0x37163c2b'])
    w_int_hex=w_int_hex[0][2:] #w_int_hex='37163c2b'
    matrix=np.array([f'0x{w_int_hex[j:j+2]}' for j in range(0, len(w_int_hex), 2)]) 
    #matrix=array(['0x37', '0x16', '0x3c', '0x2b'], dtype='<U4')
    matrix=np.array([int(x,16) for x in matrix]) #将matrix中每一位元素用十进制数存放
    return matrix

#轮密钥生成
def subkey_generation(key):
    """
    密钥长度为128位(16字节),轮数为10
    """
    if len(key) != 16:
        raise ValueError('Key length should be 128 bits(16 bytes).') #判断密钥长度是否为16字节，128位
    key_blocks = [key[i] for i in range(0,len(key))] #先将密钥存入列表中
    key_schedule = [[0]*4 for _ in range(4)]  #初始化密钥初始矩阵
    for i in range(4):
        for j in range(4):
            if key_blocks[i+j*4].isprintable(): #将一排十六进制密钥，竖着一列一列存到矩阵中
                key_schedule[i][j] = '0x' + format(ord(key_blocks[i+j*4]), '02x') 
                #初始密钥矩阵列表,将每个字节以十六进制形式存放
    key_schedule = np.array(key_schedule) #转化为矩阵
    ###########################################################################
# =============================================================================
#     #测试第5-3章-AES.ppt P60例二 密码书 P125页
#     # 十六进制字符串序列
#     key_blocks_ori = ['2b', '7e', '15', '16', '28', 'ae', 'd2', 'a6', 'ab', 'f7', '15', '88', '09', 'cf', '4f', '3c']
#     # 将十六进制字符串转为含有 0x 前缀的十六进制值
#     key_blocks = ['0x' + x for x in key_blocks_ori]    
#     # 将其转化为 4x4 矩阵
#     for i in range(4):
#         for j in range(4):
#             if key_blocks[i+j*4].isprintable(): #将一排十六进制密钥，竖着一列一列存到矩阵中
#                 key_schedule[i][j] = key_blocks[i+j*4] #初始密钥矩阵列表,将每个字节以十六进制形式存放
#     key_schedule = np.array(key_schedule) #转化为矩阵
# =============================================================================
    ###########################################################################
    w=[[0]*4 for _ in range(44)] #初始化存放所有操作完成后的子密钥的列表，基础元素为十六进制数
    w[0]=key_schedule[:,0] #取出初始密钥矩阵的第一列作为w[0] array(['0x3C', '0xA1', '0x0B', '0x21']
    w[1]=key_schedule[:,1] #取出初始密钥矩阵的第二列作为w[1] 
    w[2]=key_schedule[:,2] #取出初始密钥矩阵的第三列作为w[2]
    w[3]=key_schedule[:,3] #取出初始密钥矩阵的第一四作为w[3]
    rcon_matrix=np.array(constant.Rcon) #将轮常数列表转化为矩阵
    for i in range(4,44):   
        if i%4!=0 : #i不是4的倍数时
            wi1_int=np.array([int(x,16) for x in w[i-1]])
            wi4_int=np.array([int(x,16) for x in w[i-4]])
            w[i]=np.bitwise_xor(wi1_int,wi4_int) 
            w[i]=np.array(['0x'+hex(x)[2:].zfill(2) for x in w[i]]) 
            #将w[i]中的元素转化为16进制存放
        else : #i是4的倍数时
            wi4_int=np.array([int(x,16) for x in w[i-4]]) 
            #将w[i-4]中的['0x10',...,'0x11'],转化为整数存放[16,...,17],仅举例说明用
            w[i]=np.bitwise_xor(wi4_int,T(w[i-1],i,rcon_matrix)) 
            #将w[i-4]与经过T函数操作过的w[i-1]的对应位进行异或操作得到w[i]，此时w[i]中元素类型为整型
            w[i]=np.array(['0x'+hex(x)[2:].zfill(2) for x in w[i]]) #将w[i]中的元素转化为16进制存放
    return w    #返回生成的轮密钥
  
#明文转化为矩阵
def plain_tran(plaintext):
    plain_blocks = [plaintext[i] for i in range(0,len(plaintext))] #先将明文存入列表中
    plain_schedule = [[0]*4 for _ in range(4)]  #初始化明文初始矩阵
    for i in range(4):
        for j in range(4):
            if plain_blocks[i+j*4].isprintable(): #将一排十六进制明文，竖着一列一列存到矩阵中
                plain_schedule[i][j] = '0x' + format(ord(plain_blocks[i+j*4]), '02x') 
                #初始明文矩阵列表,将每个字节以十六进制形式存放
    plain_schedule = np.array(plain_schedule) #转化为矩阵
    ########################################################################### 
# =============================================================================
#     #测试 PPT P58 密码书 P127
#     plain_schedule = np.array([['0x32','0x88','0x31','0xe0'],['0x43','0x5a','0x31','0x37'],['0xf6','0x30','0x98','0x07'],['0xa8','0x8d','0xa2','0x34']])
# =============================================================================
    ###########################################################################
    return plain_schedule

#AES加密算法
def aes_encode(plain_schedule,w):
    tai=[] #存放tai
    tai.append(plain_schedule) #初始tai为明文十六进制编码的四乘四矩阵
    w_array=np.array(w) #w_array存放矩阵形式的w
    subkey_w = [w_array[i:i + 4].T for i in range(0, len(w), 4)] 
    #subkey_w中存放了初始密钥和十轮子密钥，共十一个密钥，每个密钥是四乘四矩阵形式
    
    #初始轮密钥加变换，就是相应位置的元素进行异或操作
    tai0_int=np.array([[int(x,16) for x in row] for row in plain_schedule])
    subkey_int0=np.array([[int(x,16) for x in row] for row in subkey_w[0]])
    tai.append(np.bitwise_xor(tai0_int,subkey_int0))
    tai[1]=np.array([['0x'+hex(x)[2:].zfill(2) for x in row] for row in tai[1]]) 
    #将tai[i]中的元素转化为16进制存放

    #开始循环十轮加密
    for i in range(10):
        #字节代换-SubBytes
        tai.append(subbytes(tai[len(tai)-1]))
        #行移位-ShiftRows
        tai_tem_int = [[int(x, 16) for x in row] for row in tai[len(tai)-1]]
        tai_tem = [row[i:] + row[:i] for i, row in enumerate(tai_tem_int)] 
        #实现从上到下每行左移零位，一位，两位，三位
        tai_tem = np.array([['0x'+hex(x)[2:].zfill(2) for x in row] for row in tai_tem])
        tai.append(tai_tem)
        #列混淆-MixColumns
        if i!=9:
            tai_tem=np.array(list(tai_tem)) 
            #为什么不直接使用tai_tem呢，因为直接使用，会导致tai中append进去的tai_tem也发生变化，
            #所以在此进行拷贝一个副本tai_tem进行操作
            tai_tem_int = [[int(x, 16) for x in row] for row in tai[len(tai)-1]]
            tai_tem_matrix=np.array(tai_tem_int)
            for j in range(4):
                for k in range(4):
                    tai_tem[j][k]=row_cheng_columns(constant.mix_columns_en_matrix[j],list(tai_tem_matrix[:,k]) )
            tai_tem = np.array([['0x'+hex(int(x))[2:].zfill(2) for x in row] for row in tai_tem])
            tai.append(tai_tem)
        #轮密钥加
        tai_tem_int = [[int(x, 16) for x in row] for row in tai[len(tai)-1]]
        subkey_int=np.array([[int(x,16) for x in row] for row in subkey_w[i+1]])
        tai_tem=np.bitwise_xor(tai_tem_int,subkey_int)
        tai_tem=np.array([['0x'+hex(x)[2:].zfill(2) for x in row] for row in tai_tem])
        tai.append(tai_tem)
    
    #加密结果为ciphertext
    ciphertext_matrix=tai[len(tai)-1].T
    ciphertext=''
    for i  in range(4):
        for j in range(4):
            ciphertext+=str(ciphertext_matrix[i][j][2:])
    return ciphertext
    
#列混淆常数矩阵乘以tai 实现 行列表[0x01,0x02,0x03,0x04]×列列表[0x3a,0x32,0x12,0x44]在GF(2**8)域上的运算，
#通过查对数表,反对数表
def row_cheng_columns(row,column):
    a=[]
    for i in range(4):
        # 如果当前元素为 0x00，直接跳过
        if row[i] == 0x00 or column[i] == 0x00: 
            #此种特殊情况为：aes解密时，若出现查对数表0行0列的特殊情况时，直接将该乘积结果赋为0
            a.append(0x00)
            continue
        log_row_row_num=row[i]//16 
        log_row_column_num=row[i]%16 
        log_column_row_num=column[i]//16 
        log_column_column_num=column[i]%16
        tem=(constant.Log_table[log_row_row_num][log_row_column_num]+constant.Log_table[log_column_row_num][log_column_column_num])
        if tem>255: 
            #此种特殊情况为，当查反对数表时出现行列值大于15的特殊情况，大于了GF(2**8),
            #需要 -255 或者 %255 再进行查反对数表
            tem=tem%255
        result_row=tem//16 
        result_column=tem%16 
        tem=constant.Antilog_table[result_row][result_column]
        a.append(tem)
    result=0
    for num in a:
        result^=num
    return result

#密文转化为矩阵
def cipher_tran(ciphertext):
    cipher_schedule=[[0]*4 for _ in range(4)]
    cipher_list=[ciphertext[i:i+2] for i in range(0,len(ciphertext),2)]
    for i in range(4):
        for j in range(4):
            cipher_schedule[i][j]='0x'+cipher_list[i+j*4]
    cipher_schedule=np.array(cipher_schedule)
    return cipher_schedule

#解密算法
def aes_decode(cipher_schedule,w):
    tai=[] #存放tai
    tai.append(cipher_schedule) #初始tai为密文十六进制编码的四乘四矩阵
    w_array=np.array(w) #w_array存放矩阵形式的w
    subkey_w = [w_array[i:i + 4].T for i in range(0, len(w), 4)] 
    #subkey_w中存放了初始密钥和十轮子密钥，共十一个密钥，每个密钥是四乘四矩阵形式    
    subkey_w = subkey_w[::-1] #将十一个密钥倒序排放，用于解密
    
    #初始轮密钥加变换，就是相应位置的元素进行异或操作
    tai0_int=np.array([[int(x,16) for x in row] for row in tai[0]])
    subkey_int10=np.array([[int(x,16) for x in row] for row in subkey_w[0]])
    tai.append(np.bitwise_xor(tai0_int,subkey_int10))
    tai[1]=np.array([['0x'+hex(x)[2:].zfill(2) for x in row] for row in tai[1]]) 
    #将tai[i]中的元素转化为16进制存放
    
    #开始循环十轮解密
    for i in range(10):
        #逆行移位-InvShiftRows
        tai_tem_int = [[int(x, 16) for x in row] for row in tai[len(tai)-1]]
        tai_tem = [row[-i:] + row[:-i] for i, row in enumerate(tai_tem_int)]   
        #实现从上到下每行右移零位，一位，两位，三位
        tai_tem = np.array([['0x'+hex(x)[2:].zfill(2) for x in row] for row in tai_tem])
        tai.append(tai_tem)
        #逆字节代换-InvSubBytes
        tai.append(invsubbytes(tai[len(tai)-1]))
        #轮密钥加
        tai_tem_int = [[int(x, 16) for x in row] for row in tai[len(tai)-1]]
        subkey_int=np.array([[int(x,16) for x in row] for row in subkey_w[i+1]])
        tai_tem=np.bitwise_xor(tai_tem_int,subkey_int)
        tai_tem=np.array([['0x'+hex(x)[2:].zfill(2) for x in row] for row in tai_tem])
        tai.append(tai_tem)
        
        #逆列混淆-InvMixColumns
        if i!=9:
            tai_tem=np.array(list(tai_tem)) #为什么不直接使用tai_tem呢，因为直接使用，
            #会导致tai中append进去的tai_tem也发生变化，所以在此进行拷贝一个副本tai_tem进行操作
            tai_tem_int = [[int(x, 16) for x in row] for row in tai[len(tai)-1]]
            tai_tem_matrix=np.array(tai_tem_int)
            for j in range(4):
                for k in range(4):
                    tai_tem[j][k]=row_cheng_columns(constant.mix_columns_de_matrix[j],list(tai_tem_matrix[:,k]) )
            tai_tem = np.array([['0x'+hex(int(x))[2:].zfill(2) for x in row] for row in tai_tem])
            tai.append(tai_tem)
        
    #加密结果为plaintext
    plaintext_matrix=tai[len(tai)-1].T
    plaintext=''
    for i  in range(4):
        for j in range(4):
            plaintext+=chr(int(plaintext_matrix[i][j],16))
    return plaintext

#主程序
def main():
    while True:
        print("==================== AES 加密与解密 ====================")
        print("[1] 加密")
        print("[2] 解密")
        print("[0] 退出")
        print("====================================================")
        try:
            choice = int(input("请输入操作选项 (0, 1 或 2): "))
            if choice == 0:
                print("\n\n程序已退出。感谢使用 AES 加解密工具！")
                break
            elif choice == 1:
                # 加密流程
                plaintext = input("请输入明文 (UTF-8 编码，16 个字符): ")
                plain_schedule=plain_tran(plaintext)
                key = input("请输入密钥 (UTF-8 编码，16 个字符): ")
                w=subkey_generation(key) #w存入轮密钥w[0]-w[3],用来对明文进行初始的轮密钥加变化，
                #w[4]-w[7]作为第一轮子密钥，一共十轮，第十轮子密钥为w[40]-w[43]
                if not plaintext or not key:
                    raise ValueError("明文和密钥均不能为空！")
                ciphertext = aes_encode(plain_schedule, w)
                print("\n加密结果 (十六进制):")
                print(ciphertext)
            elif choice == 2:
                # 解密流程
                ciphertext = input("请输入密文 (连续的十六进制): ")
                cipher_schedule=cipher_tran(ciphertext)
                key = input("请输入密钥 (UTF-8 编码，16 个字符): ")
                w=subkey_generation(key) #w存入轮密钥w[0]-w[3],用来对明文进行初始的轮密钥加变化，
                #w[4]-w[7]作为第一轮子密钥，一共十轮，第十轮子密钥为w[40]-w[43]
                if not ciphertext or not key:
                    raise ValueError("密文和密钥均不能为空！")
                plaintext = aes_decode(cipher_schedule, w)
                print("\n解密结果 (UTF-8 编码):")
                print(plaintext)
            else:
                raise ValueError("无效选项")
    
        except ValueError as e:
            print(f"输入错误: {e}")
        except Exception as e:
            print(f"发生错误: {e}")

if __name__ == "__main__":
    main()

]]> AES加密算法是一种对称加密算法，本文将详细介绍AES基本知识及python实现。 Hello World https://www.chaincipher.cn/posts/82084c25.html 2024-11-13T12:36:59.000Z 2025-06-03T10:18:37.338Z 博客搭建过程。

博客搭建

基于hexo和butterfly主题搭建的博客。

详见我的csdn博客

]]> <p>博客搭建过程。</p> <h1 id="博客搭建"><a href="#博客搭建" class="headerlink" title="博客搭建"></a>博客搭建</h1><p>基于hexo和butterfly主题搭建的博客。</p> <p><a href="https: