sha-1从原理到cpp实现#

1
H0 = 0x67452301
2
H1 = 0xEFCDAB89
3
H2 = 0x98BADCFE
4
H3 = 0x10325476
5
H4 = 0xC3D2E1F0
6
就比我们的md5多了一个H4，其他都是一样的哈。

1
// ============================================================
2
// SHA-1 上下文
3
// ============================================================
4
struct SHA1Context {
5
    uint32_t state[5];      // A, B, C, D, E 五个寄存器
6
    uint64_t bitCount;      // 已处理的比特数
7
    uint8_t  buffer[64];    // 当前未处理完的 64 字节块
8
    size_t   bufferLen;     // buffer 中已有多少字节
9

10
    SHA1Context() { init(); }
11

12
    void init() {
13
        // SHA-1 的 5 个初始魔数（RFC 3174 定义）
14
        state[0] = 0x67452301;   // A
15
        state[1] = 0xEFCDAB89;   // B
16
        state[2] = 0x98BADCFE;   // C
17
        state[3] = 0x10325476;   // D
18
        state[4] = 0xC3D2E1F0;   // E
19
        bitCount = 0;
20
        bufferLen = 0;
21
    }
22
};

1
// ============================================================
2
// 更新数据（可以分多次调用）
3
// ============================================================
4
static void sha1Update(SHA1Context& ctx, const uint8_t* data, size_t len) {
5
    ctx.bitCount += (uint64_t)len * 8;   // 累加比特数，计算原始消息长度
6

7
    while (len > 0) {
8
        size_t space = 64 - ctx.bufferLen;
9
        size_t copy  = (len < space) ? len : space;
10

11
        std::memcpy(ctx.buffer + ctx.bufferLen, data, copy);
12
        ctx.bufferLen += copy;
13
        data += copy;
14
        len  -= copy;
15

16
        if (ctx.bufferLen == 64) {
17
            sha1Transform(ctx.state, ctx.buffer);
18
            ctx.bufferLen = 0;
19
        }
20
    }
21
}

1
// ============================================================
2
// SHA-1 每轮常数 K（只有 4 个，每 20 轮换一个）
3
// ============================================================
4
static const uint32_t K[4] = {
5
    0x5A827999,   // 0..19
6
    0x6ED9EBA1,   // 20..39
7
    0x8F1BBCDC,   // 40..59
8
    0xCA62C1D6    // 60..79
9
};
10

11
// ============================================================
12
// 大端序读写工具（SHA-1 规定 32 位字按大端序读/写）
13
// ============================================================
14
static inline uint32_t read_be32(const uint8_t* p) {
15
    return ((uint32_t)p[0] << 24)
16
         | ((uint32_t)p[1] << 16)
17
         | ((uint32_t)p[2] << 8)
18
         |  (uint32_t)p[3];
19
}
20

21
static inline void write_be32(uint8_t* p, uint32_t v) {
22
    p[0] = (uint8_t)((v >> 24) & 0xff);
23
    p[1] = (uint8_t)((v >> 16) & 0xff);
24
    p[2] = (uint8_t)((v >> 8)  & 0xff);
25
    p[3] = (uint8_t)( v        & 0xff);
26
}
27

28
// 循环左移
29
static inline uint32_t rotl(uint32_t x, uint32_t n) {
30
    return (x << n) | (x >> (32 - n));
31
}

1
// ============================================================
2
// 处理一个 512 位（64 字节）块
3
// ============================================================
4
static void sha1Transform(uint32_t state[5], const uint8_t block[64]) {
5
    uint32_t W[80];     //声明我们需要将原始消息扩展的空间
6

7
    // 1. 按大端序把 64 字节拆成 16 个 32 位字
8
    for (int i = 0; i < 16; i++) {
9
        W[i] = read_be32(block + i * 4);
10
    }
11

12
    // 2. 扩展到 80 个字：W[t] = rotl(W[t-3]^W[t-8]^W[t-14]^W[t-16], 1)
13
    for (int i = 16; i < 80; i++) {
14
        W[i] = rotl(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
15
    }
16
    //这里是循环左移一位，解决了sha0的危险点。
17

18
    uint32_t A = state[0];
19
    uint32_t B = state[1];
20
    uint32_t C = state[2];
21
    uint32_t D = state[3];
22
    uint32_t E = state[4];
23

24
    // 3. 80 步主循环
25
    for (int i = 0; i < 80; i++) {
26
        uint32_t F;
27
        uint32_t k;
28

29
        if (i < 20) {
30
            // 第 1 段：选择函数
31
            F = (B & C) | (~B & D);
32
            k = K[0];
33
        } else if (i < 40) {
34
            // 第 2 段：异或
35
            F = B ^ C ^ D;
36
            k = K[1];
37
        } else if (i < 60) {
38
            // 第 3 段：多数函数
39
            F = (B & C) | (B & D) | (C & D);
40
            k = K[2];
41
        } else {
42
            // 第 4 段：异或（和 20..39 相同）
43
            F = B ^ C ^ D;
44
            k = K[3];
45
        }
46

47
        uint32_t tmp = rotl(A, 5) + F + E + k + W[i]; //这里是循环左移5位，而md5是动态的s位
48
        E = D;
49
        D = C;
50
        C = rotl(B, 30);
51
        B = A;
52
        A = tmp;
53
    }
54

55
    // 4. 累加回 state
56
    state[0] += A;
57
    state[1] += B;
58
    state[2] += C;
59
    state[3] += D;
60
    state[4] += E;
61
}

1
// ============================================================
2
// 收尾：填充 + 写入原始长度 + 输出 20 字节摘要
3
// ============================================================
4
static void sha1Final(SHA1Context& ctx, uint8_t digest[20]) {
5
    uint8_t padding[64];
6
    std::memset(padding, 0, sizeof(padding));
7
    padding[0] = 0x80;
8

9
    uint64_t bits = ctx.bitCount;
10

11
    // 让 (bufferLen + 8) % 64 == 0
12
    size_t padLen = (ctx.bufferLen < 56)
13
                  ? (56 - ctx.bufferLen)
14
                  : (120 - ctx.bufferLen);
15

16
    //注意哈，虽然定义上是第一步就填充，但是咱们写代码时为了优化可以放在最后一步做。
17
    sha1Update(ctx, padding, padLen);
18

19
    // 64 位原始长度按大端序追加
20
    uint8_t lenBytes[8];
21
    for (int i = 0; i < 8; i++) {
22
        lenBytes[i] = (uint8_t)((bits >> (8 * (7 - i))) & 0xff);
23
    }
24
    sha1Update(ctx, lenBytes, 8);
25

26
    // 把 A..E 按大端序输出成 20 字节
27
    for (int i = 0; i < 5; i++) {
28
        write_be32(digest + i * 4, ctx.state[i]);
29
    }
30
}