MD5对文件进行摘要加密

合集下载

C语言实现MD5加密，竟如此简单！

C语言实现MD5加密，竟如此简单！本文详细讲解视频已经上传到B站：https:///video/BV1uy4y1p7on/公众号后台回复【md5】即可获得本文所有源码。

一、摘要算法摘要算法又称哈希算法。

它表示输入任意长度的数据，输出固定长度的数据，它的主要特征是加密过程不需要密钥，并且经过加密的数据无法被解密。

目前可以被解密逆向的只有CRC32算法，只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。

消息摘要算法不存在密钥的管理与分发问题，适合于分布式网络上使用。

由于其加密计算的工作量相当巨大，所以以前的这种算法通常只用于数据量有限的情况下的加密。

消息摘要算法分为三类：•MD(Message Digest)：消息摘要•SHA(Secure Hash Algorithm)：安全散列•MAC(Message Authentication Code)：消息认证码这三类算法的主要作用：验证数据的完整性二、MD5简介MD5即Message-Digest Algorithm 5（信息-摘要算法）。

属于摘要算法，是一个不可逆过程，就是无论多大数据，经过算法运算后都是生成固定长度的数据，结果使用16进制进行显示的128bit的二进制串。

通常表示为32个十六进制数连成的字符串。

MD5有什么用？用于确保信息传输完整一致。

是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。

更多用在文档校验上，用来生成密钥检测文档是否被篡改。

三、在线MD5加密有很多在线进行MD5加密的网站，如下：/code/c26.html举例: 给字符串 12334567 加密成。

