速速收藏！纯C实现的MD5哈希校验算法~！

已于 2023-12-03 20:59:08 修改
阅读量795 收藏 11
点赞数 11
分类专栏： C/C++ 文章标签： 哈希算法 c语言 算法 MD5
于 2023-12-03 20:58:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq153471503/article/details/134770383
版权

速速收藏！纯C实现的MD5哈希校验算法~！

只有一个函数：
void MD5(const void* buf, unsigned int len, unsigned char output[16]);

在线验证网站：https://www.sojson.com/md5/

头文件

/**
 * \file md5.h
 *
 * \brief MD5 message digest algorithm (hash function)
 */

#ifndef MD5_H__
#define MD5_H__

#ifdef __cplusplus
extern "C" {
#endif

void MD5(const void* buf, unsigned int len, unsigned char output[16]);

#ifdef __cplusplus
}
#endif

#endif

源文件

/**
 * \file md5.c
 *
 * \brief MD5 message digest algorithm (hash function)
 */

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

#include "md5.h"

typedef struct
{
    uint32_t total[2];          /*!< number of bytes processed  */
    uint32_t state[4];          /*!< intermediate digest state  */
    unsigned char buffer[64];   /*!< data block being processed */
}md5_context;

/*
 * 32-bit integer manipulation macros (little endian)
 */

#define GET_UINT32_LE(n,b,i)                            \
{                                                       \
    (n) = ( (uint32_t) (b)[(i)    ]       )             \
        | ( (uint32_t) (b)[(i) + 1] <<  8 )             \
        | ( (uint32_t) (b)[(i) + 2] << 16 )             \
        | ( (uint32_t) (b)[(i) + 3] << 24 );            \
}

