MD5 C++源码 亲测可运行

最新推荐文章于 2024-09-10 11:16:14 发布
最新推荐文章于 2024-09-10 11:16:14 发布
阅读量1k 收藏 2
点赞数
分类专栏： 技术源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linmude/article/details/39274555
版权
这是一个C++编写的MD5类，包含初始化、更新输入、转换、编码、解码等功能，支持从字符串、输入流计算MD5摘要，并能将结果转换为16进制字符串。
摘要由CSDN通过智能技术生成

源代码：
MD5.h 
#pragma once
#include <stdlib.h>
#include <string>
#include <iostream>
#include <stdio.h>
#include <fstream>

typedef unsigned char byte;
typedef unsigned long int UNIT;

using namespace std;
class MD5
{
	public:
	MD5();
	MD5(const string &str);
	MD5(const void* input, size_t length);
	MD5(ifstream &ifs);
	void update(const void* input,size_t length);
	void update(const string &str);
	void update(ifstream &ifs);
	string toString();	
	const byte* digest();
	void reset();
	~MD5(void);
private:
	void update(const byte*input ,size_t length);
	void final();
	void transform(const byte block[64]);
	void encode(const UNIT *input,byte *output, size_t length);
	void decode(const byte *input,UNIT *output, size_t length);
	string bytesToHexString(const byte *input,size_t length);
private:
	UNIT _state[4];
	UNIT _count[2];
	byte _buffer[64];
	byte _digest[16];
	bool _finished;

	static const byte PADDING[64];
	static const char HEX[16];
	static const size_t BUFFER_SIZE = 1024;
};


MD5.cpp 
#include "MD5.h"

  
/* F, G, H and I are basic MD5 functions. 
*/  
inline UNIT F(UNIT x, UNIT y,UNIT z) {return (UNIT)(((x) & (y)) | ((~x) & (z))); } 
inline UNIT G(UNIT x, UNIT y,UNIT z) {return (UNIT)(((x) & (z)) | ((y) & (~z))); } 
inline UNIT H(UNIT x, UNIT y, UNIT z) {return (UNIT )((x) ^ (y) ^ (z))  ;}
inline UNIT I(UNIT x, UNIT y, UNIT z) {return (UNIT)((y) ^ ((x) | (~z)))  ;}
  
/* ROTATE_LEFT rotates x left n bits. 
*/  
inline UNIT ROTATE_LEFT(UNIT x,UNIT n) {return UNIT(((x) << (n)) | ((x) >> (32-(n)))) ;} 
  
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. 
Rotation is separate from addition to prevent recomputation. 
*/  
void FF(UNIT &a, UNIT &b, UNIT &c, UNIT &d, UNIT x, UNIT s, UNIT ac){   
    a += F ((b), (c), (d)) + (x) + ac;   
    a = ROTATE_LEFT ((a), (s));  
    a += b;  
}  
void GG(UNIT &a,UNIT &b, UNIT &c,UNIT &d, UNIT x, UNIT s,UNIT ac) { 
    (a) += G ((b), (c), (d)) + (x) + ac; 
    (a) = ROTATE_LEFT ((a), (s)); 
    (a) += (b); 
}  
void HH(UNIT &a,UNIT &b, UNIT &c,UNIT &d, UNIT x, UNIT s,UNIT ac) {   
    (a) += H ((b), (c), (d)) + (x) + ac;   
    (a) = ROTATE_LEFT ((a), (s));   
    (a) += (b);   
}  
void II(UNIT &a,UNIT &b, UNIT &c,UNIT &d, UNIT x, UNIT s,UNIT ac) {   
    (a) += I ((b), (c), (d)) + (x) + ac;   
    (a) = ROTATE_LEFT ((a), (s));   
    (a) += (b);   
}
const int s[16]={
    7,12,17,22,
	5,9,14,20,
	4,11,16,23,
	6,10,15,21
};
const byte MD5::PADDING[64]={0x80};
const char MD5::HEX[16]={'0','1','2','3',
						'4','5','6','7','8',
						'9','a','b','c','d','e','f'};

