SHA256加密算法 - 0xnonce's Blog

SHA256 算法其实跟前面的哈希算法类似，他们所需要经历的步骤是一样的，下面来用一个表格来跟前面的哈希算法做一个对比

特性	MD5	SHA1	SHA256
输出长度	128 位	160 位	256 位
安全性	已破解	存在碰撞攻击	目前安全
块大小	512 位	512 位	512 位
步数	64 步	80 步	64 步
初始化常量	4 个	5 个	8 个
字节序	小端序	大端序	大端序

填充#

此步骤与 MD5,SHA1 的规则一致，将原始消息填充至长度恰好是 512 的整数倍，规则几乎相同:

在消息末尾首先补一个 1(即 0x80)
补足够多的比特 0,直到消息长度满足(长度+64)%512=0,注意，这里的 64 比特是留给长度信息的还是以之前的”password”这个字符串为例:
填充后的消息: 70 61 73 73 77 6f 72 64 80 00 00 00 00 00 00 00 ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 40

初始化常量#

这个跟 MD5 和 SHA1 不同的是，他有 8 个初始化常量

1
h0 = 0x6a09e667
2
h1 = 0xbb67ae85
3
h2 = 0x3c6ef372
4
h3 = 0xa54ff53a
5
h4 = 0x510e527f
6
h5 = 0x9b05688c
7
h6 = 0x1f83d9ab
8
h7 = 0x5be0cd19

扩充#

需要将 16 个四字节扩充到 64 个四字节
前 16 个四字节直接获取填充过后的结果:

1
W[0]  = 0x70737361  // "ps sa" 的大端序表示（源自 "pass"）
2
W[1]  = 0x776f7264  // "wor d" 的大端序表示（源自 "word"）
3
W[2]  = 0x80000000  // 填充符 0x80 后跟三个 0x00
4
W[3]  = 0x00000000
5
W[4]  = 0x00000000
6
W[5]  = 0x00000000
7
W[6]  = 0x00000000
8
W[7]  = 0x00000000
9
W[8]  = 0x00000000
10
W[9]  = 0x00000000
11
W[10] = 0x00000000
12
W[11] = 0x00000000
13
W[12] = 0x00000000
14
W[13] = 0x00000000
15
W[14] = 0x00000000
16
W[15] = 0x00000040  // 原始消息长度 64 位 (0x40)

后 48 个四字节使用扩充算法进行填充

1
def _rotr(x, n):
2
    return ((x >> n) | (x << (32 - n))) & 0xffffffff
3

4
for i in range(16, 64):
5
  s0 = _rotr(w[i-15], 7) ^ _rotr(w[i-15], 18) ^ (w[i-15] >> 3)
6
  s1 = _rotr(w[i-2], 17) ^ _rotr(w[i-2], 19) ^ (w[i-2] >> 10)
7
  w[i] = (w[i-16] + s0 + w[i-7] + s1) & 0xffffffff

计算#

对于这个 64 次运算，同样有 64 个 k 值

1
k = [
2
  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
3
  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
4
  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
5
  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
6
  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
7
  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
8
  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
9
  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
10
]

接着来看一下主流程是怎么样的

1
# 主压缩循环
2
for i in range(64):
3
   S1 = _rotr(e, 6) ^ _rotr(e, 11) ^ _rotr(e, 25)
4
   ch = (e & f) ^ ((~e) & g)
5
   S0 = _rotr(a, 2) ^ _rotr(a, 13) ^ _rotr(a, 22)
6
   maj = (a & b) ^ (a & c) ^ (b & c)
7
   temp1 = (h_ + S1 + ch + k[i] + w[i]) & 0xffffffff
8
   temp2 = (S0 + maj) & 0xffffffff
9

10
   h_ = g
11
   g = f
12
   f = e
13
   e = (d + temp1) & 0xffffffff
14
   d = c
15
   c = b
16
   b = a
17
   a = (temp1 + temp2) & 0xffffffff

出现了两个临时变量，temp1 和 temp2,四个非线性函数，跟前面的 MD5 和 SHA1 的大差不差
通过在循环中，不断得到新的 a,b,c,d,e,f,g,h_,最后拼接起来，就得到了最终的 sha256 加密的值

代码实现#

