md5

最新推荐文章于 2023-06-05 00:00:11 发布
最新推荐文章于 2023-06-05 00:00:11 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 网络编程 文章标签： input output c list 算法 struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aloking/article/details/56719
版权

MD5算法学习笔记

单向散列函数，md表示的是消息摘要，它对输入的消息运算，产生128列散列值，

算法原理

首先填充消息使得数据长度恰好为512的倍数仅小64位的数，条中方法是附一个1在消息的背后，后接所要求的多个0，然后在其后附上64位的消息长度，这两部分的作用是让消息长度恰好等于512位的整数倍，同时确保不同的消息在填充中不相同

 

C语言举例：

--------------------------------------------

 

*/

#ifndef PROTOTYPES

#define PROTOTYPES 0

#endif

typedef unsigned char *POINTER;

typedef unsigned short int UINT2;

typedef unsigned long int UINT4;

#if PROTOTYPES

#define PROTO_LIST(list) list

#else

#define PROTO_LIST(list) ()

#endif

 

---------- MD5.h----------------------------

 

typedef struct {

  UINT4 state[4];        

  UINT4 count[2];      

  unsigned char buffer[64];                      

} MD5_CTX;

 

void MD5Init PROTO_LIST ((MD5_CTX *));

void MD5Update PROTO_LIST

  ((MD5_CTX *, unsigned char *, unsigned int));

void MD5Final PROTO_LIST ((unsigned char [16], MD5_CTX *));

 

※※※※※※※※※MD5C.C※※※※※※※※※※※※※※※※※※※※※※※※

#include "global.h"

#include "md5.h"

#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

 

static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));

static void Encode PROTO_LIST

  ((unsigned char *, UINT4 *, unsigned int));

static void Decode PROTO_LIST

  ((UINT4 *, unsigned char *, unsigned int));

static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));

static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));

 

static unsigned char PADDING[64] = {

  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

};

 

/* 定义F G H I 为四个基数

 

#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) + (UINT4)(ac); /

 (a) = ROTATE_LEFT ((a), (s)); /

 (a) += (b); /

  }

#define GG(a, b, c, d, x, s, ac) { /

 (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); /

 (a) = ROTATE_LEFT ((a), (s)); /

 (a) += (b); /

  }

#define HH(a, b, c, d, x, s, ac) { /

 (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); /

 (a) = ROTATE_LEFT ((a), (s)); /

 (a) += (b); /

  }

#define II(a, b, c, d, x, s, ac) { /

 (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); /

 (a) = ROTATE_LEFT ((a), (s)); /

 (a) += (b); /

  }

 

/*开始进行MD5计算

void MD5Init (context)

MD5_CTX *context;                             

{

  context->count[0] = context->count[1] = 0;

  /* 在这里定义四个常数，也就是我们刚才讲到的四个特征数.

 

  context->state[0] = 0x67452301;

  context->state[1] = 0xefcdab89;

  context->state[2] = 0x98badcfe;

  context->state[3] = 0x10325476;

}

 

void MD5Update (context, input, inputLen)

MD5_CTX *context;                               

unsigned char *input;                           

unsigned int inputLen;                  

{

  unsigned int i, index, partLen;

 

  index = (unsigned int)((context->count[0] >> 3) & 0x3F);

 

  if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3))

 context->count[1]++;

  context->count[1] += ((UINT4)inputLen >> 29);

 

  partLen = 64 - index;

 

  if (inputLen >= partLen) {

 MD5_memcpy

   ((POINTER)&context->buffer[index], (POINTER)input, partLen);

 MD5Transform (context->state, context->buffer);

 

 for (i = partLen; i + 63 < inputLen; i += 64)

   MD5Transform (context->state, &input[i]);

 

 index = 0;

  }

  else

 i = 0;

 

  MD5_memcpy

 ((POINTER)&context->buffer[index], (POINTER)&input[i],

  inputLen-i);

}

 

void MD5Final (digest, context)

unsigned char digest[16];                 

MD5_CTX *context;                              

{

  unsigned char bits[8];

  unsigned int index, padLen;

 

  Encode (bits, context->count, 8);

 

  index = (unsigned int)((context->count[0] >> 3) & 0x3f);

  padLen = (index < 56) ? (56 - index) : (120 - index);

  MD5Update (context, PADDING, padLen);

  MD5Update (context, bits, 8);

 

  Encode (digest, context->state, 16);

  MD5_memset ((POINTER)context, 0, sizeof (*context));

}

 

static void MD5Transform (state, block)

UINT4 state[4];

unsigned char block[64];

{

  UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

 

  Decode (x, block, 64);

 

  /* 第一轮循环 */

  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 */

 

 /* 第二轮循环 */

  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 */

 

  /* 第三轮循环 */

  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 */

 

  /* 第四轮循环 */

  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;

 

  MD5_memset ((POINTER)x, 0, sizeof (x));

 

}

static void Encode (output, input, len)

unsigned char *output;

UINT4 *input;

unsigned int len;

{

  unsigned int i, j;

 

  for (i = 0, j = 0; j < len; i++, j += 4) {

 output[j] = (unsigned char)(input[i] & 0xff);

 output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);

 output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);

 output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);

  }

}

 

static void Decode (output, input, len)