MD5::MD5()
{
	reset();
}
MD5::MD5(const string &str){
	reset();
	update(str);
}
MD5::MD5(const void* input,size_t length){
    reset();
	update(input,length);
}
MD5::MD5(ifstream &ifs){
	reset();
	update(ifs);
}
void MD5::reset(){
	 _state[0] = 0x67452301;  
    _state[1] = 0xefcdab89;  
    _state[2] = 0x98badcfe;  
    _state[3] = 0x10325476;  

	_finished = false;
	_count[0]=_count[1]=0;
}

const byte* MD5::digest(){
	if(!_finished){
		_finished = true;
		final();
	}
	return _digest;
}
void MD5::final(){
	byte bits[8];
	UNIT oldState[4];
	UNIT oldCount[2];
	UNIT index,padLen;

	memcpy(oldState,_state,16);
	memcpy(oldCount,_count,8);

	encode(_count,bits,8);

	index = (UNIT)((_count[0]>>3)&(0x3f));
	padLen = (index < 56)?(56-index):(120-index);

	update(PADDING,padLen);
	update(bits,8);
	encode(_state,_digest,16);


}

void MD5::update(const void *input,size_t length){
	update((const byte*)input,length);
}
void MD5::update(const string &str){
	update((const byte*)str.c_str(),str.length());
}
void MD5::update(ifstream &ifs){
	if(!ifs){
		return;
	}
	streamsize length;
	char buffer[BUFFER_SIZE];
	while(!ifs.eof()){
		ifs.read(buffer,BUFFER_SIZE);
		length = ifs.gcount();
		if(length >0){
			update(buffer,length);
		}
	}
	ifs.close();
}
void MD5::update(const byte* input,size_t length){
	UNIT index,partLen,i;
	_finished = false;
	//Compute number of bytes mod 64
	index = (UNIT)((_count[0]>>3)&0x3f);

	if((_count[0] += ((UNIT)length<<3))<((UNIT)length<<3)){
		_count[1]++;
	}
	_count[1] += ((UNIT)length>>29);

	partLen = 64 - index;
	if(length >= partLen){
		memcpy(&_buffer[index],input,partLen);
		transform(_buffer);
		for(i = partLen;i+63 < length; i+= 64){
		    transform(&input[i]);
		}
		index = 0;
	}
	else i=0;
	memcpy(&_buffer[index],&input[i],length-i);
}

