VC++取MD5算法记录下以后用得到（转）

这个是网上扒下来的作者已经无法知道是谁了

MD5.h

 #ifndef MD5_H

 #define MD5_H 

 #include <string>

 #include <fstream> 

 /* Type define */

 typedef unsigned char byte;

 typedef unsigned int uint32;

 typedef unsigned int uint4;

 using std::string;

 using std::ifstream;

 /* MD5 declaration. */

 class MD5 {

 public:

     MD5();

     MD5(const void *input, size_t length);

     MD5(const string &str);

     MD5(ifstream &in);

     void update(const void *input, size_t length);

     void update(const string &str);

     void update(ifstream &in);

     const byte* digest();

     string toString();

     void reset();

     inline uint4 rotate_left(uint4 x, int n);

     inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);

     inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);

     inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);

     inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);

 private:

     void update(const byte *input, size_t length);

     void final();

     void transform(const byte block[]);

     void encode(const uint32 *input, byte *output, size_t length);

     void decode(const byte *input, uint32 *output, size_t length);

     string bytesToHexString(const byte *input, size_t length);

     /* class uncopyable */

     MD5(const MD5&);

     MD5& operator=(const MD5&);

 private:

     uint32 _state[]; /* state (ABCD) */

     uint32 _count[]; /* number of bits, modulo 2^64 (low-order word first) */

     byte _buffer[]; /* input buffer */

     byte _digest[]; /* message digest */

     bool _finished; /* calculate finished ? */

     static const byte PADDING[]; /* padding for calculate */

     static const char HEX[];

     static const size_t BUFFER_SIZE = ;

 };

 string FileDigest(const string &file);

 #endif/*MD5_H*/