如图结果为：32135A337F8DC8E2BB9A9B80D86BDFD0 四、C语言实现MD5算法源文件如下：md5.h#ifndef MD5_H#define MD5_Htypedef struct{unsigned int count[2];unsigned int state[4];unsigned char buffer[64];}MD5_CTX;#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 + ac; \a = ROTATE_LEFT(a,s); \a += b; \}#define GG(a,b,c,d,x,s,ac) \{ \a += G(b,c,d) + x + ac; \a = ROTATE_LEFT(a,s); \a += b; \}#define HH(a,b,c,d,x,s,ac) \{ \a += H(b,c,d) + x + ac; \a = ROTATE_LEFT(a,s); \a += b; \}#define II(a,b,c,d,x,s,ac) \{ \a += I(b,c,d) + x + ac; \a = ROTATE_LEFT(a,s); \a += b; \}void MD5Init(MD5_CTX *context);void MD5Update(MD5_CTX *context,unsigned char *input,u nsigned int inputlen);void MD5Final(MD5_CTX *context,unsigned char digest[16]);void MD5Transform(unsigned int state[4],unsigned char block[64]);void MD5Encode(unsigned char *output,unsigned int *input ,unsigned int len);void MD5Decode(unsigned int *output,unsigned char *inpu t,unsigned int len);#endifmd5.c#include <memory.h>#include 'md5.h'unsigned char PADDING[]={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};void MD5Init(MD5_CTX *context){context->count[0] = 0;context->count[1] = 0;context->state[0] = 0x67452301;context->state[1] = 0xEFCDAB89;context->state[2] = 0x98BADCFE;context->state[3] = 0x10325476;}void MD5Update(MD5_CTX *context,unsigned char *input,u nsigned int inputlen){unsigned int i = 0,index = 0,partlen = 0;index = (context->count[0] >> 3) & 0x3F;partlen = 64 - index;context->count[0] += inputlen << 3;if(context->count[0] < (inputlen << 3))context->count[1]++;context->count[1] += inputlen >> 29;if(inputlen >= partlen){memcpy(&context->buffer[index],input,partlen);MD5Transform(context->state,context->buffer);for(i = partlen;i+64 <= inputlen;i+=64)MD5Transform(context->state,&input[i]);index = 0;}else{i = 0;}memcpy(&context->buffer[index],&input[i],inputlen-i);}void MD5Final(MD5_CTX *context,unsigned char digest[16]) {unsigned int index = 0,padlen = 0;unsigned char bits[8];index = (context->count[0] >> 3) & 0x3F;padlen = (index < 56)?(56-index):(120-index);MD5Encode(bits,context->count,8);MD5Update(context,PADDING,padlen);MD5Update(context,bits,8);MD5Encode(digest,context->state,16);}void MD5Encode(unsigned char *output,unsigned int *input ,unsigned int len){unsigned int i = 0,j = 0;while(j < len){output[j] = input[i] & 0xFF;output[j+1] = (input[i] >> 8) & 0xFF;output[j+2] = (input[i] >> 16) & 0xFF;output[j+3] = (input[i] >> 24) & 0xFF;i++;j+=4;}}void MD5Decode(unsigned int *output,unsigned char *inpu t,unsigned int len){unsigned int i = 0,j = 0;while(j < len){output[i] = (input[j]) |(input[j+1] << 8) |(input[j+2] << 16) |(input[j+3] << 24);i++;j+=4;}}void MD5Transform(unsigned int state[4],unsigned char block[64]){unsigned int a = state[0];unsigned int b = state[1];unsigned int c = state[2];unsigned int d = state[3];unsigned int x[64];MD5Decode(x,block,64);FF(a, b, c, d, x[ 0], 7, 0xd76aa478); /* 1 */FF(d, a, b, c, x[ 1], 12, 0xe8c7b756); /* 2 */FF(c, d, a, b, x[ 2], 17, 0x242070db); /* 3 */FF(b, c, d, a, x[ 3], 22, 0xc1bdceee); /* 4 */FF(a, b, c, d, x[ 4], 7, 0xf57c0faf); /* 5 */FF(d, a, b, c, x[ 5], 12, 0x4787c62a); /* 6 */FF(c, d, a, b, x[ 6], 17, 0xa8304613); /* 7 */FF(b, c, d, a, x[ 7], 22, 0xfd469501); /* 8 */FF(a, b, c, d, x[ 8], 7, 0x698098d8); /* 9 */FF(d, a, b, c, x[ 9], 12, 0x8b44f7af); /* 10 */FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 *//* Round 2 */GG(a, b, c, d, x[ 1], 5, 0xf61e2562); /* 17 */GG(d, a, b, c, x[ 6], 9, 0xc040b340); /* 18 */GG(c, d, a, b, x[11], 14, 0x265e5a51); /* 19 */ GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /* 20 */GG(a, b, c, d, x[ 5], 5, 0xd62f105d); /* 21 */ GG(d, a, b, c, x[10], 9, 0x2441453); /* 22 */ GG(c, d, a, b, x[15], 14, 0xd8a1e681); /* 23 */ GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /* 24 */ GG(a, b, c, d, x[ 9], 5, 0x21e1cde6); /* 25 */ GG(d, a, b, c, x[14], 9, 0xc33707d6); /* 26 */ GG(c, d, a, b, x[ 3], 14, 0xf4d50d87); /* 27 */ GG(b, c, d, a, x[ 8], 20, 0x455a14ed); /* 28 */ GG(a, b, c, d, x[13], 5, 0xa9e3e905); /* 29 */ GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8); /* 30 */ GG(c, d, a, b, x[ 7], 14, 0x676f02d9); /* 31 */ GG(b, c, d, a, x[12], 20, 0x8d2a4c8a); /* 32 *//* Round 3 */HH(a, b, c, d, x[ 5], 4, 0xfffa3942); /* 33 */ HH(d, a, b, c, x[ 8], 11, 0x8771f681); /* 34 */ HH(c, d, a, b, x[11], 16, 0x6d9d6122); /* 35 */ HH(b, c, d, a, x[14], 23, 0xfde5380c); /* 36 */ HH(a, b, c, d, x[ 1], 4, 0xa4beea44); /* 37 */ HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9); /* 38 */ HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60); /* 39 */ HH(b, c, d, a, x[10], 23, 0xbebfbc70); /* 40 */ HH(a, b, c, d, x[13], 4, 0x289b7ec6); /* 41 */ HH(d, a, b, c, x[ 0], 11, 0xeaa127fa); /* 42 */ HH(c, d, a, b, x[ 3], 16, 0xd4ef3085); /* 43 */ HH(b, c, d, a, x[ 6], 23, 0x4881d05); /* 44 */ HH(a, b, c, d, x[ 9], 4, 0xd9d4d039); /* 45 */ HH(d, a, b, c, x[12], 11, 0xe6db99e5); /* 46 */ HH(c, d, a, b, x[15], 16, 0x1fa27cf8); /* 47 */ HH(b, c, d, a, x[ 2], 23, 0xc4ac5665); /* 48 *//* Round 4 */II(a, b, c, d, x[ 0], 6, 0xf4292244); /* 49 */II(d, a, b, c, x[ 7], 10, 0x432aff97); /* 50 */II(c, d, a, b, x[14], 15, 0xab9423a7); /* 51 */II(b, c, d, a, x[ 5], 21, 0xfc93a039); /* 52 */II(a, b, c, d, x[12], 6, 0x655b59c3); /* 53 */II(d, a, b, c, x[ 3], 10, 0x8f0ccc92); /* 54 */II(c, d, a, b, x[10], 15, 0xffeff47d); /* 55 */II(b, c, d, a, x[ 1], 21, 0x85845dd1); /* 56 */II(a, b, c, d, x[ 8], 6, 0x6fa87e4f); /* 57 */II(d, a, b, c, x[15], 10, 0xfe2ce6e0); /* 58 */II(c, d, a, b, x[ 6], 15, 0xa3014314); /* 59 */II(b, c, d, a, x[13], 21, 0x4e0811a1); /* 60 */II(a, b, c, d, x[ 4], 6, 0xf7537e82); /* 61 */II(d, a, b, c, x[11], 10, 0xbd3af235); /* 62 */II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /* 63 */II(b, c, d, a, x[ 9], 21, 0xeb86d391); /* 64 */state[0] += a;state[1] += b;state[2] += c;state[3] += d;}五、MD5加密实例MD5加密步骤如下：1.定义MD5_CTX md5c;2.初始化/******************************************************** * 名称: MD5Init()* 功能: 初始化MD5结构体* 入口参数:context：要初始化的MD5结构体* 出口参数: 无*********************************************************/MD5Init(MD5_CTX *context);3.MD5值计算实现MD5值的计算及结构体的更新：/********************************************************** 名称: MD5Update()* 功能: 将要加密的信息传递给初始化过的MD5结构体，无返回值* 入口参数:context：初始化过了的MD5结构体input：需要加密的信息，可以任意长度inputLen：指定input的长度* 出口参数: 无*********************************************************/MD5Update(MD5_CTX *context,(unsigned char *)input,inpu tLen);4.输出转换/********************************************************** 名称: MD5Update()* 功能: 将加密结果存储到，无返回值* 入口参数:context：初始化过了的MD5结构体digest ：加密过的结果* 出口参数: 无*********************************************************/MD5Final(MD5_CTX *context,unsigned char digest[16]);5.格式整理转换成32位的16进制字符串。

MD5加密算法详解

MD5加密算法详解MD5（Message Digest Algorithm 5）是一种常见的哈希算法，用于将任意长度的信息转换为固定长度（通常为128位）的输出。

它是MD4算法的改进版本，由Ron Rivest在1991年设计。

MD5算法在密码学和数据完整性检查方面被广泛应用。

1.算法概述：MD5算法的输入是任意长度的消息，输出是一个128位（32个字符）的消息摘要。

这个摘要是唯一的，即使消息只有微小的变化，它的摘要也会有较大的差异。

