基于STM32的MD5校验

[复制链接]

STMCU小助手发布时间：2022-11-30 14:00

技术帖
文章封面:
文章简介:	基于STM32的MD5校验

引言

我们在嵌入式及单片机的产品开发时，往往需要对一些文件进行检验，来保证此文件是在传输的过程没有被修改或者损坏。比如IAP升级程序时，往往就需要对升级固件进行校验。MD5是其中非常常用的一种检验方式。本文通过使用MD5检验程序，对STM32的Flash中的某一段数据进行检验，检验后存放到字符串里，可用来比对或者输出。

/ C0 ~* |1 i* H# `% r5 [; \2 W: z

介绍MD5简介及使用场景

MD5校验（checksum）是通过对接收的传输数据执行散列运算来检查数据的正确性。一个散列函数，比如 MD5，是一个将任意长度的数据字符串转化成短的固定长度的值的单向操作。任意两个字符串不应有相同的散列值（即，有“很大可能”是不一样的，并且要人为地创造出来两个散列值相同的字符串应该是困难的）。
0 b1 `0 K" K. G# a+ O7 ]: G) n4 h一个 MD5 校验和（checksum）通过对接收的传输数据执行散列运算来检查数据的正确性。计算出的散列值拿来和随数据传输的散列值比较。如果两个值相同，说明传输的数据完整无误、没有被窜改过（前提是散列值没有被窜改），从而可以放心使用。+ R W) r* e6 {4 R) F4 J" R4 ]
MD5校验可以应用多个领域，比如说机密资料的检验，下载文件的检验，明文密码的加密等。

" X- `6 g% G5 ~8 R$ ?* W

MD5原理

MD5的加密过程，整体来看，就是先定义四个值，然后用这四个值，对原文信息进行计算，并得到新的四个值，然后再对原文进行计算，再得到新的四个值，如此循环一定次数，最终对最后的这四个值进行简单的字符串拼接，就得到了最终的密文。8 ?% X+ d6 V& B6 A5 E7 D8 ?" z
主要就是下面这3步：