void MD5::transform(const byte block[64]){
	UNIT a = _state[0], b = _state[1],c = _state[2], d = _state[3],x[16];
	decode(block,x,64);
	int i=0;

	FF (a, b, c, d, x[ 0], s[i++], 0xd76aa478); /* 1 */  
    FF (d, a, b, c, x[ 1], s[i++], 0xe8c7b756); /* 2 */  
    FF (c, d, a, b, x[ 2], s[i++], 0x242070db); /* 3 */  
    FF (b, c, d, a, x[ 3], s[i++], 0xc1bdceee); /* 4 */  
	i-=4;
    FF (a, b, c, d, x[ 4], s[i++], 0xf57c0faf); /* 5 */  
    FF (d, a, b, c, x[ 5], s[i++], 0x4787c62a); /* 6 */  
    FF (c, d, a, b, x[ 6], s[i++], 0xa8304613); /* 7 */  
    FF (b, c, d, a, x[ 7], s[i++], 0xfd469501); /* 8 */  
	i-=4;
    FF (a, b, c, d, x[ 8], s[i++], 0x698098d8); /* 9 */  
    FF (d, a, b, c, x[ 9], s[i++], 0x8b44f7af); /* 10 */  
    FF (c, d, a, b, x[10], s[i++], 0xffff5bb1); /* 11 */  
    FF (b, c, d, a, x[11], s[i++], 0x895cd7be); /* 12 */  
	i-=4;
    FF (a, b, c, d, x[12], s[i++], 0x6b901122); /* 13 */  
    FF (d, a, b, c, x[13], s[i++], 0xfd987193); /* 14 */  
    FF (c, d, a, b, x[14], s[i++], 0xa679438e); /* 15 */  
    FF (b, c, d, a, x[15], s[i++], 0x49b40821); /* 16 */  

  
    /* Round 2 */  
    GG (a, b, c, d, x[ 1], s[i++], 0xf61e2562); /* 17 */  
    GG (d, a, b, c, x[ 6], s[i++], 0xc040b340); /* 18 */  
    GG (c, d, a, b, x[11], s[i++], 0x265e5a51); /* 19 */  
    GG (b, c, d, a, x[ 0], s[i++], 0xe9b6c7aa); /* 20 */  
	i-=4;
    GG (a, b, c, d, x[ 5], s[i++], 0xd62f105d); /* 21 */  
    GG (d, a, b, c, x[10], s[i++],  0x2441453); /* 22 */  
    GG (c, d, a, b, x[15], s[i++], 0xd8a1e681); /* 23 */  
    GG (b, c, d, a, x[ 4], s[i++], 0xe7d3fbc8); /* 24 */  
	i-=4;
    GG (a, b, c, d, x[ 9], s[i++], 0x21e1cde6); /* 25 */  
    GG (d, a, b, c, x[14], s[i++], 0xc33707d6); /* 26 */  
    GG (c, d, a, b, x[ 3], s[i++], 0xf4d50d87); /* 27 */  
    GG (b, c, d, a, x[ 8], s[i++], 0x455a14ed); /* 28 */  
	i-=4;
    GG (a, b, c, d, x[13], s[i++], 0xa9e3e905); /* 29 */  
    GG (d, a, b, c, x[ 2], s[i++], 0xfcefa3f8); /* 30 */  
    GG (c, d, a, b, x[ 7], s[i++], 0x676f02d9); /* 31 */  
    GG (b, c, d, a, x[12], s[i++], 0x8d2a4c8a); /* 32 */  
  
    /* Round 3 */  
    HH (a, b, c, d, x[ 5], s[i++], 0xfffa3942); /* 33 */  
    HH (d, a, b, c, x[ 8], s[i++], 0x8771f681); /* 34 */  
    HH (c, d, a, b, x[11], s[i++], 0x6d9d6122); /* 35 */  
    HH (b, c, d, a, x[14], s[i++], 0xfde5380c); /* 36 */  
	i-=4;
    HH (a, b, c, d, x[ 1], s[i++], 0xa4beea44); /* 37 */  
    HH (d, a, b, c, x[ 4], s[i++], 0x4bdecfa9); /* 38 */  
    HH (c, d, a, b, x[ 7], s[i++], 0xf6bb4b60); /* 39 */  
    HH (b, c, d, a, x[10], s[i++], 0xbebfbc70); /* 40 */  
	i-=4;
    HH (a, b, c, d, x[13], s[i++], 0x289b7ec6); /* 41 */  
    HH (d, a, b, c, x[ 0], s[i++], 0xeaa127fa); /* 42 */  
    HH (c, d, a, b, x[ 3], s[i++], 0xd4ef3085); /* 43 */  
    HH (b, c, d, a, x[ 6], s[i++],  0x4881d05); /* 44 */  
	i-=4;
    HH (a, b, c, d, x[ 9], s[i++], 0xd9d4d039); /* 45 */  
    HH (d, a, b, c, x[12], s[i++], 0xe6db99e5); /* 46 */  
    HH (c, d, a, b, x[15], s[i++], 0x1fa27cf8); /* 47 */  
    HH (b, c, d, a, x[ 2], s[i++], 0xc4ac5665); /* 48 */  
  
    /* Round 4 */  
    II (a, b, c, d, x[ 0], s[i++], 0xf4292244); /* 49 */  
    II (d, a, b, c, x[ 7], s[i++], 0x432aff97); /* 50 */  
    II (c, d, a, b, x[14], s[i++], 0xab9423a7); /* 51 */  
    II (b, c, d, a, x[ 5], s[i++], 0xfc93a039); /* 52 */  
	i-=4;
    II (a, b, c, d, x[12], s[i++], 0x655b59c3); /* 53 */  
    II (d, a, b, c, x[ 3], s[i++], 0x8f0ccc92); /* 54 */  
    II (c, d, a, b, x[10], s[i++], 0xffeff47d); /* 55 */  
    II (b, c, d, a, x[ 1], s[i++], 0x85845dd1); /* 56 */ 
	i-=4;
    II (a, b, c, d, x[ 8], s[i++], 0x6fa87e4f); /* 57 */  
    II (d, a, b, c, x[15], s[i++], 0xfe2ce6e0); /* 58 */  
    II (c, d, a, b, x[ 6], s[i++], 0xa3014314); /* 59 */  
    II (b, c, d, a, x[13], s[i++], 0x4e0811a1); /* 60 */  
	i-=4;
    II (a, b, c, d, x[ 4], s[i++], 0xf7537e82); /* 61 */  
    II (d, a, b, c, x[11], s[i++], 0xbd3af235); /* 62 */  
    II (c, d, a, b, x[ 2], s[i++], 0x2ad7d2bb); /* 63 */  
    II (b, c, d, a, x[ 9], s[i++], 0xeb86d391); /* 64 */  

    _state[0] += a;  
    _state[1] += b;  
    _state[2] += c;  
    _state[3] += d;  
}  
void MD5::encode(const UNIT *input,byte* output,size_t length){
	for(size_t i=0,j=0; j<length;i++,j+=4){
		output[j] = (byte)(input[i]&0xff);
		output[j+1] = (byte)((input[i]>>8)&0xff);
		output[j+2] = (byte)((input[i]>>16)&0xff);
		output[j+3] = (byte)((input[i]>>24)&0xff);
	}

}
void MD5::decode(const byte *input,UNIT *output,size_t length){
    for(size_t i=0,j=0;j<length;i++,j+=4){
		output[i] = ((UNIT)(input[j])|((UNIT)(input[j+1])<<8)
			|((UNIT)(input[j+2])<<16)|((UNIT)(input[j+3])<<24));
	}
}

