什么是哈希算法,用C语言模拟哈希算法

哈希算法（Hash Algorithm）又称散列算法、摘要算法，它是一种将任意长度的消息压缩到一个固定长度的输出的算法。哈希算法通过一个函数，将任意长度的数据转换成一段固定长度的数据串，该数据串通常被称为哈希值、散列值、摘要或者指纹。哈希算法主要用于确保数据完整性、提高密码安全性、进行数据索引或者作为数据唯一标识等场合。

哈希算法的特点：

1. 任意长度的输入数据，纷繁复杂的数据流可以通过哈希算法转换为固定长度，通常为128位、160位、256位等。

2. 具有高效性：哈希算法的计算速度相对于加密算法较快，可以在很短时间内对大量数据进行哈希值的计算。

3. 强大的单向作用：哈希值可以很容易的计算出来，但是通过哈希值推算出数据源的过程极其困难，即Hash算法具有强大的单向作用。

4. 散列碰撞的概率非常小：散列碰撞是指不同的数据输入，哈希值得输出结果相同的情况。经过严格的测试，大多数哈希算法在实际运行过程中很少出现这种情况。

常用的哈希算法：

1. MD5（Message-Digest Algorithm 5）：哈希值为128位，是一种广泛使用的哈希算法，但是在安全方面存在一些缺陷，已经不再被推荐使用了。

2. SHA（Secure Hash Algorithm）：哈希值为160位，也是一种广泛使用的哈希算法，安全性比MD5更好，但相对于最新的SHA-3算法，性能较慢。

3. SHA-3：哈希值为224位、256位、384位、512位等不同长度，是一种安全性高、性能良好的哈希算法，目前是最新的哈希算法。

哈希算法应用：

1. 数据库索引：哈希算法可以将任何大小的数据快速压缩到一个固定长度的值，这可以帮助数据库实现更快的查询和索引。

2. 数字签名：哈希算法可以用于数字签名，用私钥校验哈希值可以验证数据是否被篡改过。

3. 密码存储：哈希算法可以对密码进行单向加密存储，避免密码泄露。

4. 消息认证码：哈希算法可以与密钥配合使用构建消息认证码（MAC），用于数据的完整性验证和防伪。

总之，哈希算法是一种高效、强大、广泛应用的算法，可以用于数据安全、数据完整性验证、数据压缩和加密存储等等领域，是计算机安全和数据管理的基础之一。

---

以下是使用C语言实现SHA-1哈希算法的示例代码：

#include 
#include 

// 左旋转函数
#define ROTL(a, b) (((a) << (b)) | ((a) >> (32 - (b))))

// 定义常用函数
#define Ch(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
#define Parity(x, y, z) ((x) ^ (y) ^ (z))
#define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))

// 定义常量
const uint32_t k[] = {
    0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
};

// 定义函数
void sha1(const uint8_t *msg, size_t len, uint32_t h[5]) {
    uint32_t w[80];
    uint32_t a, b, c, d, e, t;
    size_t i, j;
    uint64_t bitlen = len * 8;
    uint8_t *p = (uint8_t *)w;

    // 初始化
    h[0] = 0x67452301;
    h[1] = 0xEFCDAB89;
    h[2] = 0x98BADCFE;
    h[3] = 0x10325476;
    h[4] = 0xC3D2E1F0;

    // 填充
    p[len] = 0x80;
    len++;
    if (len % 64 > 56) {
        len += 64 - len % 64;
    }
    len += 8;
    *((uint64_t *)(p + len - 8)) = bitlen;

    // 执行哈希计算
    for (i = 0; i < len; i += 64) {
        // 计算w
        for (j = 0; j < 16; j++) {
            w[j] = (uint32_t)(p[i + j * 4 + 0]) << 24;
            w[j] |= (uint32_t)(p[i + j * 4 + 1]) << 16;
            w[j] |= (uint32_t)(p[i + j * 4 + 2]) << 8;
            w[j] |= (uint32_t)(p[i + j * 4 + 3]) << 0;
        }
        for (j = 16; j < 80; j++) {
            w[j] = ROTL(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
        }

        // 初始化abcde
        a = h[0];
        b = h[1];
        c = h[2];
        d = h[3];
        e = h[4];

        // 执行80轮循环
        for (j = 0; j < 80; j++) {
            t = ROTL(a, 5) + k[j / 20] + w[j];
            if (j < 20) {
                t += Ch(b, c, d);
            } else if (j < 40) {
                t += Parity(b, c, d);
            } else if (j < 60) {
                t += Maj(b, c, d);
            } else { // j < 80
                t += Parity(b, c, d);
            }
            e = d;
            d = c;
            c = ROTL(b, 30);
            b = a;
            a = t;
        }

        // 更新abcde
        h[0] += a;
        h[1] += b;
        h[2] += c;
        h[3] += d;
        h[4] += e;
    }
}

int main() {
    uint8_t msg[] = "Hello, world!";
    uint32_t h[5];
    size_t len = sizeof(msg) - 1;
    size_t i;

    // 执行哈希算法
    sha1(msg, len, h);

    // 打印结果
    printf("hash: ");
    for (i = 0; i < 5; i++) {
        printf("%08x", h[i]);
    }
    printf("\n");

    return 0;
}