Md5

最新推荐文章于 2024-07-26 13:15:00 发布
最新推荐文章于 2024-07-26 13:15:00 发布
阅读量443 收藏
点赞数
分类专栏： 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sz76211822/article/details/78250076
版权

头文件：

#ifndef __MD5__
#define __MD5__

#include <string>
using namespace std;

string GetMd5(const string& str);

#endif

.cpp 

#include "StdAfx.h"
#include "Md5.h"
#include <stdio.h>

typedef struct {
	unsigned int state[4];    
	unsigned int count[2];    
	unsigned char buffer[64];    
} MD5Context;
void MD5_Init(MD5Context * context);
void MD5_Update(MD5Context * context, unsigned char * buf, int len);
void MD5_Final(MD5Context * context, unsigned char digest[16]);
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static unsigned char PADDING[64] =
{0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define FF(a, b, c, d, x, s, ac)          \
{                       \
	(a) += F((b), (c), (d)) + (x) + (unsigned int)(ac); \
	(a) = ROTATE_LEFT((a), (s));           \
	(a) += (b);                 \
}
#define GG(a, b, c, d, x, s, ac)          \
{                       \
	(a) += G((b), (c), (d)) + (x) + (unsigned int)(ac); \
	(a) = ROTATE_LEFT((a), (s));           \
	(a) += (b);                 \
}
#define HH(a, b, c, d, x, s, ac)          \
{                       \
	(a) += H((b), (c), (d)) + (x) + (unsigned int)(ac); \
	(a) = ROTATE_LEFT((a), (s));           \
	(a) += (b);                 \
}
#define II(a, b, c, d, x, s, ac)          \
{                       \
	(a) += I((b), (c), (d)) + (x) + (unsigned int)(ac); \
	(a) = ROTATE_LEFT((a), (s));           \
	(a) += (b);                 \
}
static void MD5_Encode(unsigned char * output, unsigned int * input, int len)
{
	unsigned int i, j;
	for (i = 0, j = 0; j < len; i++, j += 4){
		output[j] = (unsigned char) (input[i] & 0xff);
		output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
		output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
		output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
	}
}
static void MD5_Decode(unsigned int * output, unsigned char * input, int len)
{
	unsigned int i, j;
	for (i = 0, j = 0; j < len; i++, j += 4){
		output[i] = ((unsigned int) input[j]) |
			(((unsigned int) input[j + 1]) << 8) |
			(((unsigned int) input[j + 2]) << 16) |
			(((unsigned int) input[j + 3]) << 24);
	}
}
static void MD5_Transform(unsigned int state[4], unsigned char block[64])
{
	unsigned int a = state[0], b = state[1], c = state[2], d = state[3], x[16];
	MD5_Decode(x, block, 64);
	/* Round 1 */
	FF(a, b, c, d, x[0], S11, 0xd76aa478);    /* 1 */
	FF(d, a, b, c, x[1], S12, 0xe8c7b756);    /* 2 */
	FF(c, d, a, b, x[2], S13, 0x242070db);    /* 3 */
	FF(b, c, d, a, x[3], S14, 0xc1bdceee);    /* 4 */
	FF(a, b, c, d, x[4], S11, 0xf57c0faf);    /* 5 */
	FF(d, a, b, c, x[5], S12, 0x4787c62a);    /* 6 */
	FF(c, d, a, b, x[6], S13, 0xa8304613);    /* 7 */
	FF(b, c, d, a, x[7], S14, 0xfd469501);    /* 8 */
	FF(a, b, c, d, x[8], S11, 0x698098d8);    /* 9 */
	FF(d, a, b, c, x[9], S12, 0x8b44f7af);    /* 10 */
	FF(c, d, a, b, x[10], S13, 0xffff5bb1);   /* 11 */
	FF(b, c, d, a, x[11], S14, 0x895cd7be);   /* 12 */
	FF(a, b, c, d, x[12], S11, 0x6b901122);   /* 13 */
	FF(d, a, b, c, x[13], S12, 0xfd987193);   /* 14 */
	FF(c, d, a, b, x[14], S13, 0xa679438e);   /* 15 */
	FF(b, c, d, a, x[15], S14, 0x49b40821);   /* 16 */
	/* Round 2 */
	GG(a, b, c, d, x[1], S21, 0xf61e2562);    /* 17 */

	GG(d, a, b, c, x[6], S22, 0xc040b340);    /* 18 */

	GG(c, d, a, b, x[11], S23, 0x265e5a51);   /* 19 */

	GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);    /* 20 */

	GG(a, b, c, d, x[5], S21, 0xd62f105d);    /* 21 */

	GG(d, a, b, c, x[10], S22, 0x2441453);    /* 22 */

	GG(c, d, a, b, x[15], S23, 0xd8a1e681);   /* 23 */

	GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);    /* 24 */

	GG(a, b, c, d, x[9], S21, 0x21e1cde6);    /* 25 */

	GG(d, a, b, c, x[14], S22, 0xc33707d6);   /* 26 */

	GG(c, d, a, b, x[3], S23, 0xf4d50d87);    /* 27 */

	GG(b, c, d, a, x[8], S24, 0x455a14ed);    /* 28 */

	GG(a, b, c, d, x[13], S21, 0xa9e3e905);   /* 29 */

	GG(d, a, b, c, x[2], S22, 0xfcefa3f8);    /* 30 */

	GG(c, d, a, b, x[7], S23, 0x676f02d9);    /* 31 */

	GG(b, c, d, a, x[12], S24, 0x8d2a4c8a);   /* 32 */



	/* Round 3 */

	HH(a, b, c, d, x[5], S31, 0xfffa3942);    /* 33 */

	HH(d, a, b, c, x[8], S32, 0x8771f681);    /* 34 */

	HH(c, d, a, b, x[11], S33, 0x6d9d6122);   /* 35 */

	HH(b, c, d, a, x[14], S34, 0xfde5380c);   /* 36 */

	HH(a, b, c, d, x[1], S31, 0xa4beea44);    /* 37 */

	HH(d, a, b, c, x[4], S32, 0x4bdecfa9);    /* 38 */

	HH(c, d, a, b, x[7], S33, 0xf6bb4b60);    /* 39 */

	HH(b, c, d, a, x[10], S34, 0xbebfbc70);   /* 40 */

	HH(a, b, c, d, x[13], S31, 0x289b7ec6);   /* 41 */

	HH(d, a, b, c, x[0], S32, 0xeaa127fa);    /* 42 */

	HH(c, d, a, b, x[3], S33, 0xd4ef3085);    /* 43 */

	HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */

	HH(a, b, c, d, x[9], S31, 0xd9d4d039);    /* 45 */

	HH(d, a, b, c, x[12], S32, 0xe6db99e5);   /* 46 */

	HH(c, d, a, b, x[15], S33, 0x1fa27cf8);   /* 47 */

	HH(b, c, d, a, x[2], S34, 0xc4ac5665);    /* 48 */



	/* Round 4 */

	II(a, b, c, d, x[0], S41, 0xf4292244);    /* 49 */

	II(d, a, b, c, x[7], S42, 0x432aff97);    /* 50 */

	II(c, d, a, b, x[14], S43, 0xab9423a7);   /* 51 */

	II(b, c, d, a, x[5], S44, 0xfc93a039);    /* 52 */

	II(a, b, c, d, x[12], S41, 0x655b59c3);   /* 53 */

	II(d, a, b, c, x[3], S42, 0x8f0ccc92);    /* 54 */

	II(c, d, a, b, x[10], S43, 0xffeff47d);   /* 55 */

	II(b, c, d, a, x[1], S44, 0x85845dd1);    /* 56 */

	II(a, b, c, d, x[8], S41, 0x6fa87e4f);    /* 57 */

	II(d, a, b, c, x[15], S42, 0xfe2ce6e0);   /* 58 */

	II(c, d, a, b, x[6], S43, 0xa3014314);    /* 59 */

	II(b, c, d, a, x[13], S44, 0x4e0811a1);   /* 60 */

	II(a, b, c, d, x[4], S41, 0xf7537e82);    /* 61 */

	II(d, a, b, c, x[11], S42, 0xbd3af235);   /* 62 */

	II(c, d, a, b, x[2], S43, 0x2ad7d2bb);    /* 63 */

	II(b, c, d, a, x[9], S44, 0xeb86d391);    /* 64 */



	state[0] += a;

	state[1] += b;

	state[2] += c;

	state[3] += d;



	memset((char *) x, 0, sizeof(x));
}