#define PUT_UINT32_LE(n,b,i)                                    \
{                                                               \
    (b)[(i)    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \
    (b)[(i) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \
    (b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF );    \
    (b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF );    \
}

void md5_internal_process(md5_context *ctx, const unsigned char data[64])
{
    uint32_t X[16], A, B, C, D;

    GET_UINT32_LE( X[ 0], data,  0 );
    GET_UINT32_LE( X[ 1], data,  4 );
    GET_UINT32_LE( X[ 2], data,  8 );
    GET_UINT32_LE( X[ 3], data, 12 );
    GET_UINT32_LE( X[ 4], data, 16 );
    GET_UINT32_LE( X[ 5], data, 20 );
    GET_UINT32_LE( X[ 6], data, 24 );
    GET_UINT32_LE( X[ 7], data, 28 );
    GET_UINT32_LE( X[ 8], data, 32 );
    GET_UINT32_LE( X[ 9], data, 36 );
    GET_UINT32_LE( X[10], data, 40 );
    GET_UINT32_LE( X[11], data, 44 );
    GET_UINT32_LE( X[12], data, 48 );
    GET_UINT32_LE( X[13], data, 52 );
    GET_UINT32_LE( X[14], data, 56 );
    GET_UINT32_LE( X[15], data, 60 );

#define S(x,n)                                                          \
    ( ( (x) << (n) ) | ( ( (x) & 0xFFFFFFFF) >> ( 32 - (n) ) ) )

#define P(a,b,c,d,k,s,t)                                        \
    do                                                          \
    {                                                           \
        (a) += F((b),(c),(d)) + X[(k)] + (t);                   \
        (a) = S((a),(s)) + (b);                                 \
    } while( 0 )

    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];

#define F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))

    P( A, B, C, D,  0,  7, 0xD76AA478 );
    P( D, A, B, C,  1, 12, 0xE8C7B756 );
    P( C, D, A, B,  2, 17, 0x242070DB );
    P( B, C, D, A,  3, 22, 0xC1BDCEEE );
    P( A, B, C, D,  4,  7, 0xF57C0FAF );
    P( D, A, B, C,  5, 12, 0x4787C62A );
    P( C, D, A, B,  6, 17, 0xA8304613 );
    P( B, C, D, A,  7, 22, 0xFD469501 );
    P( A, B, C, D,  8,  7, 0x698098D8 );
    P( D, A, B, C,  9, 12, 0x8B44F7AF );
    P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
    P( B, C, D, A, 11, 22, 0x895CD7BE );
    P( A, B, C, D, 12,  7, 0x6B901122 );
    P( D, A, B, C, 13, 12, 0xFD987193 );
    P( C, D, A, B, 14, 17, 0xA679438E );
    P( B, C, D, A, 15, 22, 0x49B40821 );

#undef F

#define F(x,y,z) ((y) ^ ((z) & ((x) ^ (y))))

    P( A, B, C, D,  1,  5, 0xF61E2562 );
    P( D, A, B, C,  6,  9, 0xC040B340 );
    P( C, D, A, B, 11, 14, 0x265E5A51 );
    P( B, C, D, A,  0, 20, 0xE9B6C7AA );
    P( A, B, C, D,  5,  5, 0xD62F105D );
    P( D, A, B, C, 10,  9, 0x02441453 );
    P( C, D, A, B, 15, 14, 0xD8A1E681 );
    P( B, C, D, A,  4, 20, 0xE7D3FBC8 );
    P( A, B, C, D,  9,  5, 0x21E1CDE6 );
    P( D, A, B, C, 14,  9, 0xC33707D6 );
    P( C, D, A, B,  3, 14, 0xF4D50D87 );
    P( B, C, D, A,  8, 20, 0x455A14ED );
    P( A, B, C, D, 13,  5, 0xA9E3E905 );
    P( D, A, B, C,  2,  9, 0xFCEFA3F8 );
    P( C, D, A, B,  7, 14, 0x676F02D9 );
    P( B, C, D, A, 12, 20, 0x8D2A4C8A );

#undef F

#define F(x,y,z) ((x) ^ (y) ^ (z))

    P( A, B, C, D,  5,  4, 0xFFFA3942 );
    P( D, A, B, C,  8, 11, 0x8771F681 );
    P( C, D, A, B, 11, 16, 0x6D9D6122 );
    P( B, C, D, A, 14, 23, 0xFDE5380C );
    P( A, B, C, D,  1,  4, 0xA4BEEA44 );
    P( D, A, B, C,  4, 11, 0x4BDECFA9 );
    P( C, D, A, B,  7, 16, 0xF6BB4B60 );
    P( B, C, D, A, 10, 23, 0xBEBFBC70 );
    P( A, B, C, D, 13,  4, 0x289B7EC6 );
    P( D, A, B, C,  0, 11, 0xEAA127FA );
    P( C, D, A, B,  3, 16, 0xD4EF3085 );
    P( B, C, D, A,  6, 23, 0x04881D05 );
    P( A, B, C, D,  9,  4, 0xD9D4D039 );
    P( D, A, B, C, 12, 11, 0xE6DB99E5 );
    P( C, D, A, B, 15, 16, 0x1FA27CF8 );
    P( B, C, D, A,  2, 23, 0xC4AC5665 );

#undef F

#define F(x,y,z) ((y) ^ ((x) | ~(z)))

    P( A, B, C, D,  0,  6, 0xF4292244 );
    P( D, A, B, C,  7, 10, 0x432AFF97 );
    P( C, D, A, B, 14, 15, 0xAB9423A7 );
    P( B, C, D, A,  5, 21, 0xFC93A039 );
    P( A, B, C, D, 12,  6, 0x655B59C3 );
    P( D, A, B, C,  3, 10, 0x8F0CCC92 );
    P( C, D, A, B, 10, 15, 0xFFEFF47D );
    P( B, C, D, A,  1, 21, 0x85845DD1 );
    P( A, B, C, D,  8,  6, 0x6FA87E4F );
    P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
    P( C, D, A, B,  6, 15, 0xA3014314 );
    P( B, C, D, A, 13, 21, 0x4E0811A1 );
    P( A, B, C, D,  4,  6, 0xF7537E82 );
    P( D, A, B, C, 11, 10, 0xBD3AF235 );
    P( C, D, A, B,  2, 15, 0x2AD7D2BB );
    P( B, C, D, A,  9, 21, 0xEB86D391 );

#undef F

    ctx->state[0] += A;
    ctx->state[1] += B;
    ctx->state[2] += C;
    ctx->state[3] += D;
}

/*
 * MD5 process buffer
 */
static void md5_update( md5_context *ctx, const unsigned char *input, size_t ilen)
{
    size_t fill;
    uint32_t left;

    if( ilen == 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (uint32_t) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (uint32_t) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left), input, fill );
        md5_internal_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
    	md5_internal_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left), input, ilen );
    }
}

/*
 * MD5 final digest
 */