MD5具有以下特点：-可逆性：MD5是单向散列函数，即不能从摘要中恢复原始消息。

这意味着无法通过知道MD5摘要的人来确定原始消息，所以MD5算法通常用于验证消息的完整性。

-高度可靠性：MD5算法能够快速计算，且其输出分布均匀，几乎每个消息都有不同的摘要。

-高速性：MD5算法的计算速度非常快，在软件和硬件上都可以轻松实现。

2.算法步骤：MD5算法的核心包括四个基本步骤：填充、初始化、循环操作和输出。

下面是详细的步骤说明：-填充：首先将消息进行填充，使其长度（以比特位为单位）满足对512求余等于448、填充的格式为一个1后面跟随若干个0，然后是64位的原始消息长度。

-初始化：使用4个固定的32位字作为初始变量（A、B、C、D），这些变量用于存储中间摘要和最终摘要。

-循环操作：MD5算法使用了64个循环运算来处理填充后的消息。

在每个循环中，输入消息的一部分被处理，并按照一系列算法步骤进行变换，然后将变换的结果添加到当前状态变量中。

-输出：循环运算结束后，将中间变量连接起来形成最终的128位摘要。

最终的结果可以表示为一个32位的十六进制数。

3.安全性：尽管MD5算法在之前被广泛应用于检验文件完整性和密码验证等领域，但现在已经不再被认为是安全的。

主要原因有：-容易受到碰撞攻击：由于MD5算法的输出空间相对较小（只有128位），因此存在相同摘要的不同输入。

这使得攻击者可以通过找到相同摘要的两个不同输入来冒充验证身份或篡改数据。

MD5加密解密

实验五MD5加密解密一．MD5生成文件摘要（1）本机进入“密码工具”｜“加密解密”｜“MD5哈希函数”｜“生成摘要”页签，在明文框中编辑文本内容： ghgfnd4eh56t78udfnhgfdghgfdhqa3mkjhagawfftefg 。

单击“生成摘要”按钮，生成文本摘要：单击“导出”按钮，将摘要导出到MD5共享文件夹（D:\Work\Encryption\MD5\）中，并通告同组主机获取摘要。

（2）单击“导入摘要”按钮，从同组主机的MD5共享文件夹中将摘要导入。

在文本框中输入同组主机编辑过的文本内容，单击“生成摘要”按钮，将新生成的摘要与导入的摘要进行比较，验证相同文本会产生相同的摘要。

（3）对同组主机编辑过的文本内容做很小的改动，再次生成摘要，与导入的摘要进行对比，验证MD5算法的抗修改性。

二．MD5算法本机进入“密码工具”｜“加密解密”｜“MD5哈希函数”｜“演示”页签,在明文输入区输入文本（文本不能超过48个字符）,单击“开始演示”，查看各模块数据及算法流程。

（1）明文：fhgfhgftyfhgftdfhgsdhj54654fghfghfghfgh（2）摘要演示过程：三．源码应用（选做）设计MD5文件校验工具，利用MD5算法计算文件摘要。

单击工具栏“VC6”按钮，启动VC++6.0。

选择“File”|“Open Workspace…”加载程文件“C:\ExpNIS\Encrypt-Lab\Projects\MD5\MD5.dsw”。

基于此工程进行程序设计。

程序代码如下：（只实现了加密的功能解密具体没有实现）#include <string.h>#include <stdlib.h>#include "md5.h"//! 文件最大2M#define MAX_FILE 1024*1024*2/*******************/// 名称：usage// 功能：帮助信息// 参数：应用程序名称// 返回：无/**********/void Usage( const char *appname )printf( "\n\tusage: md5 文件\n" );}/********/// 名称：CheckParse// 功能：校验应用程序入口参数// 参数：argc等于main主函数argc参数，argv指向main主函数argv参数// 返回：若参数合法返回true，否则返回false// 备注：简单的入口参数校验/*********/bool CheckParse( int argc, char** argv ){if( argc != 2 ){Usage( argv[0] );return false;}return true;}unsigned A,B,C,D,a,b,c,d,i,len,flen[2],x[16]; //i临时变量,len文件长,flen[2]为64位二进制表示的文件初始长度char filename[200]; //文件名FILE *fp;char MD5[32];//用于清除回车键缓存的影响void safe_flush(FILE *fp){int ch;while( (ch = fgetc(fp)) != EOF && ch != '\n' );}void dealy(){for(int time=0;time<=366666666;time++){if(time == 366666666){system("cls");}}void main(){printf("\n\n\n\n\n\t*****************题目：MD5加密工具****************\n\n");printf("\n\t*****************作者：徐刘根谢燕******************\n\n");printf("\n\t*****************指导老师：张恒汝********************\n\n");printf("\n\t*****************日期：2014-6-16********************\n\n");printf("\n\n\n\n\t\t\t3秒后自动跳转......");dealy();printf("\n\n\t******************************************************\n \n");printf("\t 加密请输入：1 退出请输入：2\n\n");printf("\t******************************************************\n");int temp;scanf("%d",&temp);safe_flush(stdin);if(temp == 2){printf("感谢使用加密解密程序！\n");}else if(temp == 1){printf("请输入你的文件名:");gets(filename);if(!(fp=fopen(filename,"rb"))){printf("无法打开你的文件!\n");}if(filename[0]==34)filename[strlen(filename)-1]=0,strcpy(filename,filename+1);fseek(fp, 0, SEEK_END);len=ftell(fp);rewind(fp);A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476;flen[1]=len/0x20000000;flen[0]=(len%0x20000000)*8;memset(x,0,64);fread(&x,4,16,fp);for(i=0;i<len/64;i++){md5();memset(x,0,64);fread(&x,4,16,fp);}((char*)x)[len%64]=128;if(len%64>55) md5(),memset(x,0,64);memcpy(x+14,flen,8); //文件末尾加入原文件的bit长度md5();fclose(fp);sprintf(MD5,"%08X%08X%08X%08X",PP(A),PP(B),PP(C),PP(D));printf("经过MD5加密后的内容为：");printf("MD5 Code:%s\n",MD5);}else{printf("请输入一个正确的选择！");}}运行结果：。