void MD5_Init(MD5Context * context)
{
	context->count[0] = context->count[1] = 0;
	context->state[0] = 0x67452301;
	context->state[1] = 0xefcdab89;
	context->state[2] = 0x98badcfe;
	context->state[3] = 0x10325476;
}



void MD5_Update(MD5Context * context, unsigned char * buf, int len)
{
	unsigned int i, index, partLen;
	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
	if ((context->count[0] += ((unsigned int) len << 3)) < ((unsigned int) len << 3)){
		context->count[1]++;
	}
	context->count[1] += ((unsigned int) len >> 29);
	partLen = 64 - index;
	if (len >= partLen){
		memcpy((char *) &context->buffer[index], (char *) buf, partLen);
		MD5_Transform(context->state, context->buffer);

		for (i = partLen; i + 63 < len; i += 64){
			MD5_Transform(context->state, &buf[i]);
		}
		index = 0;
	}
	else{
		i = 0;
	}

	memcpy((char *) &context->buffer[index], (char *) &buf[i], len - i);
}

void MD5_Final(MD5Context * context, unsigned char digest[16])
{
	unsigned char bits[8];
	unsigned int index, padLen;
	MD5_Encode(bits, context->count, 8);

	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
	padLen = (index < 56) ? (56 - index) : (120 - index);

	MD5_Update(context, PADDING, padLen);
	MD5_Update(context, bits, 8);
	MD5_Encode(digest, context->state, 16);
	memset((char *) context, 0, sizeof(*context));
}


