好的，下面是一个简单的 C 语言实现 SHA-256 算法的示例，包含 `init`、`update` 和 `finish` 三个过程。输入和输出都是 `uint8_t` 类型的数组。 ```c #include <stdint.h> #include <string.h> // 定义 SHA-256 的常量和初始哈希值 #define SHA256_BLOCK_SIZE 64 #define SHA256_DIGEST_SIZE 32 typedef struct { uint32_t state[8]; uint64_t count; uint8_t buffer[SHA256_BLOCK_SIZE]; int buffer_offset; } SHA256_CTX; // 初始化上下文 void sha256_init(SHA256_CTX *ctx) { ctx->state[0] = 0x6a09e667; ctx->state[1] = 0xbb67ae85; ctx->state[2] = 0x3c6ef372; ctx->state[3] = 0xa54ff53a; ctx->state[4] = 0x510e527f; ctx->state[5] = 0x9b05688c; ctx->state[6] = 0x1f83d9ab; ctx->state[7] = 0x5be0cd19; ctx->count = 0; ctx->buffer_offset = 0; } // 更新上下文 void sha256_update(SHA256_CTX *ctx, const uint8_t *data, size_t len) { size_t i; for (i = 0; i < len; ++i) { ctx->buffer[ctx->buffer_offset++] = data[i]; if (ctx->buffer_offset == SHA256_BLOCK_SIZE) { sha256_process_block(ctx); ctx->buffer_offset = 0; } } ctx->count += len; } // 处理一个块 void sha256_process_block(SHA256_CTX *ctx) { uint32_t a, b, c, d, e, f, g, h; uint32_t w[64]; int t; // 初始化工作变量 a = ctx->state[0]; b = ctx->state[1]; c = ctx->state[2]; d = ctx->state[3]; e = ctx->state[4]; f = ctx->state[5]; g = ctx->state[6]; h = ctx->state[7]; // 扩展消息 for (t = 0; t < 16; ++t) { w[t] = (ctx->buffer[t * 4 + 0] << 24) | (ctx->buffer[t * 4 + 1] << 16) | (ctx->buffer[t * 4 + 2] << 8) | (ctx->buffer[t * 4 + 3]); } for (t = 16; t < 64; ++t) { w[t] = (sigma1(w[t - 2]) + w[t - 7] + sigma0(w[t - 15]) + w[t - 16]) & 0xFFFFFFFF; } // 主循环 for (t = 0; t < 64; ++t) { uint32_t T1 = h + Sigma1(e) + Ch(e, f, g) + K[t] + w[t]; uint32_t T2 = Sigma0(a) + Maj(a, b, c); h = g; g = f; f = e; e = (d + T1) & 0xFFFFFFFF; d = c; c = b; b = a; a = (T1 + T2) & 0xFFFFFFFF; } // 更新状态 ctx->state[0] = (ctx->state[0] + a) & 0xFFFFFFFF; ctx->state[1] = (ctx->state[1] + b) & 0xFFFFFFFF; ctx->state[2] = (ctx->state[2] + c) & 0xFFFFFFFF; ctx->state[3] = (ctx->state[3] + d) & 0xFFFFFFFF; ctx->state[4] = (ctx->state[4] + e) & 0xFFFFFFFF; ctx->state[5] = (ctx->state[5] + f) & 0xFFFFFFFF; ctx->state[6] = (ctx->state[6] + g) & 0xFFFFFFFF; ctx->state[7] = (ctx->state[7] + h) & 0xFFFFFFFF; } // 完成哈希计算 void sha256_finish(SHA256_CTX *ctx, uint8_t digest[SHA256_DIGEST_SIZE]) { uint8_t padding[SHA256_BLOCK_SIZE]; size_t padlen; size_t i; // 添加填充 memset(padding, 0, sizeof(padding)); padding[0] = 0x80; padlen = (56 - (ctx->count % 64)) % 64; sha256_update(ctx, padding, padlen); // 添加长度 uint64_t length = ctx->count * 8; sha256_update(ctx, (const uint8_t *)&length, 8); // 输出结果 for (i = 0; i < 8; ++i) { digest[i * 4 + 0] = (ctx->state[i] >> 24) & 0xFF; digest[i * 4 + 1] = (ctx->state[i] >> 16) & 0xFF; digest[i * 4 + 2] = (ctx->state[i] >> 8) & 0xFF; digest[i * 4 + 3] = ctx->state[i] & 0xFF; } } // 辅助函数 static inline uint32_t Sigma0(uint32_t x) { return (x >> 2) | (x << 30); } static inline uint32_t Sigma1(uint32_t x) { return (x >> 6) | (x << 26); } static inline uint32_t sigma0(uint32_t x) { return (x >> 7) | (x << 25); } static inline uint32_t sigma1(uint32_t x) { return (x >> 18) | (x << 14); } static inline uint32_t Ch(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (~x & z); } static inline uint32_t Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (x & z) ^ (y & z); } static const uint32_t K[64] = { 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. **缓冲区管理**：在 `update` 函数中，需要正确管理缓冲区，确保每次处理完整的消息块。 2. **填充和长度附加**：在 `finish` 函数中，正确处理消息的填充和长度附加，确保符合 SHA-256 标准。 3. **状态更新**：在 `process_block` 函数中，正确更新状态变量，确保每个块的处理结果正确累积到最终的哈希值中。 [2024-12-01 09:33:52 | AI写代码神器 | 2413点数解答]