MD5加密C语言实现

MD5加密C语言实现MD5 （Message Digest Algorithm 5) 是一种常用的密码散列函数，用于将数据加密为128位长度的摘要。

在C语言中，可以通过一系列步骤来实现MD5加密算法。

1.准备工作：首先需要包含一些C标准头文件和预定义常量。

在C语言中，可以使用以下代码来实现：```c#include <stdio.h>#include <stdlib.h>#include <string.h>#include <stdint.h>#define HASH_LENGTH 16```2.定义数据结构：MD5算法涉及到一个64字节的消息块和一个4字节的消息摘要块。

在C语言中，可以使用以下代码来定义这些结构：```ctypedef structuint8_t data[64];uint32_t datalen;uint32_t bitlen[2];uint32_t state[4];}MD5_CTX;typedef uint8_t (*hash_function)(uint8_t *);```3.定义常量和函数：MD5算法使用到一些常量和函数。

在C语言中，可以使用以下代码来定义这些常量和函数：```cconst uint32_t k[64] =// more constants ...};const uint32_t r[64] =7,12,17,22,7,12,17,22,// more constants ...};void md5_transform(MD5_CTX *ctx, uint8_t data[]);void md5_init(MD5_CTX *ctx)ctx->datalen = 0;ctx->bitlen[0] = 0;ctx->bitlen[1] = 0;ctx->state[1] = 0xEFCDAB89;ctx->state[2] = 0x98BADCFE;void md5_update(MD5_CTX *ctx, uint8_t data[], uint32_t len) for (uint32_t i = 0; i < len; i++)ctx->data[ctx->datalen] = data[i];ctx->datalen++;if (ctx->datalen == 64)md5_transform(ctx, ctx->data);ctx->bitlen[0] += 512;ctx->bitlen[1] += (ctx->bitlen[0] < 512);ctx->datalen = 0;}}void md5_final(MD5_CTX *ctx, uint8_t hash[])uint32_t i = ctx->datalen;if (ctx->datalen < 56)ctx->data[i++] = 0x80;while (i < 56)ctx->data[i++] = 0x00;}} elsectx->data[i++] = 0x80;while (i < 64)ctx->data[i++] = 0x00;}md5_transform(ctx, ctx->data);memset(ctx->data, 0, 56);}ctx->bitlen[0] += ctx->datalen * 8;ctx->bitlen[1] += (ctx->bitlen[0] < ctx->datalen * 8); ctx->data[63] = ctx->bitlen[0] & 0xff;ctx->data[62] = (ctx->bitlen[0] >> 8) & 0xff;ctx->data[61] = (ctx->bitlen[0] >> 16) & 0xff;ctx->data[60] = (ctx->bitlen[0] >> 24) & 0xff;ctx->data[59] = ctx->bitlen[1] & 0xff;ctx->data[58] = (ctx->bitlen[1] >> 8) & 0xff;ctx->data[57] = (ctx->bitlen[1] >> 16) & 0xff;ctx->data[56] = (ctx->bitlen[1] >> 24) & 0xff;md5_transform(ctx, ctx->data);for (i = 0; i < 4; i++)hash[i] = (ctx->state[0] >> (i * 8)) & 0xff;hash[i + 4] = (ctx->state[1] >> (i * 8)) & 0xff;hash[i + 8] = (ctx->state[2] >> (i * 8)) & 0xff;hash[i + 12] = (ctx->state[3] >> (i * 8)) & 0xff;}void md5_transform(MD5_CTX *ctx, uint8_t data[])uint32_t a, b, c, d, f, g, temp;uint32_t m[16], i, j;for (i = 0, j = 0; i < 16; i++, j += 4)m[i] = (data[j]) + (data[j + 1] << 8) + (data[j + 2] << 16) + (data[j + 3] << 24);}a = ctx->state[0];b = ctx->state[1];c = ctx->state[2];d = ctx->state[3];for (i = 0; i < 64; i++)if (i < 16)f=(b&c)，((~b)&d);g=i;} else if (i < 32)f=(d&b)，((~d)&c);g=(5*i+1)%16;} else if (i < 48)f=b^c^d;g=(3*i+5)%16;} elsef=c^(b，(~d));g=(7*i)%16;}temp = d;d=c;c=b;b = b + leftrotate((a + f + k[i] + m[g]), r[i]);a = temp;}ctx->state[0] += a;ctx->state[1] += b;ctx->state[2] += c;ctx->state[3] += d;```4.实现加密函数：最后，可以编写一个简单的调用MD5算法的加密函数。

MD5加密算法的原理及应用

MD5加密算法的原理及应用MD5加密算法是一种常见的哈希算法，用于产生固定长度的摘要信息。

该算法由美国计算机安全专家罗纳德·李维斯特于1991年设计，并在1992年首次公开。

MD5是指“Message Digest Algorithm 5”的缩写。

MD5加密算法的原理是将任意长度的输入消息通过一系列操作转换为长度固定（128位）的输出摘要。

这一过程是不可逆的，即无法通过摘要信息还原出原始的输入消息。

MD5算法的核心函数包括位操作、模运算、异或运算和与非运算。

具体过程如下：1.初始填充：将输入消息分割为若干个512位的消息块，并添加填充位，使每个消息块的长度为512位。

2.初始化状态：将四个32位的寄存器A、B、C、D初始化，作为MD5算法的内部状态。

3.处理消息块：循环处理每个消息块，对每个消息块进行一系列的位运算、模运算和异或运算，修改内部状态。