string MD5::bytesToHexString(const byte *input,size_t length){
	string str;
	str.reserve(length<<1);
	for(size_t i=0;i<length;i++){
		int t = input[i];
		int a = t/16;
		int b = t%16;
		str.append(1,HEX[a]);
		str.append(1,HEX[b]);
	}
	return str;
}

string MD5::toString(){
	return bytesToHexString(digest(),16);
}
MD5::~MD5(void)
{
}

test.cpp 
#include "md5.h"  
#include <iostream>  
  
using namespace std;  
  
void PrintMD5(const string &str, MD5 &md5) {  
    cout << "MD5(\"" << str << "\") = " << md5.toString() << endl;  
}  
  
string FileDigest(const string &file) {  
  
    ifstream in(file.c_str(), ios::binary);  
    if (!in)  
        return "";  
  
    MD5 md5;  
    std::streamsize length;  
    char buffer[1024];  
    while (!in.eof()) {  
        in.read(buffer, 1024);  
        length = in.gcount();  
        if (length > 0)  
            md5.update(buffer, length);  
    }  
    in.close();  
    return md5.toString();  
}  
  
int main() {  
  
    cout<<"Please input a string:"<<endl; 
	string str;
	while(getline(cin,str)){
	 cout<<"Source Code:"<<str<<endl<<"MD5:"<<MD5(str).toString()<<endl;
	 cout<<"Please input a string:"<<endl; 
	}
	system("pause");
    /*cout << MD5(ifstream("D:\\test.txt")).toString() << endl;  
    cout << MD5(ifstream("D:\\test.exe", ios::binary)).toString() << endl;  
    cout << FileDigest("D:\\test.exe") << endl;
	*/
  
  /*  MD5 md5;  
    md5.update("");  
    PrintMD5("", md5);  
  
    md5.update("a");  
    PrintMD5("a", md5);  
  
    md5.update("bc");  
    PrintMD5("abc", md5);  
  
    md5.update("defghijklmnopqrstuvwxyz");  
    PrintMD5("abcdefghijklmnopqrstuvwxyz", md5);  
  
    md5.reset();  
    md5.update("message digest");  
    PrintMD5("message digest", md5);  
  
    md5.reset();  
    md5.update(ifstream("D:\\test.txt"));  
    PrintMD5("D:\\test.txt", md5);  
    return 0;
	*/
}
截图：
MD5 C++源码 亲测可运行 - Eric - hacktimelin的博客
 
