C++封装MD5加密方法，记录保存

最新推荐文章于 2023-07-20 13:02:27 发布
最新推荐文章于 2023-07-20 13:02:27 发布
阅读量156 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43284805/article/details/122237713
版权

c++ 开发语言 后端

md5_encode.h

/*
*******************************************************
* brief: md5 encryption
* author: Monkey.Knight
*******************************************************
*/

#ifndef __MD5_ENCODE_H__
#define __MD5_ENCODE_H__

// std
#include <string>

// define
#define UInt32 unsigned int
#define BIT_OF_BYTE  8
#define BIT_OF_GROUP 512
#define SRC_DATA_LEN 64

// 四个非线性函数宏定义
#define DEF_F(X, Y, Z ) ((( (X) & (Y) )|((~X)&(Z))))
#define DEF_G(X, Y, Z)  (((X)&(Z))|((Y)&(~Z)))
#define DEF_H(X, Y, Z)  ((X)^(Y)^(Z))
#define DEF_I(X, Y, Z)  ((Y)^((X)|(~Z)))

// 求链接数函数宏定义
#define FF(a, b, c, d, Mj, s, ti)  (a = b + CycleMoveLeft((a + DEF_F(b,c,d) + Mj + ti),s));
#define GG(a, b, c, d, Mj, s, ti)  (a = b + CycleMoveLeft((a + DEF_G(b,c,d) + Mj + ti),s));
#define HH(a, b, c, d, Mj, s, ti)  (a = b + CycleMoveLeft((a + DEF_H(b,c,d) + Mj + ti),s));
#define II(a, b, c, d, Mj, s, ti)  (a = b + CycleMoveLeft((a + DEF_I(b,c,d) + Mj + ti),s));


class Md5Encode {
public:
	// 4轮循环算法
	struct ParamDynamic {
		UInt32 ua_;
		UInt32 ub_;
		UInt32 uc_;
		UInt32 ud_;
		UInt32 va_last_;
		UInt32 vb_last_;
		UInt32 vc_last_;
		UInt32 vd_last_;
	};
public:
	Md5Encode() {
	}
	std::string Encode(std::string src_info);

protected:

	UInt32 CycleMoveLeft(UInt32 src_num, int bit_num_to_move);
	UInt32 FillData(const char* in_data_ptr, int data_byte_len, char** out_data_ptr);
	void RoundF(char* data_512_ptr, ParamDynamic& param);
	void RoundG(char* data_512_ptr, ParamDynamic& param);
	void RoundH(char* data_512_ptr, ParamDynamic& param);
	void RoundI(char* data_512_ptr, ParamDynamic& param);
	void RotationCalculate(char* data_512_ptr, ParamDynamic& param);
	std::string GetHexStr(unsigned int num_str);

private:
	// 幻数定义
	static const int kA;
	static const int kB;
	static const int kC;
	static const int kD;
	static const unsigned long long k_ti_num_integer;
};

#endif

md5_encode.cpp

#include "md5_encode.h"
#include <iostream>
// 幻数定义
const int Md5Encode::kA = 0x67452301;
const int Md5Encode::kB = 0xefcdab89;
const int Md5Encode::kC = 0x98badcfe;
const int Md5Encode::kD = 0x10325476;

const unsigned long long Md5Encode::k_ti_num_integer = 4294967296;

// function: CycleMoveLeft
// @param src_num:要左移的数
// @param bit_num_to_move:要移动的bit位数
// @return  循环左移后的结果数
UInt32 Md5Encode::CycleMoveLeft(UInt32 src_num, int bit_num_to_move) {
	UInt32 src_num1 = src_num;
	UInt32 src_num2 = src_num;
	if (0 >= bit_num_to_move) {
		return src_num;
	}
	UInt32 num1 = src_num1 << bit_num_to_move;
	UInt32 num2 = src_num2 >> (32 - bit_num_to_move);

	return ((src_num1 << bit_num_to_move) \
		| (src_num2 >> (32 - bit_num_to_move)));
}