MD5.cpp

 #include "md5.h" 

 using namespace std;

 /* Constants for MD5Transform routine. */

 #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 

 /* F, G, H and I are basic MD5 functions.

 */

 #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)))) 

 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.

 Rotation is separate from addition to prevent recomputation.

 */

 //#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); \

 //}

 inline uint4 MD5::rotate_left(uint4 x, int n) {

     return (x << n) | (x >> ( - n));

 }

 inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {

     a = rotate_left(a + F(b, c, d) + x + ac, s) + b;

 }

 inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {

     a = rotate_left(a + G(b, c, d) + x + ac, s) + b;

 }

 inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {

     a = rotate_left(a + H(b, c, d) + x + ac, s) + b;

 }

 inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {

     a = rotate_left(a + I(b, c, d) + x + ac, s) + b;

 }

 const byte MD5::PADDING[] = { 0x80 };

 const char MD5::HEX[] = {

     '', '', '', '',

     '', '', '', '',

     '', '', 'a', 'b',

     'c', 'd', 'e', 'f'

 };

 /* Default construct. */

 MD5::MD5() {

     reset();

 }

 /* Construct a MD5 object with a input buffer. */

 MD5::MD5(const void *input, size_t length) {

     reset();

     update(input, length);

 }

 /* Construct a MD5 object with a string. */

 MD5::MD5(const string &str) {

     reset();

     update(str);

 }

 /* Construct a MD5 object with a file. */

 MD5::MD5(ifstream &in) {

     reset();

     update(in);

 }

 /* Return the message-digest */

 const byte* MD5::digest() {

     if (!_finished) {

         _finished = true;

         final();

     }

     return _digest;

 }

 /* Reset the calculate state */

 void MD5::reset() {

     _finished = false;

     /* reset number of bits. */

     _count[] = _count[] = ;

     /* Load magic initialization constants. */

     _state[] = 0x67452301;

     _state[] = 0xefcdab89;

     _state[] = 0x98badcfe;

     _state[] = 0x10325476;

 }

 /* Updating the context with a input buffer. */

 void MD5::update(const void *input, size_t length) {

     update((const byte*)input, length);

 }

 /* Updating the context with a string. */

 void MD5::update(const string &str) {

     update((const byte*)str.c_str(), str.length());

 }

 /* Updating the context with a file. */

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

             update(buffer, length);

     }

     in.close();

 }

 /* MD5 block update operation. Continues an MD5 message-digest

 operation, processing another message block, and updating the

 context.

 */

 void MD5::update(const byte *input, size_t length) {

     uint32 i, index, partLen;

     _finished = false;

     /* Compute number of bytes mod 64 */

     index = (uint32)((_count[] >> ) & 0x3f);

     /* update number of bits */

     if ((_count[] += ((uint32)length << )) < ((uint32)length << ))

         _count[]++;

     _count[] += ((uint32)length >> );

     partLen =  - index;

     /* transform as many times as possible. */

     if (length >= partLen) {

         memcpy(&_buffer[index], input, partLen);

         transform(_buffer);

         for (i = partLen; i +  < length; i += )

             transform(&input[i]);

         index = ;

     }

     else {

         i = ;

     }

     /* Buffer remaining input */

     memcpy(&_buffer[index], &input[i], length - i);

 }

 /* MD5 finalization. Ends an MD5 message-_digest operation, writing the

 the message _digest and zeroizing the context.

 */

 void MD5::final() {

     byte bits[];

     uint32 oldState[];

     uint32 oldCount[];

     uint32 index, padLen;

     /* Save current state and count. */

     memcpy(oldState, _state, );

     memcpy(oldCount, _count, );

     /* Save number of bits */

     encode(_count, bits, );

     /* Pad out to 56 mod 64. */

     index = (uint32)((_count[] >> ) & 0x3f);

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

     update(PADDING, padLen);

     /* Append length (before padding) */

     update(bits, );

     /* Store state in digest */

     encode(_state, _digest, );

     /* Restore current state and count. */

     memcpy(_state, oldState, );

     memcpy(_count, oldCount, );

 }

 /* MD5 basic transformation. Transforms _state based on block. */

 void MD5::transform(const byte block[]) {

     uint32 a = _state[], b = _state[], c = _state[], d = _state[], x[];

     decode(block, x, );

     /* Round 1 */

     FF(a, b, c, d, x[], S11, 0xd76aa478); /* 1 */

     FF(d, a, b, c, x[], S12, 0xe8c7b756); /* 2 */

     FF(c, d, a, b, x[], S13, 0x242070db); /* 3 */

     FF(b, c, d, a, x[], S14, 0xc1bdceee); /* 4 */

     FF(a, b, c, d, x[], S11, 0xf57c0faf); /* 5 */

     FF(d, a, b, c, x[], S12, 0x4787c62a); /* 6 */

     FF(c, d, a, b, x[], S13, 0xa8304613); /* 7 */

     FF(b, c, d, a, x[], S14, 0xfd469501); /* 8 */

     FF(a, b, c, d, x[], S11, 0x698098d8); /* 9 */

     FF(d, a, b, c, x[], S12, 0x8b44f7af); /* 10 */

     FF(c, d, a, b, x[], S13, 0xffff5bb1); /* 11 */

     FF(b, c, d, a, x[], S14, 0x895cd7be); /* 12 */

     FF(a, b, c, d, x[], S11, 0x6b901122); /* 13 */

     FF(d, a, b, c, x[], S12, 0xfd987193); /* 14 */

     FF(c, d, a, b, x[], S13, 0xa679438e); /* 15 */

     FF(b, c, d, a, x[], S14, 0x49b40821); /* 16 */

                                             /* Round 2 */

     GG(a, b, c, d, x[], S21, 0xf61e2562); /* 17 */

     GG(d, a, b, c, x[], S22, 0xc040b340); /* 18 */

     GG(c, d, a, b, x[], S23, 0x265e5a51); /* 19 */

     GG(b, c, d, a, x[], S24, 0xe9b6c7aa); /* 20 */

     GG(a, b, c, d, x[], S21, 0xd62f105d); /* 21 */

     GG(d, a, b, c, x[], S22, 0x2441453); /* 22 */

     GG(c, d, a, b, x[], S23, 0xd8a1e681); /* 23 */

     GG(b, c, d, a, x[], S24, 0xe7d3fbc8); /* 24 */

     GG(a, b, c, d, x[], S21, 0x21e1cde6); /* 25 */

     GG(d, a, b, c, x[], S22, 0xc33707d6); /* 26 */

     GG(c, d, a, b, x[], S23, 0xf4d50d87); /* 27 */

     GG(b, c, d, a, x[], S24, 0x455a14ed); /* 28 */

     GG(a, b, c, d, x[], S21, 0xa9e3e905); /* 29 */

     GG(d, a, b, c, x[], S22, 0xfcefa3f8); /* 30 */

     GG(c, d, a, b, x[], S23, 0x676f02d9); /* 31 */

     GG(b, c, d, a, x[], S24, 0x8d2a4c8a); /* 32 */

                                             /* Round 3 */

     HH(a, b, c, d, x[], S31, 0xfffa3942); /* 33 */

     HH(d, a, b, c, x[], S32, 0x8771f681); /* 34 */

     HH(c, d, a, b, x[], S33, 0x6d9d6122); /* 35 */

     HH(b, c, d, a, x[], S34, 0xfde5380c); /* 36 */

     HH(a, b, c, d, x[], S31, 0xa4beea44); /* 37 */

     HH(d, a, b, c, x[], S32, 0x4bdecfa9); /* 38 */

     HH(c, d, a, b, x[], S33, 0xf6bb4b60); /* 39 */

     HH(b, c, d, a, x[], S34, 0xbebfbc70); /* 40 */

     HH(a, b, c, d, x[], S31, 0x289b7ec6); /* 41 */

     HH(d, a, b, c, x[], S32, 0xeaa127fa); /* 42 */

     HH(c, d, a, b, x[], S33, 0xd4ef3085); /* 43 */

     HH(b, c, d, a, x[], S34, 0x4881d05); /* 44 */

     HH(a, b, c, d, x[], S31, 0xd9d4d039); /* 45 */

     HH(d, a, b, c, x[], S32, 0xe6db99e5); /* 46 */

     HH(c, d, a, b, x[], S33, 0x1fa27cf8); /* 47 */

     HH(b, c, d, a, x[], S34, 0xc4ac5665); /* 48 */

                                            /* Round 4 */

     II(a, b, c, d, x[], S41, 0xf4292244); /* 49 */

     II(d, a, b, c, x[], S42, 0x432aff97); /* 50 */

     II(c, d, a, b, x[], S43, 0xab9423a7); /* 51 */

     II(b, c, d, a, x[], S44, 0xfc93a039); /* 52 */

     II(a, b, c, d, x[], S41, 0x655b59c3); /* 53 */

     II(d, a, b, c, x[], S42, 0x8f0ccc92); /* 54 */

     II(c, d, a, b, x[], S43, 0xffeff47d); /* 55 */

     II(b, c, d, a, x[], S44, 0x85845dd1); /* 56 */

     II(a, b, c, d, x[], S41, 0x6fa87e4f); /* 57 */

     II(d, a, b, c, x[], S42, 0xfe2ce6e0); /* 58 */

     II(c, d, a, b, x[], S43, 0xa3014314); /* 59 */

     II(b, c, d, a, x[], S44, 0x4e0811a1); /* 60 */

     II(a, b, c, d, x[], S41, 0xf7537e82); /* 61 */

     II(d, a, b, c, x[], S42, 0xbd3af235); /* 62 */

     II(c, d, a, b, x[], S43, 0x2ad7d2bb); /* 63 */

     II(b, c, d, a, x[], S44, 0xeb86d391); /* 64 */

     _state[] += a;

     _state[] += b;

     _state[] += c;

     _state[] += d;

 }

 /* Encodes input (ulong) into output (byte). Assumes length is

 a multiple of 4.

 */

 void MD5::encode(const uint32 *input, byte *output, size_t length) {

     for (size_t i = , j = ; j<length; i++, j += ) {

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

         output[j + ] = (byte)((input[i] >> ) & 0xff);

         output[j + ] = (byte)((input[i] >> ) & 0xff);

         output[j + ] = (byte)((input[i] >> ) & 0xff);

     }

 }

 /* Decodes input (byte) into output (ulong). Assumes length is

 a multiple of 4.

 */

 void MD5::decode(const byte *input, uint32 *output, size_t length) {

     for (size_t i = , j = ; j<length; i++, j += ) {

         output[i] = ((uint32)input[j]) | (((uint32)input[j + ]) << ) |

             (((uint32)input[j + ]) << ) | (((uint32)input[j + ]) << );

     }

 }

 /* Convert byte array to hex string. */

 string MD5::bytesToHexString(const byte *input, size_t length) {

     string str;

     str.reserve(length << );

     for (size_t i = ; i < length; i++) {

         int t = input[i];

         int a = t / ;

         int b = t % ;

         str.append(, HEX[a]);

         str.append(, HEX[b]);

     }

     return str;

 }

 /* Convert digest to string value */

 string MD5::toString() {

     return bytesToHexString(digest(), );

 }

 //得到二进制文件的MD5码

 string FileDigest(const string &file) {

     ifstream in(file.c_str(), ios::binary);

     if (!in)

         return "";

     MD5 md5;

     md5.reset();

     std::streamsize length;

     char buffer[];

     while (!in.eof()) {

         in.read(buffer, );

         length = in.gcount();

         if (length > )

             md5.update(buffer, length);

     }

     in.close();

     return md5.toString();

 }