static void md5_finish( md5_context *ctx, unsigned char output[16])
{
    uint32_t used;
    uint32_t high, low;

    /*
     * Add padding: 0x80 then 0x00 until 8 bytes remain for the length
     */
    used = ctx->total[0] & 0x3F;

    ctx->buffer[used++] = 0x80;

    if( used <= 56 )
    {
        /* Enough room for padding + length in current block */
        memset( ctx->buffer + used, 0, 56 - used );
    }
    else
    {
        /* We'll need an extra block */
        memset( ctx->buffer + used, 0, 64 - used );

        md5_internal_process( ctx, ctx->buffer );

        memset( ctx->buffer, 0, 56 );
    }

    /*
     * Add message length
     */
    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32_LE( low,  ctx->buffer, 56 );
    PUT_UINT32_LE( high, ctx->buffer, 60 );

    md5_internal_process( ctx, ctx->buffer );

    /*
     * Output final state
     */
    PUT_UINT32_LE( ctx->state[0], output,  0 );
    PUT_UINT32_LE( ctx->state[1], output,  4 );
    PUT_UINT32_LE( ctx->state[2], output,  8 );
    PUT_UINT32_LE( ctx->state[3], output, 12 );
}

void MD5(const void* buf, unsigned int len, unsigned char output[16])
{
    md5_context ctx = {0};
    ctx.total[0] = 0;
    ctx.total[1] = 0;
    ctx.state[0] = 0x67452301;
    ctx.state[1] = 0xEFCDAB89;
    ctx.state[2] = 0x98BADCFE;
    ctx.state[3] = 0x10325476;
    md5_update(&ctx, (unsigned char *)buf, len);
    md5_finish(&ctx, output);
}


#if 0
#include <stdio.h>
#include <stdlib.h>
#include "md5.h"

/*

verify online: https://www.sojson.com/md5/

testdata:helloworld1234567890
md5(hex):cee76d16b6c243c1cd7c7ecc677de87d

 */

int main(void)
{
	const char* testdata = "helloworld1234567890";
	uint8_t md5[16];
	MD5(testdata, strlen(testdata), md5);
	printf("testdata:%s\n", testdata);
	printf("md5(hex):");
	for(int i = 0; i < 16; i++)
	{
		printf("%02x", md5[i]);
	}
	printf("\n");
	return 0;
}
#endif
觉皇嵌入式
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用C语言实现MD5哈希函数
01-12
用C语言实现MD5哈希函数，它是将文件的每一行进行MD5加密，输出一个128位的哈希值。
MD5校验及其c实现
weixin_33834137的博客
06-07 525
那么MD5校验是什么？     一般软件或者说文件都有自己的固定文件格式或者架构信息，说简单一点就是。”世界上没有完全相同的2片叶子” ，因为MD5是一种不可逆的加密算法。      那么对于某些网上公开下载的软件，视频，尤其是镜像文件。如果被修改了可能会导致用不了或者其他的问题，发布者镜像MD5算法计算一组数值。让下载的用户 进行MD5数值对比，也就是MD5校验啦。由于MD5加密不可逆算，如...
【MD5算法_C语言实现】
Sugar_wolf的博客
01-18 3089
Message Digest Algorithm 消息摘要算法： 5表示第5版 算法的文件号为RFC 1321 本质： 算法不可逆 不同的数据可能会生成相同的一串 有破解之道，比如穷举法，暴力破解。 根据生成的数据串，在数据库中找生成他的数据数据库是在时时刻刻的收集枚举各种数据组合。 应用：比如登录密码 本地注册时填入密码，本地将密码转成md5串，传输给服务器，服务器存的密码就是md5串。中途被坏人劫走的密码，劫走的只是md5串，而不是密码本身，这也是一种保护。 很多验证都应用的md5 ...
C语言实现MD5加密
叶落花枯的博客
09-05 4822
  MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。   MD5算法可以对任意长度的输入串经过计算得到固定长度的输出，而且只有在明文相同的情况下，才能等到相同的密文，并且这个算法是不可逆的，即便得到了加密以后的密文，也不可能通过解密算法反算出明文。   MD5算法主要的应用场景有：  头文件 md5.h   源文件 md5.c   测试示例....