4.输出：处理完所有消息块后，将最终的内部状态输出为一个128位（32位×4）的摘要。

1.文件完整性校验：MD5可以对文件进行哈希计算，生成唯一的摘要值，通过比对两个文件的MD5摘要是否一致，可以判断文件是否被篡改。

2.密码存储：在用户注册过程中，通常不会将用户的密码明文存储在数据库中，而是将其进行MD5加密后存储。

当用户登录时，输入的密码再次通过MD5加密与数据库中存储的加密密码进行对比。

4.垃圾邮件过滤：MD5可以用于检测垃圾邮件。

将邮件的正文内容通过MD5加密并与已知的垃圾邮件MD5值进行对比，可以快速判定该邮件是否为垃圾邮件。

5.数据库索引：MD5可以作为数据库索引的一部分，提高查询效率。

通过对需要索引的数据进行MD5加密，可以将一部分数据转化为固定长度的摘要，便于数据库的查询操作。

然而，由于MD5算法的安全性较低，易受到碰撞攻击（即找到不同的原始消息，但其MD5摘要值相同）和彩虹表攻击（通过预先计算MD5摘要的映射关系，快速破解密码）等攻击方式的影响，因此在一些对安全性要求较高的场景，如数据加密、验证、身份认证等领域，MD5算法已经不再推荐使用。

MD5对文件进行摘要加密

MD5对文‎件进行摘要‎加密[摘要]MD5（Messa‎ge-Diges‎t Algor‎ithm 5）90年代初‎由MIT Labor‎atory‎ for compu ‎ter scien‎ce和RS‎ A Data Secur‎ity inc的R‎onald‎ L．Rives‎t开发出来‎，经MD2、MD3和M‎D4发展而‎来。

本文描述了‎MD5加密‎算法的原理‎及程序设计‎过程与程序‎实现，在参考RF‎C1321‎的基础上，把加密程序‎做成可视化‎窗口形式，以方便使用‎。

[关键词] MD5加密‎设计实现应用1. 引言MD (Messa‎g e Diges‎t)意为报文摘‎要。

由Ron River‎s t 于1990‎年作为RF‎C提出，1992年‎[RFC 1320，1321]公布了MD‎5算法的细‎节。

其功能是对‎不定长的报‎文作出定长‎的“报文摘要”。

1.1 编写目的本文描述了‎怎样实现M‎D5报文摘‎要算法的方‎法。

MD5有这‎样一个性质‎，杂凑码中的‎每一个比特‎都是所有输‎入比特的函‎数，因此获得了‎很好的混淆‎效果，从而不可能‎随机选择两‎个具有相同‎杂凑码的报‎文。

此算法将对‎输入的任意‎长度的信息‎进行计算，产生一个1‎28位长度‎的“指纹”或“报文摘要”。

1.2 安全性分析‎找出两个具‎有相同杂凑‎码的报文需‎要执行O(264)次运算；而寻找具有‎给定杂凑码‎的一个报文‎，要执行O(2128)次运算。

从密码分析‎的角度来看‎，要破解MD‎5运算结果‎，若用穷尽搜‎索方法，需进行O(264) 次运算，但用第Ⅱ类生日攻击‎，分析所需时‎间要短得多‎。

因此认为M‎D5易受第‎Ⅱ类生日攻击‎的威胁。

1. 3 术语与符号‎实现中，一个“字”是32位，一个“字节”是8位。

一系列位串‎可看成是一‎系列字节的‎普通形式，其中的连续‎的8位看成‎一个字节，高位在前，同理一系列‎字节串可看‎成是一系列‎32位的字‎，其中每个连‎续的4个字‎节当作一个‎字，低位在前。

MD5加密算法原理及实现

MD5加密算法原理及实现MD5消息摘要算法，属Hash算法⼀类。

MD5算法对输⼊任意长度的消息进⾏运⾏，产⽣⼀个128位的消息摘要。

以下所描述的消息长度、填充数据都以位(Bit)为单位，字节序为⼩端字节。

算法原理1、数据填充对消息进⾏数据填充，使消息的长度对512取模得448，设消息长度为X，即满⾜X mod 512=448。

根据此公式得出需要填充的数据长度。

填充⽅法：在消息后⾯进⾏填充，填充第⼀位为1，其余为0。

2、添加消息长度在第⼀步结果之后再填充上原消息的长度，可⽤来进⾏的存储长度为64位。

如果消息长度⼤于264，则只使⽤其低64位的值，即（消息长度对 264取模）。

在此步骤进⾏完毕后，最终消息长度就是512的整数倍。

3、数据处理准备需要⽤到的数据：4个常数：A = 0x67452301, B = 0x0EFCDAB89, C = 0x98BADCFE, D = 0x10325476;4个函数：F(X,Y,Z)=(X & Y) | ((~X) & Z); G(X,Y,Z)=(X & Z) | (Y & (~Z)); H(X,Y,Z)=X ^ Y ^ Z; I(X,Y,Z)=Y ^ (X | (~Z));把消息分以512位为⼀分组进⾏处理，每⼀个分组进⾏4轮变换，以上⾯所说4个常数为起始变量进⾏计算，重新输出4个变量，以这4个变量再进⾏下⼀分组的运算，如果已经是最后⼀个分组，则这4个变量为最后的结果，即MD5值。

具体计算的实现较为复杂，建议查阅相关书籍，下⾯给出在C++上的实现代码。