// function: FillData
// @param in_data_ptr:    要加密的信息数据
// @param data_byte_len: 数据的字节数
// @param out_data_ptr:  填充必要信息后的数据
// return : 填充信息后的数据长度,以字节为单位
UInt32 Md5Encode::FillData(const char* in_data_ptr, int data_byte_len, char** out_data_ptr) {
	int bit_num = data_byte_len * BIT_OF_BYTE;
	int grop_num = bit_num / BIT_OF_GROUP;
	int mod_bit_num = bit_num % BIT_OF_GROUP;
	int bit_need_fill = 0;
	if (mod_bit_num > (BIT_OF_GROUP - SRC_DATA_LEN)) {
		bit_need_fill = (BIT_OF_GROUP - mod_bit_num);
		bit_need_fill += (BIT_OF_GROUP - SRC_DATA_LEN);
	}
	else {
		bit_need_fill = (BIT_OF_GROUP - SRC_DATA_LEN) - mod_bit_num; //  这里多加了一个BIT_OF_GROUP，避免bit_need_fill正好等于0,暂时不加
	}
	int all_bit = bit_num + bit_need_fill;
	if (0 < bit_need_fill) {
		*out_data_ptr = new char[all_bit / BIT_OF_BYTE + SRC_DATA_LEN / BIT_OF_BYTE];
		memset(*out_data_ptr, 0, all_bit / BIT_OF_BYTE + SRC_DATA_LEN / BIT_OF_BYTE);
		// copy data
		memcpy(*out_data_ptr, in_data_ptr, data_byte_len);
		// fill rest data
		unsigned char* tmp = reinterpret_cast<unsigned char*>(*out_data_ptr);
		tmp += data_byte_len;
		// fill 1 and 0
		*tmp = 0x80;
		// fill origin data len
		unsigned long long* origin_num = (unsigned long long*)((*out_data_ptr) + ((all_bit / BIT_OF_BYTE)));
		*origin_num = data_byte_len * BIT_OF_BYTE;
	}
	return (all_bit / BIT_OF_BYTE + SRC_DATA_LEN / BIT_OF_BYTE);
}

void Md5Encode::RoundF(char* data_BIT_OF_GROUP_ptr, ParamDynamic& param) {
	UInt32* M = reinterpret_cast<UInt32*>(data_BIT_OF_GROUP_ptr);
	int s[] = { 7, 12, 17, 22 };
	for (int i = 0; i < 16; ++i) {
		UInt32 ti = k_ti_num_integer * abs(sin(i + 1));
		if (i % 4 == 0) {
			FF(param.ua_, param.ub_, param.uc_, param.ud_, M[i], s[i % 4], ti);
		}
		else if (i % 4 == 1) {
			FF(param.ud_, param.ua_, param.ub_, param.uc_, M[i], s[i % 4], ti);
		}
		else if (i % 4 == 2) {
			FF(param.uc_, param.ud_, param.ua_, param.ub_, M[i], s[i % 4], ti);
		}
		else if (i % 4 == 3) {
			FF(param.ub_, param.uc_, param.ud_, param.ua_, M[i], s[i % 4], ti);
		}
	}
}

