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

随机推荐

HZOJ 赤（CF739E Gosha is hunting）
本来没有打算写题解的,时间有点紧.但是这个wqs二分看了好久才明白还是写点东西吧. 题解就直接粘dg的了: 赤(red) 本题来自codeforces 739E,加大了数据范围. 首先对一只猫不会扔两 ...
Streamy障碍二：超大排序合并
Streamy障碍一：大批量条目
CF1054F Electric Scheme
CF1054F Electric Scheme 其实没啥的. 离散化后,每行每列选择一个. 但是可能会相交每行或每列相邻两个点成为一小段. 小段按照行列左右部点小段有交,连inf边,每个s-左, ...
AtCoder Regular Contest 058
这个应该是第一场有英文的atcoder吧??不过题解却没有英文的... 从前往后慢慢做... C こだわり者いろはちゃん / Iroha's Obsession 数据范围这么小,直接暴力 #inclu ...
mysql 字段名和关键字冲突
用"(`)"将有冲突的字段框起来,,键盘上1边上那个键. 例: SELECT * FROM yun_roleright WHERE right LIKE '%{13}%'; 上面s ...
MySQL锁的用法之行级锁
行级锁是MySQL中粒度最小的一种锁,他能大大减少数据库操作的冲突.但是粒度越小,实现的成本也越高.MYISAM引擎只支持表级锁,而INNODB引擎能够支持行级锁,下面的内容也是针对INNOD ...
oracle函数 ABS(x)
[功能]返回x的绝对值 [参数]x,数字型表达式 [返回]数字 [示例] select abs(100),abs(-100) from dual; sign(x) [功能]返回x的正负值 [参数]x, ...
H3C 广播风暴
Android TextView点击效果
在Android开发中,我们有时候需要单独的点击某一段文本,如图所示: 如上图,我们要求点击新用户注册这个TextView,为了有更好的用户体验,我们肯定要设置该TextView的点击效果.下面介绍如 ...

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

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

随机推荐

热门专题