c语言sha1代码

以下是一份C语言实现的SHA-1算法代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c))))

void sha1(const char* message, uint32_t* hash) {
    uint32_t h[5] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
    uint32_t k[4] = { 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
    uint32_t w[80];

    size_t message_len = strlen(message);

    // append the '1' bit
    uint8_t* padded_message = (uint8_t*)calloc(message_len + 9, sizeof(uint8_t));
    memcpy(padded_message, message, message_len);
    padded_message[message_len] = 0x80;

    // append length
    uint64_t bit_len = message_len * 8;
    padded_message[message_len + 7] = (bit_len >> 0) & 0xFF;
    padded_message[message_len + 6] = (bit_len >> 8) & 0xFF;
    padded_message[message_len + 5] = (bit_len >> 16) & 0xFF;
    padded_message[message_len + 4] = (bit_len >> 24) & 0xFF;
    padded_message[message_len + 3] = (bit_len >> 32) & 0xFF;
    padded_message[message_len + 2] = (bit_len >> 40) & 0xFF;
    padded_message[message_len + 1] = (bit_len >> 48) & 0xFF;
    padded_message[message_len + 0] = (bit_len >> 56) & 0xFF;

    // process message in 512-bit chunks
    for (size_t i = 0; i < (message_len + 8) / 64; ++i) {
        // break chunk into sixteen 32-bit big-endian words
        for (size_t j = 0; j < 16; ++j) {
            w[j] = (padded_message[i * 64 + j * 4 + 0] << 24) |
                   (padded_message[i * 64 + j * 4 + 1] << 16) |
                   (padded_message[i * 64 + j * 4 + 2] << 8) |
                   (padded_message[i * 64 + j * 4 + 3] << 0);
        }

        // extend sixteen 32-bit words into eighty 32-bit words
        for (size_t j = 16; j < 80; ++j) {
            w[j] = LEFTROTATE((w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16]), 1);
        }

        // initialize hash value for this chunk
        uint32_t a = h[0];
        uint32_t b = h[1];
        uint32_t c = h[2];
        uint32_t d = h[3];
        uint32_t e = h[4];

        // main loop
        for (size_t j = 0; j < 80; ++j) {
            uint32_t f;
            uint32_t k;

            if (j < 20) {
                f = (b & c) | ((~b) & d);
                k = 0x5A827999;
            } else if (j < 40) {
                f = b ^ c ^ d;
                k = 0x6ED9EBA1;
            } else if (j < 60) {
                f = (b & c) | (b & d) | (c & d);
                k = 0x8F1BBCDC;
            } else {
                f = b ^ c ^ d;
                k = 0xCA62C1D6;
            }

            uint32_t temp = LEFTROTATE(a, 5) + f + e + k + w[j];
            e = d;
            d = c;
            c = LEFTROTATE(b, 30);
            b = a;
            a = temp;
        }

        // add this chunk's hash to result so far
        h[0] += a;
        h[1] += b;
        h[2] += c;
        h[3] += d;
        h[4] += e;
    }

    // free memory
    free(padded_message);

    // write hash to output buffer
    memcpy(hash, h, 5 * sizeof(uint32_t));
}

int main() {
    const char* message = "The quick brown fox jumps over the lazy dog";
    uint32_t hash[5];
    sha1(message, hash);

    printf("SHA-1 Hash of \"%s\":\n", message);
    printf("%08X %08X %08X %08X %08X\n", hash[0], hash[1], hash[2], hash[3], hash[4]);

    return 0;
}

该实现将消息分成512位的块，并对每个块应用SHA-1压缩函数。最终哈希值由5个32位字组成。