代码实现#MD5.h1 #ifndef MD5H2#define MD5H3 #include <math.h>4 #include <Windows.h>56void ROL(unsigned int &s, unsigned short cx); //32位数循环左移实现函数7void ltob(unsigned int &i); //B\L互转，接受UINT类型8 unsigned int* MD5(const char* mStr); //接⼝函数，并执⾏数据填充，计算MD5时调⽤此函数910#endif#MD5.cpp1 #include "MD5.h"23/*4组计算函数*/4 inline unsigned int F(unsigned int X, unsigned int Y, unsigned int Z)5 {6return (X & Y) | ((~X) & Z);7 }8 inline unsigned int G(unsigned int X, unsigned int Y, unsigned int Z)9 {10return (X & Z) | (Y & (~Z));11 }12 inline unsigned int H(unsigned int X, unsigned int Y, unsigned int Z)13 {14return X ^ Y ^ Z;15 }16 inline unsigned int I(unsigned int X, unsigned int Y, unsigned int Z)17 {18return Y ^ (X | (~Z));19 }20/*4组计算函数结束*/2122/*32位数循环左移实现函数*/23void ROL(unsigned int &s, unsigned short cx)24 {25if (cx > 32)cx %= 32;26 s = (s << cx) | (s >> (32 - cx));27return;28 }2930/*B\L互转，接收UINT类型*/31void ltob(unsigned int &i)32 {33 unsigned int tmp = i;//保存副本34byte *psour = (byte*)&tmp, *pdes = (byte*)&i;35 pdes += 3;//调整指针，准备左右调转36for (short i = 3; i >= 0; --i)37 {38 CopyMemory(pdes - i, psour + i, 1);39 }40return;41 }4243/*44MD5循环计算函数，label=第⼏轮循环（1<=label<=4），lGroup数组=4个种⼦副本，M=数据（16组32位数指针）45种⼦数组排列⽅式: --A--D--C--B--，即 lGroup[0]=A; lGroup[1]=D; lGroup[2]=C; lGroup[3]=B;46*/47void AccLoop(unsigned short label, unsigned int *lGroup, void *M)48 {49 unsigned int *i1, *i2, *i3, *i4, TAcc, tmpi = 0; //定义:4个指针； T表累加器；局部变量50 typedef unsigned int(*clac)(unsigned int X, unsigned int Y, unsigned int Z); //定义函数类型51const unsigned int rolarray[4][4] = {52 { 7, 12, 17, 22 },53 { 5, 9, 14, 20 },54 { 4, 11, 16, 23 },55 { 6, 10, 15, 21 }56 };//循环左移-位数表57const unsigned short mN[4][16] = {58 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },59 { 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12 },60 { 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2 },61 { 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 }62 };//数据坐标表63const unsigned int *pM = static_cast<unsigned int*>(M);//转换类型为32位的Uint64 TAcc = ((label - 1) * 16) + 1; //根据第⼏轮循环初始化T表累加器65 clac clacArr[4] = { F, G, H, I }; //定义并初始化计算函数指针数组6667/*⼀轮循环开始（16组->16次）*/68for (short i = 0; i < 16; ++i)69 {70/*进⾏指针⾃变换*/71 i1 = lGroup + ((0 + i) % 4);72 i2 = lGroup + ((3 + i) % 4);73 i3 = lGroup + ((2 + i) % 4);74 i4 = lGroup + ((1 + i) % 4);7576/*第⼀步计算开始: A+F(B,C,D)+M[i]+T[i+1] 注:第⼀步中直接计算T表*/77 tmpi = (*i1 + clacArr[label - 1](*i2, *i3, *i4) + pM[(mN[label - 1][i])] + (unsigned int)(0x100000000UL * abs(sin((double)(TAcc + i)))));78 ROL(tmpi, rolarray[label - 1][i % 4]);//第⼆步:循环左移79 *i1 = *i2 + tmpi;//第三步:相加并赋值到种⼦80 }81return;82 }8384/*接⼝函数，并执⾏数据填充*/85 unsigned int* MD5(const char* mStr)86 {87 unsigned int mLen = strlen(mStr); //计算字符串长度88if (mLen < 0) return0;89 unsigned int FillSize = 448 - ((mLen * 8) % 512); //计算需填充的bit数90 unsigned int FSbyte = FillSize / 8; //以字节表⽰的填充数91 unsigned int BuffLen = mLen + 8 + FSbyte; //缓冲区长度或者说填充后的长度92 unsigned char *md5Buff = new unsigned char[BuffLen]; //分配缓冲区93 CopyMemory(md5Buff, mStr, mLen); //复制字符串到缓冲区9495/*数据填充开始*/96 md5Buff[mLen] = 0x80; //第⼀个bit填充197 ZeroMemory(&md5Buff[mLen + 1], FSbyte - 1); //其它bit填充0，另⼀可⽤函数为FillMemory98 unsigned long long lenBit = mLen * 8ULL; //计算字符串长度，准备填充99 CopyMemory(&md5Buff[mLen + FSbyte], &lenBit, 8); //填充长度100/*数据填充结束*/101102/*运算开始*/103 unsigned int LoopNumber = BuffLen / 64; //以16个字为⼀分组，计算分组数量104 unsigned int A = 0x67452301, B = 0x0EFCDAB89, C = 0x98BADCFE, D = 0x10325476;//初始4个种⼦，⼩端类型105 unsigned int *lGroup = new unsigned int[4]{ A, D, C, B}; //种⼦副本数组,并作为返回值返回106for (unsigned int Bcount = 0; Bcount < LoopNumber; ++Bcount) //分组⼤循环开始107 {108/*进⼊4次计算的⼩循环*/109for (unsigned short Lcount = 0; Lcount < 4;)110 {111 AccLoop(++Lcount, lGroup, &md5Buff[Bcount * 64]);112 }113/*数据相加作为下⼀轮的种⼦或者最终输出*/114 A = (lGroup[0] += A);115 B = (lGroup[3] += B);116 C = (lGroup[2] += C);117 D = (lGroup[1] += D);118 }119/*转换内存中的布局后才能正常显⽰*/120 ltob(lGroup[0]);121 ltob(lGroup[1]);122 ltob(lGroup[2]);123 ltob(lGroup[3]);124 delete[] md5Buff; //清除内存并返回125return lGroup;126 }再给出调⽤实例（以win32控制台应⽤程序为例）：#main.cpp1 #include <iostream>2 #include <string.h>3 #include <stdlib.h>4 #include "MD5.h"56int main(int argc, char **argv)7 {8char tmpstr[256], buf[4][10];9 std::cout << "请输⼊要加密的字符串：";10 std::cin >> tmpstr;11 unsigned int* tmpGroup = MD5(tmpstr);12 sprintf_s(buf[0], "%8X", tmpGroup[0]);13 sprintf_s(buf[1], "%8X", tmpGroup[3]);14 sprintf_s(buf[2], "%8X", tmpGroup[2]);15 sprintf_s(buf[3], "%8X", tmpGroup[1]);16 std::cout <<"MD5:"<< buf[0] << buf[1] << buf[2] << buf[3] << std::endl; 1718 delete[] tmpGroup;19return0; //在此下断点才能看到输出的值20 }注：以上代码在VS2013上编译通过。