调用main.cpp

 // Md5Test.cpp : 定义控制台应用程序的入口点。

 //

 #include "stdafx.h"

 #include "MD5.h"

 #include <fstream>

 #include <process.h>

 int main()

 {

     std::ifstream of("ReadMe.txt", std::ios::in | std::ios::binary);

     if (!of.is_open())return ;

     MD5 fileMd5(of);

     printf("%s\r\n", fileMd5.toString().c_str());

     MD5 strMd5("");

     printf("%s\r\n", strMd5.toString().c_str());

     system("pause");

     return ;

 }

VC++取MD5算法记录下以后用得到（转）的更多相关文章

在MAC平台下编译Ngnix ，由于MD5算法不能编译通过解决办法
近期想学习Ngnix 代码,前些日子,对”自己下手狠一次“, 买了MAC 本. 所以想在Mac 上编译,是必须的,不然对不起自己的内心. 不巧遇到了MD5算法编译的问题 src/core/ngx_cr ...
信息摘要算法之一：MD5算法解析及实现
MD5即Message-Digest Algorithm 5(信息-摘要算法5),用于确保信息传输完整一致.是计算机广泛使用的杂凑算法之一(又译摘要算法.哈希算法),主流编程语言普遍已有MD5实现. ...
MD5算法解析
MD5的全称是Message-Digest Algorithm 5,在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明,经MD2.MD3和MD4发展而来. MD5将 ...
【密码学】MD5算法原理
MD5(单向散列算法)的全称是Message-Digest Algorithm 5(信息-摘要算法),经MD2.MD3和MD4发展而来.MD5算法的使用不需要支付任何版权费用. MD5功能: 输 ...
【编程开发】MD5算法原理
MD5(单向散列算法)的全称是Message-Digest Algorithm 5(信息-摘要算法),经MD2.MD3和MD4发展而来.MD5算法的使用不需要支付任何版权费用. MD5功能: ...
经常使用MD5算法代码
经常使用的MD5算法代码日期: 2014年8月4日作者: 铁锚 MD5,全称为 Message Digest Algorithm 5(消息摘要算法第五版).详情请參考维基百科:MD5 MD5加密后 ...
MD5算法的原理与实现
***********************************************声明************************************************ 原创 ...
MD5算法学习整理
一路学来记得笔记不少但是给自己看当时就记得很随意以为后面都懂但还是太单纯了,现在回顾自己都完全看不下去,所以以后的都放的博客上,让自己看懂,让感兴趣的看懂,详细,暴力不废话了 MD5算法 ...
MD5 算法
MD5 Message Digest Algorithm MD5(中文名为消息摘要算法第五版)为计算机安全领域广泛使用的一种散列函数,用以提供消息的完整性保护.该算法的文件号为RFC 1321(R. ...

随机推荐

jQuery 加法计算使用+号即强转类型
var value1 = $("#txt1").val(); var value2 = $("#txt2").val(); //数值前添加+号 number加号 ...
Git 进阶：10大技巧让你迅速提升
1.Git自动补全假使你使用命令行工具运行Git命令,那么每次手动输入各种命令是一件很令人厌烦的事情. 命令: cd ~ curl https://raw.github.com/git/git/ma ...
mysql 表名和字段、备注
select t1.table_schema ,t1.table_name ,t2.ordinal_position ,t2.column_name ,t2.data_type ,t2.charact ...
HDFS概念名称节点和数据节点-名称节点-文件系统元数据的持久状态
es6 set简析
1.数据结构Set类似于数组,但是成员的值都是唯一的,没有重复的值. var s = new Set(); [,,,,,,].map(x => s.add(x)) for (i of s) {d ...
从遇见到信任 | Apache Dubbo 的毕业之旅
所谓信任,就是多一次机会. 2018年2月16日,Apache Dubbo 加入 Apache 基金会孵化器. ... 2019年5月16日,Apache 软件基金会董事会决议通过了 Apache D ...
uva 11665 Chinese Ink (几何+并查集)
UVA 11665 随便给12的找了一道我没做过的几何基础题.这题挺简单的,不过uva上通过率挺低,通过人数也不多. 题意是要求给出的若干多边形组成多少个联通块.做的时候要注意这题是不能用double ...
随机线性网络编码的C语言实现，实现可靠传输：原理（1）
线性方程组,大家都不陌生吧.来一组 A11 *X1 + A12 *X2 + A13 *X3 + A14 *X4 =Q1 A21 *X1 + A22 *X2 + A23 *X3 + A24 *X4 =Q ...
hdu 1050 Moving Tables (Greedy)
Problem - 1050 过两天要给12的讲贪心,于是就做一下水贪心练习练习. 代码如下: #include <cstdio> #include <iostream> #i ...
1、Dapper介绍
1.Dapper是一个轻量级的O/R框架,性能强劲,支持原生sql与模型对象混合写法,通过DapperExtension插件可以实现纯模型的操作(零Sql)语句. 2.创建VS 项目,添加相关的依赖包 ...

VC++取MD5算法记录下以后用得到（转）

VC++取MD5算法记录下以后用得到（转）的更多相关文章

随机推荐

热门专题