geekking
关注
专栏目录
md5加密算法的c++代码实现
04-19
md5加密算法的c++代码实现<br>
MD5算法加密C++版
m0_46632317的博客
09-25 6976
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法）
C++|MD5简介
最新发布
奇树谦的博客
09-10 1592
将结构体的成员变量转换为字节流。使用MD5算法对字节流进行哈希计算。将计算出的哈希值转换为可读的格式（如十六进制字符串）。以下是一个简单的示例，演示如何对一个自定义结构体进行MD5哈希：首先，你需要一个MD5库。在C++中，你可以使用开源库如openssl来实现MD5。以下是使用openssl// 假设这是你的自定义结构体int a;float b;// 将结构体转换为字节流的函数// 以网络字节顺序（大端）写入数据const。
MD5步骤详解及c++实现
kidding10086的博客
01-23 3134
MD5步骤详解及c++实现 文章目录MD5步骤详解及c++实现1.步骤详解操作第一步：将字符串转换为ASCII码的二进制串第二步：消息填充第三步：计算消息摘要大坑：大小端的转换问题（如果不想自己实现MD5，可以跳过）2.c++实现 1.步骤详解 操作 一个字就是32位的二进制字符串，介于000与232−12^32-1232−1之间的整数可以表示为一个字。 X和Y分别为一个字 X AND Y = X和Y按位与 X OR Y = X和Y按位或 X XOR Y = X和Y按位异或 NOT X
MD5介绍与MD5加密的C++实现
热门推荐
mijichui2153的博客
07-15 1万+
MD5相信绝大数人都接触过，也有无数人问过我怎么做MD5解密。 当然，我们知道MD5自然没有办法解密，所以解密也不过是大量已知数据做成字典而已，MD5是不可能通过逆向计算解密的。 为什么呢？因为哈希冲突。 举个简单的例子： 比如说我给定10个位置来存放东西，假设我的对应方法是简单的求余%。 那么11%10，21%10的结果就会相同。这样就造成了冲突。 MD5也是如此，我们常用的MD5位...
MD5算法的实现原理与C/C++实现
qq_54223524的博客
01-27 2423
MD5（Message Digest Algorithm 5）是一种广泛使用的加密哈希函数，由罗纳德·李维斯特（Ronald Rivest）于1991年设计。MD5的目的是从任意长度的数据中产生一个128位（16字节）的哈希值，通常表示为32个十六进制字符。MD5的设计使其用于确保数据的完整性，常见于文件校验、数字签名等场景。：首先对消息进行填充，以使其长度（以位计）模512为448。填充始终以1开始，后跟0，直到满足长度要求。：在填充的消息后追加一个64位的长度字段，表示原始消息的长度（以位计）。
MD5 编码 源代码 C++源码 VS工程可运行
03-21
在C++源码中，这些需要以结构体的形式定义。 3. **初始化函数**：MD5算法的初始化阶段会设置这四个中间变量的初始值。 4. **更新函数**：这是MD5的核心部分，用于处理输入数据。每次接收512位的数据块，经过一系列...
md5源码，报告，exe C++
01-13
"exe"文件可能是C++实现的MD5程序的可执行文件，用户可以直接运行，无需编译源码。这个程序可能接受用户输入，然后计算并显示输入的MD5摘要。 在压缩包中仅有一个名为"md5"的文件，这可能是一个包含源码、编译好的...
VC/C++源码,加密解密,MD5,加密算法
05-10
摘要:VC/C++源码,加密解密,MD5,加密算法 VC++源代码写的用于md5加密算法的一个DLL组件源码，虽然是半成品，不过学习一下VC++中编写DLL也是不错的选择，另外还可以研究MD5加密算法具体实施代码。 运行环境：Windows/...
md5程序源码32位加密可直接放入工程内使用
04-17
总的来说，这个提供的MD5源码是一个实用的工具，可以方便地为你的C/C++项目添加MD5哈希计算功能，无论你的项目运行在Linux还是Windows平台上。不过，由于MD5的安全性已经在近年来受到质疑，如果你的应用涉及到高度...
易语言源码易语言md5加密DLL源码.rar
02-17
源码中应有相应的函数实现这些步骤，如`MD5_Init`、`MD5_Update`、`MD5_Final`，并且会涉及位运算、异或操作等。 3. **动态链接库的创建**：在易语言中创建DLL，需要定义导出函数，这些函数将在其他程序中被调用。...
C++ 实现MD5
fareast_mzh的博客
08-11 3955
md5 1. 附加填充位 　首先对输入的报文进行填位补充,使填充后的数据长度模512后余448. 如果数据长度正好模512余448,则需增加512个填充位,也就是说填充的个数为1~512位. 填充位第一个位为1,其余全部为0. 2. 补足长度 将数据长度表示为二进制,如果长度超过64位,则截取其低64位; 如果长度不足64位,则在其高位补0. 将这个64位的报...
MD5验证文件完整性 C++
weixin_44740847的博客
04-22 4037
读取文件内容并且做MD5验证 C++ 为了验证下载的文件是否完整，是否被篡改，常用的验证方法为MD5验证，文件生成32位验证码，可验证文件是否完整下载或被篡改。 md5.h文件 #ifndef MD5_H #define MD5_H #include <string> #include <fstream> /* Type define */ typedef un...
C++ 递归遍历文件并计算MD5
CSDN
07-16 7371
MD5（Message Digest Algorithm 5）是一种常用的哈希函数，用于将任意长度的消息转换为固定长度（128位）的哈希值。MD5算法常用于验证数据的完整性和一致性，例如文件校验、密码存储等场景。在计算MD5哈希值时，可以使用现有的加密库或者编程语言提供的相关函数。调用例子(遍历%temp% 下的文件)
用C++计算文件的MD5值
积累点滴，保持自我
11-23 1万+
用C++计算文件的MD5值，相关的代码如下： md5.h #ifndef MD5_H #define MD5_H #include &lt;string&gt; #include &lt;fstream&gt; /* Type define */ typedef unsigned char byte; typedef unsigned int uint32; using std::st...
C++ MD5
nightwizard2030的博客
11-11 3828
MD5是一种摘要算法，通过压缩+加密+hash的算法是绝对不可逆的。网上有很多人都写了，我也参考了MD5的基本规则写的。这个算法从数学角度上来说，主要是需要证明唯一性，但凭我等的能力想要做这种证明是不太现实的。因为我实在没办法去证明通过一系列的运算，累加a,b,c,d还能够有唯一性，因为就逆向去看加法，那是有无数解的，MD5也只能说在概率上是不会重复的吧。所以说那个幻数，还有里面的那些数据，是不能
MD5的C++源码
管子（zero）的杂乱空间
12-06 297
关于MD5的C源码，请参考我空间的另外一篇文章:MD5的C源码 md5.h: #ifndef MD5_H #define MD5_H #include &lt;string&gt; #include &lt;fstream&gt; /* Type define */ typedef unsigned char byte; typedef unsigned int uint32; ...
MD5算法的C++实现
benny5609的专栏
09-13 1811
MD5算法的C++实现 1. IntroductionMD5算法是一种消息摘要算法(Message Digest Algorithm)，此算法以任意长度的信息(message)作为输入进行计算，产生一个128-bit(16-byte)的指纹或报文摘要(fingerprint or message digest)。两个不同的message产生相同message digest的几率相当小，从一个给
VS2008环境下运行的MD5加密源码实现
"这是一个在Visual Studio 2008环境下编译通过的C++ MD5加密程序，...这个C++ MD5加密程序的实现遵循了原始MD5算法的流程，可以在VS2008环境下直接运行，对于需要对数据进行安全哈希的C++项目来说，是一个实用的工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值