【md5】几种常见的数据摘要算法（MD5、CRC32、SHA1和SHA256）

【md5】⼏种常见的数据摘要算法（MD5、CRC32、SHA1和SHA256）1、算法概述数据摘要算法是密码学算法中⾮常重要的⼀个分⽀，它通过对所有数据提取指纹信息以实现数据签名、数据完整性校验等功能，由于其不可逆性，有时候会被⽤做敏感信息的加密。

数据摘要算法也被称为哈希（Hash）算法或散列算法。

1.1、CRC8、CRC16、CRC32 CRC（Cyclic Redundancy Check，循环冗余校验）算法出现时间较长，应⽤也⼗分⼴泛，尤其是通讯领域，现在应⽤最多的就是 CRC32 算法，它产⽣⼀个4字节（32位）的校验值，⼀般是以8位⼗六进制数，如FA 12 CD 45等。

CRC算法的优点在于简便、速度快，严格的来说，CRC更应该被称为数据校验算法，但其功能与数据摘要算法类似，因此也作为测试的可选算法。

在 WinRAR、WinZIP 等软件中，也是以 CRC32 作为⽂件校验算法的。

⼀般常见的简单⽂件校验（Simple File Verify –SFV）也是以 CRC32算法为基础，它通过⽣成⼀个后缀名为 .SFV 的⽂本⽂件，这样可以任何时候可以将⽂件内容 CRC32运算的结果与 .SFV ⽂件中的值对⽐来确定此⽂件的完整性。

与 SFV 相关⼯具软件有很多，如MagicSFV、MooSFV等。

1.2、MD2 、MD4、MD5 这是应⽤⾮常⼴泛的⼀个算法家族，尤其是 MD5（Message-Digest Algorithm 5，消息摘要算法版本5），它由MD2、MD3、MD4发展⽽来，由Ron Rivest（RSA公司）在1992年提出，被⼴泛应⽤于数据完整性校验、数据（消息）摘要、数据加密等。

MD2、MD4、MD5 都产⽣16字节（128位）的校验值，⼀般⽤32位⼗六进制数表⽰。

MD2的算法较慢但相对安全，MD4速度很快，但安全性下降，MD5⽐MD4更安全、速度更快。

在互联⽹上进⾏⼤⽂件传输时，都要得⽤MD5算法产⽣⼀个与⽂件匹配的、存储MD5值的⽂本⽂件（后缀名为 .md5或.md5sum），这样接收者在接收到⽂件后，就可以利⽤与 SFV 类似的⽅法来检查⽂件完整性，绝⼤多数⼤型软件公司或开源组织都是以这种⽅式来校验数据完整性，⽽且部分操作系统也使⽤此算法来对⽤户密码进⾏加密，另外，它也是⽬前计算机犯罪中数据取证的最常⽤算法。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

MD5对文件进行摘要加密[摘要]MD5（Message-Digest Algorithm 5）90年代初由MIT Laboratory for computer science 和RSA Data Security inc的Ronald L．Rivest开发出来，经MD2、MD3和MD4发展而来。

本文描述了MD5加密算法的原理及程序设计过程与程序实现，在参考RFC1321的基础上，把加密程序做成可视化窗口形式，以方便使用。

[关键词] MD5加密设计实现应用1. 引言MD (Message Digest)意为报文摘要。

由Ron Riverst 于1990年作为RFC提出，1992年[RFC 1320，1321]公布了MD5算法的细节。

其功能是对不定长的报文作出定长的“报文摘要”。

1.1 编写目的本文描述了怎样实现MD5报文摘要算法的方法。

MD5有这样一个性质，杂凑码中的每一个比特都是所有输入比特的函数，因此获得了很好的混淆效果，从而不可能随机选择两个具有相同杂凑码的报文。

此算法将对输入的任意长度的信息进行计算，产生一个128位长度的“指纹”或“报文摘要”。

1.2 安全性分析找出两个具有相同杂凑码的报文需要执行O(264)次运算；而寻找具有给定杂凑码的一个报文，要执行O(2128)次运算。

从密码分析的角度来看，要破解MD5运算结果，若用穷尽搜索方法，需进行O(264) 次运算，但用第Ⅱ类生日攻击，分析所需时间要短得多。

因此认为MD5易受第Ⅱ类生日攻击的威胁。

1. 3 术语与符号实现中，一个“字”是32位，一个“字节”是8位。

一系列位串可看成是一系列字节的普通形式，其中的连续的8位看成一个字节，高位在前，同理一系列字节串可看成是一系列32位的字，其中每个连续的4个字节当作一个字，低位在前。

“当前文件”或“当前文档”指在当前MD5加密程序窗口打开的文件程序假定一个int型变量占一个“字”的内存空间，一个char型变量占一个“字节”的内存空间。

