SHA256加密算法

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

特性MD5SHA1SHA256
输出长度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
2
3
4
5
6
7
8
h0 = 0x6a09e667
h1 = 0xbb67ae85
h2 = 0x3c6ef372
h3 = 0xa54ff53a
h4 = 0x510e527f
h5 = 0x9b05688c
h6 = 0x1f83d9ab
h7 = 0x5be0cd19

扩充

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

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

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

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

计算

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

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

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

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

   h_ = g
   g = f
   f = e
   e = (d + temp1) & 0xffffffff
   d = c
   c = b
   b = a
   a = (temp1 + temp2) & 0xffffffff

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

在前面了解了 MD5 和 SHA1 算法之后,感觉 SHA256 跟前面的流程都大差不差,理解起来就简单很多了

代码实现

  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
def sha256(message: str) -> str:
    """
    计算输入字符串的 SHA-256 哈希值(十六进制字符串)
    """
    # === 步骤 1:预处理 ===
    
    # 将字符串转为字节(UTF-8 编码)
    if isinstance(message, str):
        message = message.encode('utf-8')
    
    # 获取原始长度(单位:bit)
    original_bit_len = len(message) * 8

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

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

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

    # === 步骤 2:初始化哈希值(H₀)IV===
    # 这些是前8个质数的平方根的小数部分 × 2³² 的整数部分
    h = [
        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
    ]

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

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

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

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

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

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

            h_ = g
            g = f
            f = e
            e = (d + temp1) & 0xffffffff
            d = c
            c = b
            b = a
            a = (temp1 + temp2) & 0xffffffff

        # 更新哈希值
        h[0] = (h[0] + a) & 0xffffffff
        h[1] = (h[1] + b) & 0xffffffff
        h[2] = (h[2] + c) & 0xffffffff
        h[3] = (h[3] + d) & 0xffffffff
        h[4] = (h[4] + e) & 0xffffffff
        h[5] = (h[5] + f) & 0xffffffff
        h[6] = (h[6] + g) & 0xffffffff
        h[7] = (h[7] + h_) & 0xffffffff

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


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


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