MD5详解（校验文件完整性）

已于 2022-10-01 17:21:50 修改
阅读量1.9w 收藏 52
点赞数 14
分类专栏： 基础算法 文章标签： 哈希算法 算法 md5 开发语言 嵌入式
于 2022-07-31 18:41:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20017379/article/details/126078818
版权

目录

一：用途

二：特性

三：概念

四：算法

1.附加填充位 

2.分组，记录信息长度

3.缓冲区初始化

4.四轮循环运算

 五：代码

一：用途

  1. 1.校验文件完整性
  2. 2.存储密码改为存储md5，就算得到md5也无法知道密码（但是单纯密码的话，还是存在固定md5，这个时候我们应该给md5加盐）

加盐：就是在密码后边随机加随机数，然后将随机数存储，每次输入密码后边再加上随机数填充计算MD5

  1. 3.无法破解原始数据，因为md5是不可逆的

二：特性

  • 1.输入任意长度的信息，经过处理，输出为128位的信息（数字指纹）
  • 2.从原数据计算出MD5值很容易(容易计算)
  • 3.让密文中的每一位受明文中的许多位的影响；
  • 4.就是将密文与密钥之间的统计关系变得尽可能复杂，使得对手即使获取了关于密文的一些统计特性，也无法推测密钥。有损加密的过程，根据128位的输出结果不可能反推出输入的信息（不可逆）
  • 5.无论密钥或明文的任何细微变化都应当引起密文的剧烈改变。输入中的一位发生变化，HASH值中将有至少一半发生变化。想找到两个不同的数据，使它们具有相同的MD5值，是非常困难的（强抗碰撞）
  • 6.寻找任何的(M1,M2),使H(M1)=H(M2)在计算上不可行，防范生日攻击。
  • 7.不同的输入得到的不同的结果（唯一性）

三：概念

MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。1996年后该算法被证实存在弱点，可以被加以破解，对于需要高度安全性的数据，专家一般建议改用其他算法，如SHA-2。2004年，证实MD5算法无法防止碰撞（collision），因此不适用于安全性认证，如SSL公开密钥认证或是数字签名等用途。

四：算法

1.附加填充位 

填充一个‘1’和若干个‘0’使其长度模512与448同余，然后再将消息的真实长度以64bit表示附加在填充结果后面，从而使得消息长度恰好为512bit的整数倍。

2.分组，记录信息长度

将该填充过的消息分成L组，每组有512位，即一个64字节的组，再将每组表示为16个32位（4字节）。如果输入信息的长度(bit)对512求余的结果不等于448，就需要填充使得对512求余的结果等于448。填充的方法是填充一个1和n个0。填充完后，信息的长度就为N*512+448(bit)；用64位来存储填充前信息长度。这64位加在第一步结果的后面，这样信息长度就变为N*512+448+64=(N+1)*512位。

3.缓冲区初始化

MD5中有A、B、C、D 4个32为寄存器，最开始存放4个固定的32位的整数参数，即初始链接变量，这些参数用于第1轮运算。

A=0x12345678，B=0x89ABCDEF，C=0xFEDCBA98，D=0x76543210

4.四轮循环运算

循环的次数是分组的个数（N+1）

 五：代码

/**
 * @file md5.c
 * @brief 计算md5
 * @details 
 * @mainpage 
 * @author it小生lkc
 * @email 
 * @version 
 * @date 2022-7-31
 * @license 
 */
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include <memory.h>
#include "md5.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
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 };
                            
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
static void MD5Transform(unsigned int state[4], unsigned char block[64]);
static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);
static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);

static 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;
    }
}

static void MD5Decode(unsigned int *output, unsigned char *input, 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;
    }
}

static 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);

    /* Round 1 */
    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;
}

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, unsigned 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);
}

#ifdef __cplusplus
};
#endif

#ifndef MD5_H
#define MD5_H

typedef struct
{
    unsigned int count[2];
    unsigned int state[4];
    unsigned char buffer[64];
}MD5_CTX;

/* F, G and H are basic MD5 functions: selection, majority, parity */
#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))

/* ROTATE_LEFT rotates x left n bits  */
#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; \
}

extern void MD5Init(MD5_CTX* context);
extern void MD5Update(MD5_CTX* context, unsigned char* input, unsigned int inputlen);
extern void MD5Final(MD5_CTX* context, unsigned char digest[16]);

#endif // MD5_H