UINT4 *output;

unsigned char *input;

unsigned int len;

{

  unsigned int i, j;

 

  for (i = 0, j = 0; j < len; i++, j += 4)

 output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |

   (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);

}

 

static void MD5_memcpy (output, input, len)

POINTER output;

POINTER input;

unsigned int len;

{

  unsigned int i;

 

  for (i = 0; i < len; i++) output[i] = input[i];

}

 

static void MD5_memset (output, value, len)

POINTER output;

int value;

unsigned int len;

{

  unsigned int i;

 

  for (i = 0; i < len; i++)

 ((char *)output)[i] = (char)value;

}

----------------C代码结束----------

 

aloking
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
md5.min.js文件
02-23
md5.min.js下载
MD5详解
xcxhzjl的博客
12-19 6536
一、介绍 二、特点 三、性质 四、用途 五、算法原理 六、破解 七、MD5较MD4所做的改进
【MD5】什么是MD5？md5的简要描述
No8g攻城狮的博客
06-05 8876
MD5：英文全称是 Message-Digest Algorithm 5。中文名为 消息摘要算法第五版。它是消息摘要算法，属于 Hash 算法的一种。正常情况下，它的结果是一个 长度为32位的16进制的字符串。也有一些地方会用到 16 位的 MD5的结果，它实际上是从 32位 字符串中取中间的第9位到第24位的部分，即长度是 16位。
MD5加密
听海的博客
04-20 4334
MD5加密。
密码加密技术（MD5）
ddccaaxXasac的博客
08-10 4819
md5的全称是md5信息摘要算法（英文：MD5 Message-Digest Algorithm ），一种被广泛使用的密码散列函数，可以产生一个128位（16字节，1字节8位）的散列值（常见的是用32位的16进制表示，比如：0caa3b23b8da53f9e4e041d95dc8fa2c），用于确保信息传输的完整一致。MD5由、、MD2改进而来，主要增强算法复杂度和不可逆性。MD5算法因其普遍、稳定、快速的特点，仍广泛应用于普通数据的加密保护领域。...
go语言加解密算法 md5 sha256
Genius_zz的博客
09-10 3491
MD5 md5介绍 md5的全称为md5信息摘要算法（MD5 Message-Digest Algorithm），是一种被广泛应用的密码散列函数，产生一个128位（16字节）的散列值，最常见的是32位的16进制表示，如：0caa3b23b8da53f9e4e041d95dc8fa2c，用以确保信息传输的完整一致。md5将整个文件当做一个大文本信息，通过不可逆的字符串变换算法，产生一个唯一的md...
md5utils.js
07-02
微信小程序md5.js
jquery.md5.js
06-27
md5加密
md5检测工具
04-14
essage Digest Algorithm MD5（中文名为消息摘要算法第五版）为计算机安全领域广泛使用的一种散列函数，用以提供消息的完整性保护。该算法的文件号为RFC 1321（R.Rivest,MIT Laboratory for Computer Science and ...
excel md5宏
11-23
打开EXCEL，点[工具][加载宏][浏览]，在硬盘中找到您下载的md5宏.xla，选择并勾选"md5宏.xla"； 2、比如A1为密码字串明文列，B1为md5加密列，则在点中B1后点[插入][函数][用户自定义]，选择"Md5_string_Calc...
js md5
04-07
NULL 博文链接：https://zl-go.iteye.com/blog/1564448
工具MD5
03-30
MD5工具测试用的很好用，给测试MAC地址加密，一个MD5理论上的确是可能对应无数多个原文的，因为MD5是有限多个的而原文可以是无数多个。
Java实现MD5
06-23
代码很容易看，比较容易理解。基于Java的MD5算法。
史上最简单的MD5加密
07-13
NULL 博文链接：https://yjck.iteye.com/blog/747125
md5加密算法
LUOZONGW的博客
10-19 9065
理解md5
MD5算法全解析
jsyjst的博客
11-13 4101
前言 这段时间刚好正在做软件安全的实验和课设，学习了各种加密算法，比如对称加密算法的DES,AES；非对称加密算法的RSA,再如今天要讲的主角-单向加密算法的MD5。为什么这么多算法，MD5成为了今天的猪脚呢？，这是因为个人感觉在目前Android开发中MD5算是比较常用的，所以很值得一讲。所以今天让我带你们来全面认识我们的主角MD5。 一、基本概念 1. 单向加密算法 在介绍MD5算法前，很有必...
怎么解密MD5，常见的MD5解密方法，一看就会
热门推荐
ITduo的博客
02-15 3万+
MD5是一种被广泛使用的密码散列函数，曾在计算机安全领域使用很广泛，但是也因为它容易发生碰撞，而被人们认为不安全。那么，MD5应用场景有哪些，我们怎么解密MD5，本文将带大家了解MD5的相关知识，以及比较简单的MD5解密方法。
md5的特点以及加密原理
aoeaoao的博客
08-21 1万+
md5的特点以及加密原理
python MD5
最新发布
09-12
Python的MD5是一种用于加密的哈希算法。在Python中，可以使用hashlib模块来进行MD5操作。通过创建MD5对象，然后使用update方法传入需要加密的字符串，并使用hexdigest方法获取加密后的字符串。例如: import hashlib...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值