string GetMd5(const string& str)
{
	unsigned char buff[16] = {0};

	int len = strlen(str.c_str());

	MD5Context context;
	MD5_Init(&context);
	MD5_Update(&context, (unsigned char *)str.c_str(), len);
	MD5_Final(&context, buff);
	string s = "";
	for(int j = 0; j < 16; j++){
		char cData[256] = {0};
		sprintf(cData, "%02X", buff[j]);
		s += cData;
	}
	return s;
}

调用： 

char str[1024] = {"官方原版_20170730095022.CPB20171016144841"};
	string s = GetMd5(str);


qq76211822
关注
专栏目录
C语言实现获取字符串的MD5码
06-27
计算一个字符串的md5码C语言实现！ 该压缩包包含：封装后的实现包含三部分：md5.h头文件、md5.c实现文件、test.c测试文件 md5.c文件最后实现了char* getMd5(char* str)获取字符串strmd5码的接口；可以直接调用。
计算字符串的md5值
06-17
通过此工具可以计算出字符串的md5值,方便开发测试人员使用，使用前确保安装了java环境
深入理解MD5算法：原理、应用与安全
最新发布
A_991128a的博客
07-26 872
MD5算法是一种广泛使用的哈希函数，用于生成128位（32个十六进制数字）的消息摘要。它接受任意长度的输入，并输出固定长度的哈希值，通常用于验证数据完整性、数字签名、密码存储等领域。MD5算法以其简洁高效的设计和快速计算速度而闻名，但近年来由于其存在一些安全性弱点，逐渐被更安全的哈希算法所取代。
c语言计算字符串md5,有人用c语言写过计算md5的么解决思路
weixin_42459078的博客
05-17 71
有人用c语言写过计算md5的么计算一个字符串的md5和计算一个文件的md5有什么区别？------解决方案--------------------仅供参考#include#include#include#includeconstunsignedints[4][4]={{7,12,17,22},{5,9,14,20},{4,11,16,23},{6,10,15,21}};constu...
计算字符串和文件的MD5值
三五月儿的专栏
01-03 3593
1、计算字符串的MD5值 public string GetMD5WithString(string sDataIn) { string str = ""; byte[] data = Encoding.GetEncoding("utf-8").GetBytes(str); MD5 md5 = new MD5CryptoServiceProvider();
计算一个字符串的MD5
克格莫（有需要的私信）
07-27 1588
import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * 使用方式:String test_md5 = MD5.MD5("test"); * @author shuaicenglou * */ public class MD5 { public static S
md5tools_md5_md5tools_
09-30
MD5助手是一款强大的实用工具，专门用于生成和比对文件的MD5哈希值。MD5，全称为Message-Digest Algorithm 5，是由Ron Rivest在1991年设计的一种广泛使用的加密散列函数，产生一个128位（16字节）的散列值，通常以32...
md5sum-code_md5sum_md5sum工具_
10-03
MD5SUM工具是Linux环境下广泛使用的命令行工具，主要用于计算文件的MD5校验和。MD5（Message-Digest Algorithm 5）是一种广泛应用于数据完整性检验的哈希函数，它能将任意长度的数据转化为固定长度的摘要信息。这个...
spark-md5-js中通用的md5加密
02-17
Spark-md5是一个用JavaScript编写的快速、高效的md5库。它根据MD5算法，将输入的任意长度的明文，经过一系列的操作，转换成一个128位（16字节）的密文。 Spark-md5实现了在浏览器中对文件进行哈希计算，并且在上传...
前端加密插件md5.js
02-24
前端加密插件md5.js MD5.js是对前端的明文数据进行MD5加密方式。是一个前端加密插件。 MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的...
VB6 MD5算法_vb6md5_VB6MD5验签_vb6_VB6MD5算法_
10-03
6. **MD5验签**：MD5验签是指预先计算好数据的MD5值并存储，之后在需要验证数据完整性的时刻，重新计算当前数据的MD5值并与预存的值进行比较。如果一致，则说明数据未被篡改。 7. **示例代码**：一个简单的VB6 MD5...
MD5计算器(计算32位和16位的字符串)
01-26
计算32位和16位的字符串 小巧而且很方便 很不错的
【java】计算字符串的MD5值
技术杂谈
10-03 5057
直接上代码 import java.security.MessageDigest; public static String MD5(String key) { char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ...
C语言实现计算一段字符串的MD5码
Magnum的博客
06-27 2271
MD5码的原理网上可以找到很多，这里只给出我自己封装的获取一段字符串的MD5码C语言实现！ 封装后的文件包含三部分：md5.h头文件、md5.c实现文件、test.c测试文件 1、md5.h头文件 #ifndef __MD5_H__ #define __MD5_H__ typedef struct { unsigned int count[2]; unsi...
javaScript中计算字符串MD5
weixin_33845881的博客
10-11 1251
进行HTTP网络通信的时候，调用API向服务器请求数据，有时为了防止API调用过程中被黑客恶意篡改，所请求参数需要进行MD5算法计算，得到摘要签名。服务端会根据请求参数，对签名进行验证，签名不合法的请求将会被拒绝。 但是目前原生JS貌似并没有提供MD5计算相关的函数方法，只能自己实现或者使用前辈大神写好的。网上找了下，找到了这个MD5的javaScript实现https://www.boo...
C语言求 MD5 值
hinewcc的博客
04-22 1919
C语言求 MD5 值
linux计算字符串md5值,计算字符串md5的几个方法
weixin_42400518的博客
04-29 2391
很多时候我们都需要计算md5用来做校验或者什么的，比如下了个iso，要做个校验看下到的文件是否没有损坏，从而刻盘啊什么的。这样的需求很好办，直接使用linux提供的工具即可：md5sum filename但是有时候我们只需要计算一个字符串的md5，这时可能很自然的想把这个字符串放进一个文件中，再计算这个文件的md5不就行了么。其实这种方法有个问题，就是在文件中这个字符串的末尾有不可见字符，比如换行...
C计算字符串和文件的MD5
Cloudy_cn的专栏
04-02 1501
这篇的MD5算法实现，比前一篇博文的实现更优雅，调用更简洁；可以很简易的计算数组/字符串和文件的MD5值。 md5.h文件 #ifndef MD5_H #define MD5_H typedef struct { unsigned int count[2]; unsigned int state[4]; unsigned char buffer[64]; }...
C语言字符串的MD5加密,如何对字符串进行MD5加密,用C语言实现,给出源代码和加密函数...
weixin_29224589的博客
05-17 188
满意答案daben5672013.11.01采纳率：49%等级：12已帮助：6508人UINT4 state[4]; /*存储原始信息的bits数长度,不包括填充的bits,最长为2^64 bits*/ UINT4 count[2]; /*存放输入的信息的缓冲区,512bits*/ unsigned char buffer[64];} MD5_CTX;static void MD5Tran...
C++实现MD5算法
这是一个关于MD5算法的C++实现，包含两个文件，`md5.h`头文件和`md5.cpp`源文件。MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，能够将任意长度的数据转化为固定长度的128位（16字节）摘要，通常以32...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值