C语言实现的MD5库
12-29
用C语言实现的MD5库。使用方法见http://blog.csdn.net/huang_yx005/article/details/53911477
解析MD5加密算法(C语言)
沐一 · 林 的博客
12-24 3896
目录 前提概要： MD5加密4步骤： C语言实现MD5算法：（假设加密 iscbupt ） 附上运行中间结果图： 字符串和文件加密实例： 前提概要： 本篇内容基于haroroda博客的MD5加密算法（c语言实现）和 艾蔓草博客的C语言实现md5函数代码，只是进行简单的融合并附上自己的理解而已，有需要的可以自己浏览上面两篇优秀的博客。 MD5加密4步骤： （1）附加填充位 课本原话：填充一个 ‘1’ 和若干个 ‘0’ 使其长度模 512 与 448 同余，然后再将...
C语言/实现MD5加密
一口Linux的专栏
02-19 1419
MD5算法也叫摘要认证
C语言实现MD5算法
萧海的博客
04-23 3075
#include <stdio.h> #include <stdlib.h> #include <time.h> #include <string.h> typedef unsigned char *POINTER; typedef unsigned short int UINT2; typedef unsigned long int UINT4; typedef struct { UINT4 state[4]; UINT4 count[2
MD5算法的C语言实现
White3zz的博客
11-18 2061
算法原理概述 MD5信息摘要算法，( Message-Digest Algorithm 5)，是一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值，用于确保信息传输完整一致。 MD5算法使用little-endian（小端模式，即低位字节存在内存低地址），输入任意不定长度信息，算法都首先将其以512-bit进行分组（不足补位），每个512-bit的分组都和四个32-bit的数...
C语言实例_获取文件MD5值
08-18 1941
MD5（Message Digest Algorithm 5）是一种常用的哈希函数算法。将任意长度的数据作为输入，并生成一个唯一的、固定长度（通常是128位）的哈希值，称为MD5值。MD5算法以其高度可靠性和广泛应用而闻名。
C语言实现Cockoo哈希算法
11-09
用C语言实现了Cockoo哈希算法，采用CRC校验值作为种子参数计算哈希值，并用顺序MAC地址作为验证数据进行了测试，512K即以下的数据量表现优异
sha256 哈希算法 c语言实现
08-10
亲测可要使用 * Filename: sha256.c * Author: Brad Conte (brad AT bradconte.com) * Copyright: * Disclaimer: This code is presented "as is" without any guarantees.
MD5_哈希算法_md5_
10-04
MD5哈希算法， 任意长度数据提取出固定长度的数组，MD5 hash algorithm
哈希值MD5校验工具.zip
07-23
哈希值MD5校验工具.zip
md5加密算法 C语言（经过测试验证完整版）
01-12
md5加密算法 C语言（经过测试验证完整版） 经过调试验证,与工具结果一致 MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。1996年后该算法被证实存在弱点，可以被加以破解，对于需要高度安全性的数据，专家一般建议改用其他算法，如SHA-2。2004年，证实MD5算法无法防止碰撞（collision），因此不适用于安全性认证，如SSL公开密钥认证或是数字签名等用途。
MD5哈希算法的C++实现（兼容大端字节序的CPU）
最新发布
04-30
MD5哈希算法的C++实现（兼容大端字节序的CPU） 测试代码 #include #include #include"md5.c" int main() { using namespace std; u8 $finalHash[16] = {}; const char* str = "a"; //调用MD5 int ret = ...
C语言实现md5函数代码
热门推荐
xhhjin的专栏
12-29 7万+
网上找到的实现md5函数代码，包括一个头文件md5.h和一个源文件md5.c，用下面的测试代码test.c测试通过，各文件依次如下： 头文件md5.h #ifndef MD5_H #define MD5_H typedef struct { unsigned int count[2]; unsigned int state[4]; unsigned char
什么是MD5,用C语言实现MD5算法
记录 IT 领域经验与见解的博客
05-05 1436
SHA算法是MD5的发展和扩展，它对MD5算法存在的缺陷进行了修复和改进，提供了更高的安全性和更大的哈希值长度。SHA-2又对SHA-1进行了进一步改进，提供了多个哈希值长度可选的算法，包括SHA-224、SHA-256、SHA-384和SHA-512等；最新的SHA-3则完全摒弃了MD5和SHA-2的设计思路，采用了一种全新的哈希算法。数据签名的主要过程是首先将消息进行哈希计算，然后把哈希值加密，最后把加密后的哈希值与原始消息一起传输，接收方再进行相同的哈希计算和加密验证，以确保消息的完整性和真实性。
Android MD5加密
Gary__123456的博客
07-12 624
MD5算法具有以下特点:1、压缩性:任意长度的数据，算出的MD5值长度都是固定的。2、容易计算:从原数据计算出MD5值很容易。3、抗修改性:对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。4、强抗碰撞:已知原数据和其MD5值，想找到一个具有相同MD5值的数据(即伪造数据)是非常困难的。代码实现：private static String MD5(String s) throw
c语言md5 哈希算法
05-17
MD5是一种常见的哈希算法，可以将任意长度的数据转换为固定长度的哈希值。以下是一个使用C语言实现MD5哈希算法的例子： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c)))) void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) { // 初始化变量 uint32_t h0, h1, h2, h3; h0 = 0x67452301; h1 = 0xEFCDAB89; h2 = 0x98BADCFE; h3 = 0x10325476; // 消息填充 uint8_t *msg = NULL; size_t new_len, offset; for (new_len = initial_len + 1; new_len % 64 != 56; new_len++); msg = (uint8_t*)calloc(new_len + 8, 1); memcpy(msg, initial_msg, initial_len); msg[initial_len] = 0x80; offset = new_len - 8; *((uint64_t*)(msg + offset)) = (uint64_t)initial_len * 8; // 处理消息块 uint32_t *w = (uint32_t *)msg; uint32_t a, b, c, d, i, f, g, temp; for (i = 0; i < new_len; i += 16) { a = h0; b = h1; c = h2; d = h3; // Round 1 for (uint8_t j = 0; j < 16; j++) { f = (b & c) | ((~b) & d); g = j; temp = d; d = c; c = b; b = b + LEFTROTATE((a + f + w[g] + 0x5A827999), 5); a = temp; } // Round 2 for (uint8_t j = 16; j < 32; j++) { f = (d & b) | ((~d) & c); g = (5 * j + 1) % 16; temp = d; d = c; c = b; b = b + LEFTROTATE((a + f + w[g] + 0x6ED9EBA1), 5); a = temp; } // Round 3 for (uint8_t j = 32; j < 48; j++) { f = b ^ c ^ d; g = (3 * j + 5) % 16; temp = d; d = c; c = b; b = b + LEFTROTATE((a + f + w[g] + 0x8F1BBCDC), 5); a = temp; } // Round 4 for (uint8_t j = 48; j < 64; j++) { f = c ^ (b | (~d)); g = (7 * j) % 16; temp = d; d = c; c = b; b = b + LEFTROTATE((a + f + w[g] + 0xCA62C1D6), 5); a = temp; } // 更新哈希值 h0 += a; h1 += b; h2 += c; h3 += d; } // 释放内存 free(msg); // 生成哈希值 *((uint32_t*)(digest)) = h0; *((uint32_t*)(digest + 4)) = h1; *((uint32_t*)(digest + 8)) = h2; *((uint32_t*)(digest + 12)) = h3; } int main() { uint8_t digest[16]; char *msg = "hello world"; md5((uint8_t*)msg, strlen(msg), digest); for (int i = 0; i < 16; i++) { printf("%02x", digest[i]); } return 0; } ``` 在这个例子中，我们使用了C语言和标准库函数来实现MD5哈希算法。首先，我们定义了一个`md5`函数，该函数接受输入消息、输入长度和哈希值缓冲区，并将哈希值存储在缓冲区中。 在`md5`函数中，我们首先初始化了四个32位的变量`h0`、`h1`、`h2`和`h3`，这些变量将用于存储哈希值。然后，我们对输入消息进行填充，以确保其长度为64的倍数。接下来，我们将填充后的消息分成16个32位的块，并使用四个循环来处理每个块。 在每个循环中，我们使用一系列运算来更新哈希值。具体来说，我们使用了四个轮（Round 1、Round 2、Round 3和Round 4），每个轮使用不同的逻辑函数和常量。最后，我们将更新后的哈希值存储在变量`h0`、`h1`、`h2`和`h3`中，并将其转换为字节序列，存储在哈希值缓冲区中。 在`main`函数中，我们定义了一个输入消息字符串，并使用`md5`函数将其哈希为一个16字节的哈希值。最后，我们打印出哈希值的十六进制表示。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

觉皇嵌入式

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值