1
def sha256(message: str) -> str:
2
    """
3
    计算输入字符串的 SHA-256 哈希值（十六进制字符串）
4
    """
5
    # === 步骤 1：预处理 ===
6

7
    # 将字符串转为字节（UTF-8 编码）
8
    if isinstance(message, str):
9
        message = message.encode('utf-8')
10

11
    # 获取原始长度（单位：bit）
12
    original_bit_len = len(message) * 8
13

14
    # 添加 bit '1'
15
    message += b'\x80'
16

17
    # 补零，直到长度 ≡ 448 (mod 512)
18
    while (len(message) * 8) % 512 != 448:
19
        message += b'\x00'
20

21
    # 添加 64-bit 原始长度（大端序）
22
    message += original_bit_len.to_bytes(8, 'big')
23

24
    # === 步骤 2：初始化哈希值（H₀）IV===
25
    # 这些是前8个质数的平方根的小数部分 × 2³² 的整数部分
26
    h = [
27
        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
28
        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
29
    ]
30

31
    # === 步骤 3：定义常量 K（前64个质数的立方根的小数部分 × 2³²）===
32
    k = [
33
        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
34
        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
35
        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
36
        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
37
        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
38
        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
39
        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
40
        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
41
    ]
42

43
    # === 步骤 4：主循环（每 512-bit 一块）===
44
    for chunk_start in range(0, len(message), 64):  # 64 bytes = 512 bits
45
        chunk = message[chunk_start:chunk_start + 64]
46

47
        # 将 chunk 拆分为 16 个 32-bit word（大端序）
48
        w = [0] * 64
49
        for i in range(16):
50
            w[i] = int.from_bytes(chunk[i*4:(i+1)*4], 'big')
51

52
        # 扩展到 64 个 word
53
        for i in range(16, 64):
54

55
            s0 = _rotr(w[i-15], 7) ^ _rotr(w[i-15], 18) ^ (w[i-15] >> 3)
56
            s1 = _rotr(w[i-2], 17) ^ _rotr(w[i-2], 19) ^ (w[i-2] >> 10)
57
            w[i] = (w[i-16] + s0 + w[i-7] + s1) & 0xffffffff
58
        # 初始化工作变量
59
        a, b, c, d, e, f, g, h_ = h
60

61
        # 主压缩循环
62
        for i in range(64):
63
            S1 = _rotr(e, 6) ^ _rotr(e, 11) ^ _rotr(e, 25)
64
            ch = (e & f) ^ ((~e) & g)
65
            S0 = _rotr(a, 2) ^ _rotr(a, 13) ^ _rotr(a, 22)
66
            maj = (a & b) ^ (a & c) ^ (b & c)
67
            temp1 = (h_ + S1 + ch + k[i] + w[i]) & 0xffffffff
68
            temp2 = (S0 + maj) & 0xffffffff
69

70
            h_ = g
71
            g = f
72
            f = e
73
            e = (d + temp1) & 0xffffffff
74
            d = c
75
            c = b
76
            b = a
77
            a = (temp1 + temp2) & 0xffffffff
78

79
        # 更新哈希值
80
        h[0] = (h[0] + a) & 0xffffffff
81
        h[1] = (h[1] + b) & 0xffffffff
82
        h[2] = (h[2] + c) & 0xffffffff
83
        h[3] = (h[3] + d) & 0xffffffff
84
        h[4] = (h[4] + e) & 0xffffffff
85
        h[5] = (h[5] + f) & 0xffffffff
86
        h[6] = (h[6] + g) & 0xffffffff
87
        h[7] = (h[7] + h_) & 0xffffffff
88

89
    # === 步骤 5：输出最终哈希值（十六进制）===
90
    return ''.join(f'{val:08x}' for val in h)
91

92

93
# 辅助函数：右循环移位
94
def _rotr(x, n):
95
    return ((x >> n) | (x << (32 - n))) & 0xffffffff
96

97

98
# === 测试 ===
99
if __name__ == "__main__":
100
  msg = "password"
101
  result = sha256(msg)
102
  print(f"Hash: {result}")

填充#

初始化常量#

扩充#

计算#

代码实现#

继续阅读

换条路线

评论

填充#

初始化常量#

扩充#

计算#

代码实现#

分享文章

沿着主题读

换条路线

评论