IT小生lkc
关注
  • 14
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
5_基于MD5的文件完整性检测程序_完整性_md5算法_
10-02
基于MD5的文件完整性检测程序，共包含4个文件：md5.h、md5.cpp、test.cpp、nankai.txt。编译：命令行模式下，切换到代码所在目录，输入make后回车即可。
MD5生成和校验
我都博客
10-23 5970
任何类型的一个文件，它都只有一个MD5值，并且如果这个文件被修改过或者篡改过，它的MD5值也将改变。因此，我们会对比文件的MD5值，来校验文件是否是有被恶意篡改过。
前端常用加密小技巧：encode, MD5,JSEncrypt
最新发布
qq_63322025的博客
04-15 448
JSEncrypt 是一个用于在 JavaScript 中进行 RSA 加密和解密的开源库。它提供了一个方便且安全的界面，可让开发人员在 Web 应用程序中轻松实施加密功能。MD5（Message Digest 5）是一种加密算法，用于生成数字消息或数据的固定长度（128 位）散列值。要使用 MD5，需要使用 MD5 算法对输入数据进行散列。这可以通过使用编程语言中的 MD5 库或使用在线 MD5 计算器来完成。最近工作的时候，写了一个登录注册相关功能，用到了些加密的东西，特此分享~
Java实现MD5大文件校验码详解
12-01
Java实现MD5大文件校验码详细解析： 包括具体方法解释、注释 通俗易懂、易于理解
详解Python3之数据指纹MD5校验与对比
09-19
主要介绍了Python3之数据指纹MD5校验与对比，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
MD5校验（checksum）
Mcy7ycM的博客
04-22 9652
MD5校验（checksum）是通过对接收的传输数据执行散列运算来检查数据的正确性。 简介 一个散列函数，比如 MD5，是一个将任意长度的数据字符串转化成短的固定长度的值的单向操作。任意两个字符串不应有相同的散列值（即，有“很大可能”是不一样的，并且要人为地创造出来两个散列值相同的字符串应该是困难的）。 一个 MD5校验和（checksum）通过对接收的传输数据执行散列运算来检查数据的正确性。计算出的散列值拿来和随数据传输的散列值比较。如果两个值相同，说明传输的数据完整无误、没有被窜改过（前提是散列.
Java中实现Md5（32位）加密
02-19
Java中实现Md5（32位）加密，此资源下载后可直接在程序中使用
基于QT的MD5加密实例
yangzijiangtou
10-30 1060
MD5在QT4中已有实现： MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 标准...
java MD5 32位加密
男人要霸气的博客
05-23 8253
import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class MD5 { public static void main(String[] args) { MD5 md5 = new MD5(); Str...
java md5 32位加密代码_JAVA 32位md5加密代码
weixin_30569303的博客
02-16 634
import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;public class Test {public static void main(String[] args) {Test test = new Test();System.out.println(test.encryption("1...
java md5 32位加密算法_JAVA-32位MD5加密算法
weixin_35734209的博客
02-13 474
package sn.len.demo;import java.io.UnsupportedEncodingException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;/*** 32位MD5加密算法* @author Mark**/public class MD5{public...
MD5校验工具
12-24
好用的MD5校验工具，
MD5加密32位小写
05-13
这个是以md5加密32位小写具体算法实例。可直接用于云mas的HTTP、和webservice接口。
Oracle中的MD5加密详解
09-10
MD5是我们常用的一种加密方式，在各个方面都有用到这个加密方式，今天我们来探讨下在Oracle中如何使用MD5加密
Python MD5加密实例详解
01-20
详解Python MD5加密 Python 3下MD5加密 # 由于MD5模块在python3中被移除 # 在python3中使用hashlib模块进行md5操作 import hashlib # 待加密信息 str = 'this is a md5 test.' # 创建md5对象 hl = hashlib.md5() #...
Linux命令之MD5校验md5sum
热门推荐
二木成林
05-25 3万+
`md5sum` 用于计算和校验文件的MD5值。
【数据加解密】MD5检验算法的原理及实现
Knight-ZXW的博客
11-14 2437
MD5检验算法的原理及实现 MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 132...
Md5是什么？MD5怎么校验？Md5校验工具怎么用？
学无止境~
04-23 2万+
经常上网下载东西的时候，有看到下载说明软件的MD5数值。也有网友说什么MD5不对什么的，那么Md5是什么？MD5怎么校验？Md5校验工具怎么用？本经验小编跟大家一起来看看MD5到底是什么东西，为什么网上提供的是“7个男人和一个女人的故事”，下载下来却是 “葫芦娃”呢？ 工具/原料 md5校验工具
MD5校验码
程序人生，学海无涯
01-02 2702
这里将介绍什么是MD5校验和如何使用MD5工具进行校验 什么是MD5码？ MD5码是message-digest algorithm 5(信息-摘要算法)的缩写，被广泛用于加密和解密技术上，它可以说是文件的“指纹”。 任何一个文件，无论是可执行程序、图像文件、临时文件或者其他任何类型的文件，也不管体积多大，都有且只有一个独一无二的MD5信息码，并且如果这个文件被修改过，它的MD5码也将随之改
stm32 md5校验
05-12
STM32 MD5校验是指在STM32微控制器中使用MD5算法进行数据校验的方法。MD5校验是一种广泛使用的hash算法，可将任意长度的消息压缩到一个128位的数字指纹中。这种方法可以用于确保数据的完整性和真实性。 STM32芯片可以使用硬件加速来加快MD5校验的过程。在执行MD5算法之前，需要将数据存储在STM32的存储器中，并将其传递给MD5算法处理器。算法处理器能够在极短的时间内计算出数据的数字指纹，从而实现数据的快速校验。 在实际应用中，STM32 MD5校验可以用于各种安全领域的应用，如软件升级、数据传输等。例如，当进行软件升级时，可以使用STM32 MD5校验来确保升级文件的完整性和正确性。此外，STM32 MD5校验还可用于保护数据传输的安全性。在数据传输过程中，可以对传输的数据进行MD5校验，并与接收到的数据进行比对以确保数据的完整性和正确性。 总之，STM32 MD5校验是一种可靠的数据校验方法，可以用于确保数据的完整性和真实性。通过利用硬件加速，还可以实现快速而高效的数据处理，提高应用程序的性能和安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值