void Md5Encode::RoundG(char* data_BIT_OF_GROUP_ptr, ParamDynamic& param) {
	UInt32* M = reinterpret_cast<UInt32*>(data_BIT_OF_GROUP_ptr);
	int s[] = { 5, 9, 14, 20 };
	for (int i = 0; i < 16; ++i) {
		UInt32 ti = k_ti_num_integer * abs(sin(i + 1 + 16));
		int index = (i * 5 + 1) % 16;
		if (i % 4 == 0) {
			GG(param.ua_, param.ub_, param.uc_, param.ud_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 1) {
			GG(param.ud_, param.ua_, param.ub_, param.uc_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 2) {
			GG(param.uc_, param.ud_, param.ua_, param.ub_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 3) {
			GG(param.ub_, param.uc_, param.ud_, param.ua_, M[index], s[i % 4], ti);
		}
	}
}

void Md5Encode::RoundH(char* data_BIT_OF_GROUP_ptr, ParamDynamic& param) {
	UInt32* M = reinterpret_cast<UInt32*>(data_BIT_OF_GROUP_ptr);
	int s[] = { 4, 11, 16, 23 };
	for (int i = 0; i < 16; ++i) {
		UInt32 ti = k_ti_num_integer * abs(sin(i + 1 + 32));
		int index = (i * 3 + 5) % 16;
		if (i % 4 == 0) {
			HH(param.ua_, param.ub_, param.uc_, param.ud_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 1) {
			HH(param.ud_, param.ua_, param.ub_, param.uc_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 2) {
			HH(param.uc_, param.ud_, param.ua_, param.ub_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 3) {
			HH(param.ub_, param.uc_, param.ud_, param.ua_, M[index], s[i % 4], ti);
		}
	}
}

void Md5Encode::RoundI(char* data_BIT_OF_GROUP_ptr, ParamDynamic& param) {
	UInt32* M = reinterpret_cast<UInt32*>(data_BIT_OF_GROUP_ptr);
	int s[] = { 6, 10, 15, 21 };
	for (int i = 0; i < 16; ++i) {
		UInt32 ti = k_ti_num_integer * abs(sin(i + 1 + 48));
		int index = (i * 7 + 0) % 16;
		if (i % 4 == 0) {
			II(param.ua_, param.ub_, param.uc_, param.ud_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 1) {
			II(param.ud_, param.ua_, param.ub_, param.uc_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 2) {
			II(param.uc_, param.ud_, param.ua_, param.ub_, M[index], s[i % 4], ti);
		}
		else if (i % 4 == 3) {
			II(param.ub_, param.uc_, param.ud_, param.ua_, M[index], s[i % 4], ti);
		}
	}
}

void Md5Encode::RotationCalculate(char* data_512_ptr, ParamDynamic& param) {
	if (NULL == data_512_ptr) {
		return;
	}
	RoundF(data_512_ptr, param);
	RoundG(data_512_ptr, param);
	RoundH(data_512_ptr, param);
	RoundI(data_512_ptr, param);
	param.ua_ = param.va_last_ + param.ua_;
	param.ub_ = param.vb_last_ + param.ub_;
	param.uc_ = param.vc_last_ + param.uc_;
	param.ud_ = param.vd_last_ + param.ud_;

	param.va_last_ = param.ua_;
	param.vb_last_ = param.ub_;
	param.vc_last_ = param.uc_;
	param.vd_last_ = param.ud_;
}

// 转换成十六进制字符串输出
std::string Md5Encode::GetHexStr(unsigned int num_str) {
	std::string hexstr = "";
	char szch[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
	unsigned char* tmptr = (unsigned char*)&num_str;
	int len = sizeof(num_str);
	// 小端字节序，逆序打印
	for (int i = 0; i < len; i++) {
		unsigned char ch = tmptr[i] & 0xF0;
		ch = ch >> 4;
		hexstr.append(1, szch[ch]);
		ch = tmptr[i] & 0x0F;
		hexstr.append(1, szch[ch]);
	}
	return hexstr;
}

// function: Encode
// @param src_info:要加密的信息
// return :加密后的MD5值
std::string Md5Encode::Encode(std::string src_info) {
	ParamDynamic param;
	param.ua_ = kA;
	param.ub_ = kB;
	param.uc_ = kC;
	param.ud_ = kD;
	param.va_last_ = kA;
	param.vb_last_ = kB;
	param.vc_last_ = kC;
	param.vd_last_ = kD;

	std::string result;
	const char* src_data = src_info.c_str();
	char* out_data_ptr = NULL;
	int total_byte = FillData(src_data, strlen(src_data), &out_data_ptr);
	//char * data_BIT_OF_GROUP = out_data_ptr;
	for (int i = 0; i < total_byte / (BIT_OF_GROUP / BIT_OF_BYTE); ++i) {
		char* data_BIT_OF_GROUP = out_data_ptr;
		data_BIT_OF_GROUP += i * (BIT_OF_GROUP / BIT_OF_BYTE);
		RotationCalculate(data_BIT_OF_GROUP, param);
	}
	if (NULL != out_data_ptr) {
		delete[] out_data_ptr, out_data_ptr = NULL;
	}
	result.append(GetHexStr(param.ua_));
	result.append(GetHexStr(param.ub_));
	result.append(GetHexStr(param.uc_));
	result.append(GetHexStr(param.ud_));
	return result;
}

调用

string strText = "ceshiwenben";
Md5Encode encode_obj;
string retMd5 = encode_obj.Encode(strText);
cout<<"MD5："<<retMd5.c_str()<<endl;

Czx.¹²³
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
md5加密的使用方法
09-28
其中包括md5的加密的函数以及md5加密的使用
MD5 加密算法 C++实现源码
10-19
在C++中实现MD5加密算法，通常包括以下几个步骤： 1. **初始化MD5状态**: 创建一个128位的缓冲区，用于存储中间结果，初始化为一组固定的常量。 2. **处理输入数据**: 将输入的明文数据按照512位的块进行处理。...
MD5加密的C++实现代码
cdyuyikj的博客
10-21 314
MD5常常被用来加密密码等信息，本博客以C++实现MD5加密类。 Md5Encode md5; cout << name << " " << md5.Encode(psw) << endl; MD5被实现在Md5.h和Md5.cpp文件中。其中Md5.h如下所示 #ifndef __MD5_ENCODE_H__ #define __MD5_ENCO...
C++ MD5加密实现
beattwo的专栏
03-21 402
[code="c++"] //MD5.h #ifndef BZF_MD5_H #define BZF_MD5_H #include #include // a small class for calculating MD5 hashes of strings or byte arrays // it is not meant to be fast or secure...
md5加密用法，可以参考一下
CSDNwlp1的博客
06-26 227
Md5加密的两种用法
qq_55473245的博客
08-30 3917
md5加密
MD5加密的C++类例程.zip_md5_md5 c++_md5 加密_字符串 加密
09-23
在压缩包中的"MD5加密的C++类例程"文件可能提供了这样一个类，封装了上述步骤，使得在C++程序中使用MD5加密更加方便。类可能包含如`encryptMD5(const std::string& input)`这样的方法，接受一个字符串作为输入，返回...
visual c++ vc MD5加密算法源代码+DLL成品.zip
01-29
通过这个压缩包，你可以学习到如何在VC++环境中使用C++实现MD5加密算法，并将其封装为DLL。DLL是一种共享库，可以被多个应用程序调用，以复用代码，减少内存占用。具体步骤包括： 1. **理解MD5算法**：学习MD5的...
C++ MD5加密封装类
01-12
MD5 是message-digest algorithm 5 （信息-摘要算法）缩写，广泛用于加密和解密技术，常用于文件校验。校验？MD5是用于对信息生成信息摘要（即散列码）的算法之一。不管文件多大，经过MD5后都能生成唯一的MD5值。...
【Java】使用MD5进行加密解密（代码实现）
热门推荐
m0_64210833的博客
09-06 3万+
我们的，对于用户来说，不应该知道我们的在正式环境，我们的数据需要通过网络传输，必须要保证明文：加密之前的内容，原始内容暗文：加密之后的内容公钥：可见的公共的钥匙私钥：不可见的私有的钥匙作用：一般对登录密码处理，用于做密码比对问题：只能加密，不能解密，特征：1. 可以加密，也可以解密2. 加密和解密的密钥是同一个作用：对数据库密码进行加密,秘钥为k，加密：s = AES（k,c）解密：c = AES(k,s)问题：1. 数据可能会被其他人2. 数据可能会。
使用MD5对数据进行加密
05-31
MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹)，以防止被“篡改”。举个例子，你将一段话写在一个叫 readme.txt文件中，并对这个readme.txt产生一个MD5的值并记录在案，然后你可以传播这个文件给别人，别人如果修改了文件中的任何内容，你对这个文件重新计算MD5时就会发现（两个MD5值不相同）。如果再有一个第三方的认证机构，用MD5还可以防止文件作者的“抵赖”，这就是所谓的数字签名应用。 　　所以，要遇到了md5密码的问题，比较好的办法是：你可以用这个系统中的md5()函数重新设一个密码，如admin，把生成的一串密码覆盖原来的就行了。(功能很强大)
MD5数据加密方法
最新发布
weixin_52115456的博客
07-20 2万+
什么场景需要使用数据加密呢？比如秘密数据传输、用户密码加密存储等等数据传输可使用密钥对的方式进行加密解密，使用签名方式验证数据是否可靠，而密码加密存储可使用MD5等一些算法对数据进行单向加密。
MD5加密使用
Fighting的专栏
04-23 828
写法1. #pragma mark - 16位加密小写 -(NSString *)md5:(NSString *)str {     const char *cStr = [str UTF8String];     unsigned char result[16];     CC_MD5(cStr, strlen(cStr), result);     NSMutabl
MD5加密的使用
庚中
06-20 676
比如一个登录密码的加密过程: 1.先安装js-md5 cnpm install js-md5 2.引入md5 import md5 from 'js-md5'; 3.调用md5方法 4.给后台传递
MD5加密的使用步骤
jinku7662_的博客
09-10 1831
代码如下 public static String getMD5Digest(String sourceData) { try { //此句话是采用MD5算法加密 MessageDigest alga = MessageDigest.getInstance(“MD5”); //此句话是采用SHA-1算法 //MessageDigest alga=MessageDigest.getInst...
md5加密使用
sheng_xinjun的博客
11-10 558
之前一直以为md5加密有多高深。今天看之前老师给的资料的时候，偶然看到了md5加密。 没想到就是一个十几行的插件类。要使用的时候调用这个类的方法就行了。太简单了，不多说，看下面代码。 public class MD5Utils { /** * 使用md5的算法进行加密 * * @param plainText * 加密原文 * @retur
md5加密的使用
fengyifanjin的博客
06-21 201
使用MD5加密
使用md5进行数据加密
qq_43731314的博客
07-11 454
public void test() throws NoSuchAlgorithmException, UnsupportedEncodingException { String str = "hello"; String str1 = "hello"; MessageDigest md5 = MessageDigest.getInstance("MD5"); Base64.Encoder base64Encoder = Base64.get
MD5算法详解：信息安全加密的关键工具
本毕业设计基于Microsoft Visual C++ 6.0平台，研究并实现了MD5算法的应用，特别是数据的加密存储功能。设计分为五个部分： 1. **MD5理论基础**：这部分介绍了MD5算法的背景、原理和用途，着重阐述了MD5算法的工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值