密码学七：MD5算法

最新推荐文章于 2024-04-11 21:06:30 发布
最新推荐文章于 2024-04-11 21:06:30 发布
阅读量340 收藏 2
点赞数 1
分类专栏： 密码学 文章标签： 算法 密码学 md5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50749380/article/details/121317109
版权

结果截图：
在这里插入图片描述
代码实现：

#include<iostream>
#include<fstream>
#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
#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 RotateLeft(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define FF(a, b, c, d, x, s, ac) { \
	(a) += F ((b), (c), (d)) + (x) + ac; \
	(a) = RotateLeft ((a), (s)); \
	(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
	(a) += G ((b), (c), (d)) + (x) + ac; \
	(a) = RotateLeft ((a), (s)); \
	(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
	(a) += H ((b), (c), (d)) + (x) + ac; \
	(a) = RotateLeft ((a), (s)); \
	(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
	(a) += I ((b), (c), (d)) + (x) + ac; \
	(a) = RotateLeft ((a), (s)); \
	(a) += (b); \
}
using namespace std;

typedef unsigned char uchar;
typedef unsigned long ulong;

class md5 {
public:
	md5();
	md5(const void* input, size_t length);
	md5(const string& str);//处理字符串
	md5(ifstream& in);//处理txt文件
	void update(const void* input, size_t length);
	void update(const string& str);//处理字符串
	void update(ifstream& in);//处理txt文件
	const uchar* digest();
	string toString();
	void reset();
private:
	void update(const uchar* input, size_t length);
	void final();
	void transform(const uchar block[64]);
	void encode(const ulong* input, uchar* output, size_t length);
	void decode(const uchar* input, ulong* output, size_t length);
	string bytesToHexString(const uchar* input, size_t length);
	md5(const md5&);
	md5& operator=(const md5&);
	ulong state[4];	/* state (ABCD) */
	ulong count[2];	/* number of bits, modulo 2^64 (low-order word first) */
	uchar buffer[64];	/* input buffer */
	uchar _digest[16];	/* message digest */
	bool over;		/* calculate finished ? */
	static const uchar padding[64];	/* padding for calculate */
	static const char hex[16];
	static const size_t BUFFER_SIZE = 1024;
};
const uchar 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 void* input, size_t length) {
	reset();
	update(input, length);
}
md5::md5(const string& str) {
	reset();
	update(str);
}
md5::md5(ifstream& in) {
	reset();
	update(in);
}
const uchar* md5::digest() {
	if (!over) {
		over = true;
		final();
	}
	return _digest;
}
void md5::reset() {
	over = false;
	/* reset number of bits. */
	count[0] = count[1] = 0;
	/* Load magic initialization constants. */
	state[0] = 0x67452301;
	state[1] = 0xefcdab89;
	state[2] = 0x98badcfe;
	state[3] = 0x10325476;
}
void md5::update(const void* input, size_t length) {
	update((const uchar*)input, length);
}
void md5::update(const string& str) {
	update((const uchar*)str.c_str(), str.length());
}
void md5::update(ifstream& in) {
	if (!in)
		return;
	std::streamsize length;
	char buffer[BUFFER_SIZE];
	while (!in.eof()) {
		in.read(buffer, BUFFER_SIZE);
		length = in.gcount();
		if (length > 0)
			update(buffer, length);
	}
	in.close();
}
void md5::update(const uchar* input, size_t length) {
	ulong i, index, partLen;
	over = false;
	/* Compute number of bytes mod 64 */
	index = (ulong)((count[0] >> 3) & 0x3f);
	/* update number of bits */
	if ((count[0] += ((ulong)length << 3)) < ((ulong)length << 3))
		count[1]++;
	count[1] += ((ulong)length >> 29);
	partLen = 64 - index;
	/* transform as many times as possible. */
	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;
	}
	/* Buffer remaining input */
	memcpy(&buffer[index], &input[i], length - i);
}
void md5::final() {
	uchar bits[8];
	ulong oldState[4];
	ulong oldCount[2];
	ulong index, padLen;
	/* Save current state and count. */
	memcpy(oldState, state, 16);
	memcpy(oldCount, count, 8);
	/* Save number of bits */
	encode(count, bits, 8);
	/* Pad out to 56 mod 64. */
	index = (ulong)((count[0] >> 3) & 0x3f);
	padLen = (index < 56) ? (56 - index) : (120 - index);
	update(padding, padLen);
	/* Append length (before padding) */
	update(bits, 8);
	/* Store state in digest */
	encode(state, _digest, 16);
	/* Restore current state and count. */
	memcpy(state, oldState, 16);
	memcpy(count, oldCount, 8);
}
void md5::transform(const uchar block[64]) {
	ulong a = state[0], b = state[1], c = state[2], d = state[3], x[16];
	decode(block, x, 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;
}
void md5::encode(const ulong* input, uchar* output, size_t length) {

	for (size_t i = 0, j = 0; j < length; i++, j += 4) {
		output[j] = (uchar)(input[i] & 0xff);
		output[j + 1] = (uchar)((input[i] >> 8) & 0xff);
		output[j + 2] = (uchar)((input[i] >> 16) & 0xff);
		output[j + 3] = (uchar)((input[i] >> 24) & 0xff);
	}
}
void md5::decode(const uchar* input, ulong* output, size_t length) {

	for (size_t i = 0, j = 0; j < length; i++, j += 4) {
		output[i] = ((ulong)input[j]) | (((ulong)input[j + 1]) << 8) |
			(((ulong)input[j + 2]) << 16) | (((ulong)input[j + 3]) << 24);
	}
}
string md5::bytesToHexString(const uchar* 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);
}
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;
	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(){
	md5 md5;
	md5.update("aabbcdefg");
	PrintMD5("aabbcdefg", md5);
	md5.reset();
	md5.update("");
	PrintMD5("", md5);

	md5.update("aa");
	PrintMD5("aa", md5);

	md5.update("bb");
	PrintMD5("aabb", md5);

	md5.update("cdefg");
	PrintMD5("aabbcdefg", md5);
	
	md5.reset();
	md5.update("message digest");
	PrintMD5("message digest", md5);
	
	return 0;
}
5436649486
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
密码学 MD5信息摘要算法
爬虫进击之路
01-26 1260
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。
密码学摘要算法之MD5
qq_30357519的博客
12-13 890
密码学摘要算法之MD5摘要算法 摘要算法 摘要算法是一种能产生特殊输出格式的算法，这种算法的特点是:无论用户输入什么长度的原始数据，经过计算后输出的密文都是固定长度的，这种算法的原理是根据一定的运算规则对原数据进行某种形式的提取，这种提取就是摘要，被摘要的数据内容与原数据有密切 联系，只要原数据稍有改变，输出的“摘要”便完全不同，因此，基于这种原理的算法便能对 数据完整性提供较为健全的保障。但是，...
区块链中的密码学系列之MD5算法（二）
俊语的博客
03-09 873
前言 MD5算法在90年代被广泛使用在各种程序语言中，用以确保资料传递无误等。但是在1996年被证明存在弱点，是可以被破解的。但是其优势是十分的明显的，比如说稳定和快速，所以我们仍然可将其用于普通数据的错误检查领域。 1. 什么是MD5 ? MD5消息算法摘要(英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值...
【密码学】MD5算法原理
weixin_30699741的博客
02-17 151
MD5（单向散列算法）的全称是Message-Digest Algorithm 5（信息-摘要算法），经MD2、MD3和MD4发展而来。MD5算法的使用不需要支付任何版权费用。MD5功能： 输入任意长度的信息，经过处理，输出为128位的信息（数字指纹）； 不同的输入得到的不同的结果（唯一性）； 根据128位的输出结果不可能反推出输入的信息（不可逆）；MD5属不属...
密码学之MD5
iteye_1232的博客
11-25 232
对于广大Coder、SA等IT人士来说，密码学是一个很常见的词语。我们对重要数据进行加密处理，我们对登陆用户密码进行验证，我们……加解密是我们日常工作的一个重要组成部分。简单来讲，密码学是研究如何隐密地传递信息的学科，其中有一个用途广泛的算法我们不得不提，那就是MD5。 MD5诞生已经有20余年，经历无数次的质疑与攻击后仍然坚挺，它简直是一个接近完美的算法。 为何说MD...
密码学：MD5+Mysql
05-28
密码学是信息安全领域中的核心部分，它涉及到数据的加密、认证和完整性保护。在这个主题中，我们将重点关注MD5（Message-Digest Algorithm 5）哈希函数以及MySQL数据库系统在用户登录注册过程中的应用。 MD5是一种...
应用密码学：协议、算法与C源程序_.rar_应用密码学
07-14
《应用密码学：协议、算法与C源程序》是一本深入浅出的密码学教材，旨在帮助读者全面理解和掌握密码学的基本概念、协议和算法。密码学是信息安全领域的重要组成部分，它涉及到数据加密、身份认证、消息完整性以及...
应用密码学：协议、算法与C源程序
11-26
《应用密码学：协议、算法与C源程序》是一本深入探讨密码学理论与实践的著作，涵盖了密码学的基础知识、重要协议以及实用的加密算法，并提供了C语言实现的源代码，为读者提供了理论与实践相结合的学习体验。密码学是...
哈希函数的冲突-md5碰撞算法原理-密码学
10-26
差分攻击2004-199王小云（MD4、MD5、HAVAL-128和RIPEMD四个国际著名密码算法的破译结果）差分攻击是通过比较分析有特定区别的明文在通过加密后变化传播情况来攻击密码算法的。
MD5_密码学_
10-01
在密码学中，MD5被用来将任意长度的数据转化为固定长度的128位（16字节）摘要，这个摘要具有抗碰撞的特性，即相同的输入会产生相同的输出，而不同的输入几乎不可能产生相同的输出。 MD5的工作原理可以分为四个步骤...
使用Md5算法对密码进行加密
zhoucheng05_13的博客
11-28 3916
Md5加密算法对密码进行加密 先上代码：package com.star.utils;import java.math.BigInteger; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class Md5Utils
密码学MD5的实现
Welcome to tiny_spot
03-11 577
MD5的实现是很坑的，我学的这本教材上写的MD5算法写的很简单，很多细节都没有说清楚，如果不注意的话，在实现md5的时候会走很多弯路。 第一个坑点：就是MD强化，俗称填充。消息的初始化处理时，需要使得消息的比特长度时512的整数倍。书上是说在消息m的二进制表示之后先填入一个1，然后再添加若干个0（不超过511个0），是的消息的比特长度是512的整数倍少64比特，最后在最低的64比特位填入消息m的...
MD5算法详解
热门推荐
123
07-16 5万+
0x00 前言 MD5是一种哈希算法，用来保证信息的完整性。 就一段信息对应一个哈希值，且不能通过哈希值推出这段信息，而且还需要保证不存在任意两段不相同的信息对应同一个哈希值。不过MD5算法算出来的值也就16个字节（16*8=128，即128位），肯定存在相同的，找到另一个所花时间长短而已。 0x01 填充信息 在计算机中，数据存储都是二进制存储的，所以任意一个文件都是些二进制。 ...
加密算法——MD5深入学习
xlsj雪松的博客
01-01 743
任意长度的输入都输出128位的散列值。 1 算法概述： MD5以512位分组来处理输入的消息，且每一分组又被划分为16个32位子分组，Mj表示，经过处理后，输出由4个32位分组级联成的128位散列值。 2 算法步骤： 分组 将输入信息M按顺序每512位一组进行分组：M = M1，M2，…，Mn-1，Mn 数据填充 分为两次填充，第一次填充后的大小对521取余结果为448；第二次再加上...
MD5数据加密方法
weixin_52115456的博客
07-20 1万+
什么场景需要使用数据加密呢？比如秘密数据传输、用户密码加密存储等等数据传输可使用密钥对的方式进行加密解密，使用签名方式验证数据是否可靠，而密码加密存储可使用MD5等一些算法对数据进行单向加密。
深入理解MD5算法：原理、应用与安全
最新发布
04-11 2686
然而，随着计算能力的增强和密码学研究的发展，MD5算法的安全性逐渐受到挑战，不建议在安全领域中单独使用MD5算法。MD5算法存在碰撞攻击的风险，即不同的输入可能会产生相同的MD5哈希值，这会导致安全性漏洞，使得攻击者可以伪造数据或签名。MD5算法的流程设计复杂且高效，通过多轮循环和非线性函数的处理，保证了生成的哈希值具有较高的随机性和安全性。总的来说，MD5算法在数据完整性验证、数字签名、密码存储和文件校验等方面都有广泛的应用，但在一些安全性要求更高的场景下，建议选择更安全的哈希算法来替代MD5。
深入理解MD5哈希算法
fudaihb的博客
11-27 2709
当谈及MD5哈希算法时，我们进入了计算机科学与信息安全的领域。MD5，即Message Digest Algorithm 5，是一种哈希函数，旨在将任意长度的输入转换为固定长度的输出，通常是128位的散列值。这种算法在数据完整性验证、密码存储等方面曾经被广泛应用，但近年来由于其存在的漏洞和安全性问题，逐渐被弃用。接下来，我们将深入探讨MD5的工作原理及其存在的问题。
MD5算法笔记
qq_38157433的博客
09-11 906
任意长度的信息输入，MD5都将产生一个长度为128比特的输出。
md5加密算法
LUOZONGW的博客
10-19 9129
理解md5

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

5436649486

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

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

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

打赏作者

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

抵扣说明：

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

余额充值