填补信息6 F; [; Y/ }, y7 j+ A
用原文长度位数对512求余，如果结果不为448，就填充到448位。填充是第一位填1，后面填0。512-448=64，用这剩余的64位，记录原文长度。( ^6 v! C x% M0 I2 `
最终得到一个填补完的信息（总长=原文长度+512位）
拿到初始值3 O! [0 Z4 E1 ~# \) e
四个初始值，是MD5这个算法提前定义好的，分别是4个32位的值，总共刚好128位。
, v8 ]# b' }! R# H: x* @: L我们用ABCD命名：
! y( i( ^& s/ d4 CA=0xefcdab89
+ P2 l# k* Q3 }; p5 C/ XB=0x89ABCDEF" k. v: i) d1 m
C=0x98badcfe
" @7 e4 |$ S& T, N9 J5 c; jD=0x103254769 W! N8 g5 Q) x r8 W, ?6 t+ d! T
3、真正的计算
& `8 L% x% T' R( x! P. B' x8 c4 K计算分为多次循环，每次循环，都是用ABCD和原文在第一步填补完的信息，进行计算，最终得到新的ABCD。最后将最后一次ABCD拼成字符串，就是最终的密文。 ~) T; |- }8 J
循环先分为主循环，每个主循环中又套有子循环。
! u( q! |) w8 D主循环次数 = 原文长度/512。" _" d9 Q' t* S% L/ D
子循环次数 = 64次。
$ L0 S: x2 `" X; W3 P2 i! W
$ W9 H# z7 t. H2 I2 j: L: E0 G

软件实现

网络上的MD5检验程序有很多，但实现在STM32上的其实并没有几个能用的。本文的程序为我自主编写，并检验使用过的。

压缩函数

a = A, b = B, c = C, d = D;
* `- m9 ^( L2 o" y8 S
FF(a, b, c, d, x[0, 7, 0xd76aa478); P+ e% j! @# d" ?" @* E3 N
FF(d, a, b, c, x[1, 12, 0xe8c7b756);$ J1 [& i& I I, S# a3 G. E
FF(c, d, a, b, x[2, 17, 0x242070db);
6 g7 w" B: w. V* d7 a# w
FF(b, c, d, a, x[3, 22, 0xc1bdceee);: J0 P+ [/ ~, `) {# ^: M
FF(a, b, c, d, x[4, 7, 0xf57c0faf);
/ Y- n; J7 d5 i3 B# Z! v
FF(d, a, b, c, x[5, 12, 0x4787c62a);
* Z5 _% N$ r0 J% x; t1 p5 [2 J2 p3 ^
FF(c, d, a, b, x[6, 17, 0xa8304613);
$ H4 ]5 `0 u1 y% H; }
FF(b, c, d, a, x[7, 22, 0xfd469501);
! D3 D# `& Z" X" e: X. c6 O4 ~
FF(a, b, c, d, x[8, 7, 0x698098d8);
* a% a& [2 u8 o- }% N. ^4 j. E
FF(d, a, b, c, x[9, 12, 0x8b44f7af);7 {0 Q" `7 M# y V
FF(c, d, a, b, x[10, 17, 0xffff5bb1);6 t4 I% E Q. q/ m; G
FF(b, c, d, a, x[11, 22, 0x895cd7be);5 ]. g6 N ]% R8 x( _1 `
FF(a, b, c, d, x[12, 7, 0x6b901122);! h& B; D2 U1 D2 F5 y% J
FF(d, a, b, c, x[13, 12, 0xfd987193);+ M) q8 @2 u& V" {9 w ?+ W. p
FF(c, d, a, b, x[14, 17, 0xa679438e);% T P& D* n/ [5 B( P
FF(b, c, d, a, x[15, 22, 0x49b40821);+ H/ ]- E3 u# c
9 ?5 B/ D) K/ g( @6 \! P D
GG(a, b, c, d, x[1, 5, 0xf61e2562); {6 v& O7 {; e8 D; i* t
GG(d, a, b, c, x[6, 9, 0xc040b340);
5 A$ w/ J' I- b# i o m4 r4 B
GG(c, d, a, b, x[11, 14, 0x265e5a51);# ?6 f; z- U4 ?- j1 y. u
GG(b, c, d, a, x[0, 20, 0xe9b6c7aa);* s, v q+ q3 ]9 k( ?4 p0 j
GG(a, b, c, d, x[5, 5, 0xd62f105d);
, ^" l- R& Z" k% }0 Z2 l; }
GG(d, a, b, c, x[10, 9, 0x02441453);$ ]2 t' [( _" g
GG(c, d, a, b, x[15, 14, 0xd8a1e681);
- f+ W) _# s# x1 H9 `. B
GG(b, c, d, a, x[4, 20, 0xe7d3fbc8);: Y/ g" B) c* A! s# D
GG(a, b, c, d, x[9, 5, 0x21e1cde6);- W) ]+ ?6 [/ N- O6 H% ]
GG(d, a, b, c, x[14, 9, 0xc33707d6);6 g0 q, y& y5 b9 R, ]) W
GG(c, d, a, b, x[3, 14, 0xf4d50d87);
5 T* U9 T% o2 S$ t: l. }$ Y# W
GG(b, c, d, a, x[8, 20, 0x455a14ed);
8 |( ~! b y3 y) g
GG(a, b, c, d, x[13, 5, 0xa9e3e905);
3 g9 {6 @) c% x6 a/ A4 ^
GG(d, a, b, c, x[2, 9, 0xfcefa3f8);
; x( G" O/ `/ X9 J0 a$ S
GG(c, d, a, b, x[7, 14, 0x676f02d9);
! r n2 G8 a8 c/ M a! [
GG(b, c, d, a, x[12, 20, 0x8d2a4c8a);
" V3 A/ @' |# L m6 U
5 t$ q. h2 c% g# h+ @7 y
HH(a, b, c, d, x[5, 4, 0xfffa3942);
3 B/ l3 t1 X2 N) o+ r* a0 Q
HH(d, a, b, c, x[8, 11, 0x8771f681); h0 s; f; c" H& c
HH(c, d, a, b, x[11, 16, 0x6d9d6122);
2 N! j6 O* D2 V& p
HH(b, c, d, a, x[14, 23, 0xfde5380c);: R$ d8 Z& r! ?, }% A
HH(a, b, c, d, x[1, 4, 0xa4beea44);5 [$ ?8 @! H' `' M8 b/ C2 l
HH(d, a, b, c, x[4, 11, 0x4bdecfa9);4 g6 N# o( w# ^% r! u! O
HH(c, d, a, b, x[7, 16, 0xf6bb4b60);- b4 w/ W; P4 ~; K+ O- u
HH(b, c, d, a, x[10, 23, 0xbebfbc70);
9 _' k# `$ w! s# G- z# H
HH(a, b, c, d, x[13, 4, 0x289b7ec6);
6 A0 l1 ]) a# N- `9 J' s, ]$ m
HH(d, a, b, c, x[0, 11, 0xeaa127fa);9 T. L! p" g) i8 I. }
HH(c, d, a, b, x[3, 16, 0xd4ef3085);/ t# T" l9 v9 _, @
HH(b, c, d, a, x[6, 23, 0x04881d05);0 I. B8 z" s- d, N
HH(a, b, c, d, x[9, 4, 0xd9d4d039);% G9 n8 s- \1 N
HH(d, a, b, c, x[12, 11, 0xe6db99e5);
8 a, K( H% K( ]6 s& m
HH(c, d, a, b, x[15, 16, 0x1fa27cf8);
9 I/ ^, y; ^ R& f% n2 p. n/ ]& `
HH(b, c, d, a, x[2, 23, 0xc4ac5665);
+ G( x# ^+ T" g9 y$ q( w; L) k
% ?- u3 N, M/ b2 ?8 T2 V
II(a, b, c, d, x[0, 6, 0xf4292244);
% C. S/ g9 J" a; J+ C
II(d, a, b, c, x[7, 10, 0x432aff97);
5 `' o& u; `' ~5 y; Z Z
II(c, d, a, b, x[14, 15, 0xab9423a7);
" Q9 _" y7 u8 G( \
II(b, c, d, a, x[5, 21, 0xfc93a039);/ r) v9 i) w1 z4 @! q! v
II(a, b, c, d, x[12, 6, 0x655b59c3);
4 E9 @* i" J; V7 y: d- H
II(d, a, b, c, x[3, 10, 0x8f0ccc92); F1 H+ W; ?1 V; E6 [
II(c, d, a, b, x[10, 15, 0xffeff47d);
- y1 a: x9 L5 ?' F; J7 q
II(b, c, d, a, x[1, 21, 0x85845dd1);
+ O2 z3 o& g& J, u! F4 J, ]
II(a, b, c, d, x[8, 6, 0x6fa87e4f);
, p. ]+ V7 e/ ~ x# K5 ~' k i T
II(d, a, b, c, x[15, 10, 0xfe2ce6e0);
n6 [% Q0 i: O$ D N
II(c, d, a, b, x[6, 15, 0xa3014314);1 ^3 z, N$ y' ]4 K9 b# }+ ]/ l6 E
II(b, c, d, a, x[13, 21, 0x4e0811a1);
3 W" `; O9 B |% O" S+ v! \
II(a, b, c, d, x[4, 6, 0xf7537e82);8 H! M7 \! g; _1 ~! ]# D
II(d, a, b, c, x[11, 10, 0xbd3af235);
0 i% i8 I8 y& ^4 M
II(c, d, a, b, x[2, 15, 0x2ad7d2bb);
$ R9 F' X* V# | c4 ^- ^. Y
II(b, c, d, a, x[9, 21, 0xeb86d391);
& u1 [7 x( Z& S
% T$ R$ O- t# z, `' W
A += a;9 j" I9 p1 ^1 y
B += b;: L' U8 ^0 K2 O0 c) V# G
C += c;
0 P, @* R) V" h* [6 o! a
D += d;

复制代码

分组读取

uint8_t j, k;5 Q% n4 C; }% C7 k
$ ]) d0 \ x2 Z! V& h
memset(x, 0, 64);) W. E) M' t3 i% U6 {( F
ulSampleIndex = 0;0 ^/ M+ D, Z& W, \: G
for (j = 0; j < 16; j++)$ n2 ?/ `$ p4 a! z
{9 k5 e( ?+ q- X
for (k = 0; k < 4; k++)! v9 W5 ^9 i) L* D8 z
{
: l% z- `% A$ X2 B
if ((ulReadCnt >= ulFlieLength / 1024) && (ulDataIndex >= ulFlieLength % 1024))" h2 ]: f; C! |5 ]/ u" s2 F
break;
$ a5 T) j+ e! G' @$ k) K
((char *)x)[ulSampleIndex = ucaFlashBuf[ulDataIndex;
2 a6 n+ j; ] X) {* V8 f
ulDataIndex++;, G7 a% }( v: x
ulSampleIndex++;
8 [( v2 Q$ I( g. |0 A& j7 E
}' i1 g, |2 ?* t2 O( s0 N
}
E' J3 M4 J# s

复制代码

应用函数

uint16_t usCnt = 0;+ \5 g5 M$ S* U, y, v# L% G
uint32_t ulFileLen[2 = {0};. ]4 i( J$ ]0 y1 U* }
/* 计算整数部分 */
) t2 d, @' Y B6 L: Y7 R3 [
for (ulReadCnt = 0; ulReadCnt < ulFlieLength / 1024; ulReadCnt++)5 ? P. s% i- s- V6 n5 k. L
{1 m/ T9 p( U i; t
读取你的文件的 1024字节;
) ~6 M# e2 ^' h6 N
ulFlashAdd += 1024;
/ A$ h* p# j+ V" U2 b1 u u
for (usCnt = 0; usCnt < 16; usCnt++)8 L) m' L4 H4 o! Q! d
{+ s; [* Q5 H8 N( w9 @
ReadGroupTempBuf(ulFlieLength);( k# V# p6 w9 {( C; m0 E
MD5();2 f5 W4 ^. L1 O9 o+ W
}
- d3 d9 o4 M5 E7 c* ]; w6 p4 `
ulDataIndex = 0;% e; o: f4 U2 i. L) Z
}
1 {$ V8 ~ w! W# T- U [
/* 计算余数部分 */- `+ J L: G5 W8 o
memset(ucaFlashBuf, 0, 1025);+ m, s) q1 ` V& j
读取你的文件的文件长度对 1024取余后除以2个字节; K& B- D# e( i# J# y0 n/ f
ReadGroupTempBuf(ulFlieLength);3 P& I L/ V: x; `1 Y' B
for (usCnt = 0; usCnt < (ulFlieLength % 1024) / 64; usCnt++)
: ]! n; K$ N/ f4 n7 _
{" A9 t. |/ P0 k v. R
MD5();
* d" r# ]3 `0 b
ReadGroupTempBuf(ulFlieLength);
+ y4 ^. K% m7 i$ V- e C
}. @8 _! e, _/ i" b
/* 文件结束补1,补0操作,128二进制即10000000 */3 k% l" t# [ y' q0 H! N# d
((char *)x)[ulFlieLength % 64 = 128;$ h1 g( r% C: A8 Y8 ~
if (ulFlieLength % 64 > 55)! A! p9 ?0 x+ L6 ?! O+ l9 J
{
4 _0 u" {2 a, W8 M
MD5(), memset(x, 0, 64);8 u# u$ I7 g6 \+ r1 J
}/ B! Q" ^ G0 X0 F5 f+ }, Z' ]
/* 文件末尾加入原文件的bit长度 */ o) e1 I/ o T) o% |: [
ulFileLen[1 = ulFlieLength / 0x20000000;
, p* L* I$ _5 X+ v
ulFileLen[0 = (ulFlieLength % 0x20000000) * 8;: W# U6 s# @5 r6 s( ~ T- I
memcpy(x + 14, ulFileLen, 8);
! _: `4 E4 y/ w, h2 b3 q$ y
MD5();3 y6 O# R2 h. O, \( D
sprintf(pEsult, "%08X%08X%08X%08X", PP(A), PP(B), PP(C), PP(D));