2. 程序说明2.1 程序描述本程序实现了MD5加密技术，对打开的文件或当前编辑的文件进行加密。

程序主要通过菜单选项进行操作。

2.2 功能说明(功能模块结构)2.3 算法说明MD5加密算法对文件中的内容进行摘要运算，摘要的执行分为以下几个步骤：第一步，补位：MD5算法先对输入的数据进行补位，使得数据的长度(以byte为单位)对64求余的结果是56。

即数据扩展至LEN=K*64+56个字节，K为整数。

补位方法：补一个1，然后补0至满足上述要求。

相当于补一个0x80的字节，再补值为0的字节。

这一步里总共补充的字节数为0～63个。

第二步，附加数据长度：用一个64位的整数表示数据的原始长度(以bit为单位)，将这个数字的8个字节按低位的在前，高位在后的顺序附加在补位后的数据后面。

这时，数据被填补后的总长度为：LEN =K*64+56+8=(K+1)*64 Bytes。

第三步，初始化MD5参数：有四个32位整数变量(A,B,C,D) 用来计算信息摘要，每一个变量被初始化成以下以十六进制数表示的数值，低位的字节在前面。

word A: 01 23 45 67word B: 89 ab cd efword C: fe dc ba 98word D: 76 54 32 10低位的字节在前面指的是Little Endian平台上内存中字节的排列方式，而在程序中书写时，要写成：A=0x67452301B=0xefcdab89C=0x98badcfeD=0x10325476第四步，定义四个MD5基本的按位操作函数：X，Y，Z为32位整数。

F(X,Y,Z) = (X and Y) or (not(X) and Z)G(X,Y,Z) = (X and Z) or (Y and not(Z))H(X,Y,Z) = X xor Y xor ZI(X,Y,Z) = Y xor (X or not(Z))再定义四个分别用于四轮变换的函数。

设Mj表示消息的第j个子分组（从0到15），<<S表示循环左移S位，则四种操作为：FF(a,b,c,d,Mj,s,ti)表示a=b+((a+(F(b,c,d)+Mj+ti)<<s)GG(a,b,c,d,Mj,s,ti)表示a=b+((a+(G(b,c,d)+Mj+ti)<<s)HH(a,b,c,d,Mj,s,ti)表示a=b+((a+(H(b,c,d)+Mj+ti)<<s)I I(a,b,c,d,Mj,s,ti)表示a=b+((a+(I(b,c,d)+Mj+ti)<<s)第五步，对输入数据作变换。

处理数据，N是总的字节数，以64个字节为一组，每组作一次循环，每次循环进行四轮操作。

要变换的64个字节用16个32位的整数数组M[0 ...15]表示。

而数组T[1 ... 64]表示一组常数，T 为4294967296*abs(sin(i))的32位整数部分，i的单位是弧度,i的取值从1到64。

具体过程如下：/* 设置主循环变量 */For (i = 0；i< =N/16-1;i++ ){/*每循环一次，把数据原文存放在16个元素的数组X中. */For( j = 0;j<=15 ;j++)Set X[j] to M[i*16+j].AA = ABB = BCC = CDD = D/* 第1轮*//* 以 [abcd k s i]表示如下操作a =b + ((a + F(b,c,d) + X[k] + T) << s) *//*做以下运算*/[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4][ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8][ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12][ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]/* 第2轮 */[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20][ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24][ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28][ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32]/* 第3轮*/[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36][ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40][ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44][ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]/* 第4轮*/[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52][ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56][ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60][ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64]/* 然后进行如下操作 */A = A + AAB = B + BBC = C + CCD = D + DD}第六步，测试结果。

3. 程序设计3.1 新建文件在程序初始化时创建子窗口，含有一个空白文档，并带有滚动条。

可以在窗口中进行文本编辑。

新建文件时把当前文件的内容置为空，并把当前文档的路径、文件名置为空值。

便相当于创建了一人个新文档。

static TCHA R szFileName[MAX_PATH], szTitleName[MAX_PATH] ；SetWindowText (hwndEdit, TEXT ("\0")) ;szFileName[0] = '\0' ;szTitleName[0] = '\0' ;在对当前文档进行置空之前还必须先询问是否保存当前文件，根据用户选项进行保存或放弃保存操作。

short AskAboutSave (HWND hwnd, TCHA R * szTitleName)；3.2 打开文件当打开一个文件时，先要初始化一个OPENFILENAME结构(全局或静态)，用于存储打开、保存文件时的一些信息。

程序中这个结构在创建窗口时对其进行初始化。

static OPENFILENAME ofn ；void PopFileInitialize (HWND hwnd){static TCHAR szFilter[] = TEXT ("Text Files (*.TXT)\0*.txt\0")\TEXT ("ASCII Files (*.ASC)\0*.asc\0") \TEXT ("All Files (*.*)\0*.*\0\0") ;ofn.lStructSize = sizeof (OPENFILENAME) ;ofn.hwndOwner = hwnd ;ofn.hInstance = NULL ;ofn.lpstrFilter = szFilter ;ofn.lpstrCustomFilter = NULL ;ofn.nMaxCustFilter = 0 ;ofn.nFilterIndex = 0 ;ofn.lpstrFile = NULL ; // Set in Open and Close functionsofn.nMaxFile = MAX_PATH ;ofn.lpstrFileTitle = NULL ;// Set in Open and Close functionsofn.nMaxFileTitle = MAX_PATH ;ofn.lpstrInitialDir = NULL ;ofn.lpstrTitle = NULL ;ofn.Flags = 0 ; // Set in Open and Close functionsofn.nFileOffset = 0 ;ofn.nFileExtension = 0 ;ofn.lpstrDefExt = TEXT ("txt") ;ofn.lCustData = 0L ;ofn.lpfnHook = NULL ;结构中各数据项在调用打开/保存文件对话框时进行设置。