梦殇国际

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
热搜: 刷粉
月光下载 云刷粉软件 云刷粉网页 水贴机电脑版 安卓软件 梦殇导航(教程集合) 有任何问题请点击提问
查看: 846|回复: 15
打印 上一主题 下一主题

[其他] C++ MD5算法

[复制链接]

229

帖子

3356

积分

5万

TBS

UID
549
积分
3356
TBS
51673
智商
1538
节操
1531
海贝
1
阅读权限
60
在线时间
147 小时
注册时间
2014-1-3
最后登录
2015-6-23
跳转到指定楼层
1
发表于 2014-4-21 18:29:26 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
先创建一个类叫做MD5生成md5.cpp与头文件md5.h

资源文件的代码如下:
#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); \
}


const byte MD5::PADDING[64] = { 0x80 };
const char MD5::HEX[16] = {
        '0', '1', '2', '3',
        '4', '5', '6', '7',
        '8', '9', '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[0] = _count[1] = 0;
        /* Load magic initialization constants. */
        _state[0] = 0x67452301;
        _state[1] = 0xefcdab89;
        _state[2] = 0x98badcfe;
        _state[3] = 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 > 0)
                        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) {

        ulong i, index, partLen;

        _finished = false;

        /* Compute number of bytes mod 64 */
        index = (ulong)((_count[0] >> 3) & 0x3f);

        /* update number of bits */
        if((_count[0] += ((ulong)length << 3)) < ((ulong)length << 3))
                _count[1]++;
        _count[1] += ((ulong)length >> 29);

        partLen = 64 - index;

        /* transform as many times as possible. */
        if(length >= partLen) {

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

                for (i = partLen; i + 63 < length; i += 64)
                        transform(&input[i]);
                index = 0;

        } else {
                i = 0;
        }

        /* 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[8];
        ulong oldState[4];
        ulong oldCount[2];
        ulong index, padLen;

        /* Save current state and count. */
        memcpy(oldState, _state, 16);
        memcpy(oldCount, _count, 8);

        /* Save number of bits */
        encode(_count, bits, 8);

        /* Pad out to 56 mod 64. */
        index = (ulong)((_count[0] >> 3) & 0x3f);
        padLen = (index < 56) ? (56 - index) : (120 - index);
        update(PADDING, padLen);

        /* Append length (before padding) */
        update(bits, 8);

        /* Store state in digest */
        encode(_state, _digest, 16);

        /* Restore current state and count. */
        memcpy(_state, oldState, 16);
        memcpy(_count, oldCount, 8);
}

/* MD5 basic transformation. Transforms _state based on block. */
void MD5::transform(const byte block[64]) {

        ulong a = _state[0], b = _state[1], c = _state[2], d = _state[3], x[16];

        decode(block, x, 64);

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

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

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

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

/* Encodes input (ulong) into output (byte). Assumes length is
a multiple of 4.
*/
void MD5::encode(const ulong *input, byte *output, size_t length) {

        for(size_t i=0, j=0; j<length; i++, j+=4) {
                output[j]= (byte)(input[i] & 0xff);
                output[j+1] = (byte)((input[i] >> 8) & 0xff);
                output[j+2] = (byte)((input[i] >> 16) & 0xff);
                output[j+3] = (byte)((input[i] >> 24) & 0xff);
        }
}

/* Decodes input (byte) into output (ulong). Assumes length is
a multiple of 4.
*/
void MD5::decode(const byte *input, ulong *output, size_t length) {

        for(size_t i=0, j=0; j<length; i++, j+=4) {       
                output[i] = ((ulong)input[j]) | (((ulong)input[j+1]) << 8) |
                        (((ulong)input[j+2]) << 16) | (((ulong)input[j+3]) << 24);
        }
}

/* Convert byte array to hex string. */
string MD5::bytesToHexString(const byte *input, size_t length) {
        string str;
        str.reserve(length << 1);
        for(size_t i = 0; i < length; i++) {
                int t = input[i];
                int a = t / 16;
                int b = t % 16;
                str.append(1, HEX[a]);
                str.append(1, HEX[b]);
        }
        return str;
}

/* Convert digest to string value */
string MD5::toString() {
        return bytesToHexString(digest(), 16);
}




----------------------------------
md5头文件代码如下:

#ifndef MD5_H
#define MD5_H

#include <string>
#include <fstream>

/* Type define */
typedef unsigned char byte;
typedef unsigned long ulong;

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();
private:
        void update(const byte *input, size_t length);
        void final();
        void transform(const byte block[64]);
        void encode(const ulong *input, byte *output, size_t length);
        void decode(const byte *input, ulong *output, size_t length);
        string bytesToHexString(const byte *input, size_t length);

        /* class uncopyable */
        MD5(const MD5&);
        MD5& operator=(const MD5&);
private:
        ulong _state[4];        /* state (ABCD) */
        ulong _count[2];        /* number of bits, modulo 2^64 (low-order word first) */
        byte _buffer[64];        /* input buffer */
        byte _digest[16];        /* message digest */
        bool _finished;                /* calculate finished ? */

        static const byte PADDING[64];        /* padding for calculate */
        static const char HEX[16];
        static const size_t BUFFER_SIZE = 1024;
};

#endif/*MD5_H*/





全站禁止灌水,后果自负 月光爆吧器 积分充值 签名档设置 积分记录 新人必备
梦殇qq群 欢迎加入群内禁止传播黄色信息!
①群:515706814 爆吧□顶贴□机器 ②群:94025161 贴吧推广□爆吧□软件 ③群:549343908 营销推广□贴吧□软件
回复

使用道具 举报

1198

帖子

0

积分

906

TBS

UID
9154
积分
0
TBS
906
智商
1291
节操
1156
海贝
0
阅读权限
0
在线时间
37 小时
注册时间
2014-4-17
最后登录
2014-6-27
2
发表于 2014-4-21 18:34:08 | 只看该作者
涨姿势
全站禁止灌水,后果自负 月光爆吧器 积分充值 签名档设置 积分记录 新人必备
梦殇qq群 欢迎加入群内禁止传播黄色信息!
①群:515706814 爆吧□顶贴□机器 ②群:94025161 贴吧推广□爆吧□软件 ③群:549343908 营销推广□贴吧□软件
回复

使用道具 举报

1198

帖子

0

积分

906

TBS

UID
9154
积分
0
TBS
906
智商
1291
节操
1156
海贝
0
阅读权限
0
在线时间
37 小时
注册时间
2014-4-17
最后登录
2014-6-27
3
发表于 2014-4-21 18:34:26 | 只看该作者
不太懂
全站禁止灌水,后果自负 月光爆吧器 积分充值 签名档设置 积分记录 新人必备
梦殇qq群 欢迎加入群内禁止传播黄色信息!
①群:515706814 爆吧□顶贴□机器 ②群:94025161 贴吧推广□爆吧□软件 ③群:549343908 营销推广□贴吧□软件
回复

使用道具 举报

4万

帖子

8591

积分

2725

TBS

UID
4
积分
8591
TBS
2725
智商
22958
节操
22039
海贝
1653
阅读权限
200
在线时间
3102 小时
注册时间
2014-1-1
最后登录
2024-10-5

在线时间长爱心大使梦殇元老

QQ
4
发表于 2014-4-21 18:36:48 | 只看该作者
从来没有撸过这么长的代码
全站禁止灌水,后果自负 月光爆吧器 积分充值 签名档设置 积分记录 新人必备
梦殇qq群 欢迎加入群内禁止传播黄色信息!
①群:515706814 爆吧□顶贴□机器 ②群:94025161 贴吧推广□爆吧□软件 ③群:549343908 营销推广□贴吧□软件
回复 支持 反对

使用道具 举报

22万

帖子

6万

积分

6万

TBS

❤牵着我的手❤闭着眼睛走你也不会迷路❤

UID
77
积分
67552
TBS
65989
智商
75025
节操
75016
海贝
1142
阅读权限
150
在线时间
6092 小时
注册时间
2014-1-2
最后登录
2023-6-29

二逼青年榜上有名在线时间长水货统领签到达人

QQ
5
发表于 2014-4-21 18:39:50 | 只看该作者
华彩大神好久不见啊
回复 支持 反对

使用道具 举报

471

帖子

154

积分

959

TBS

UID
1757
积分
154
TBS
959
智商
470
节操
460
海贝
30
阅读权限
20
在线时间
94 小时
注册时间
2014-1-12
最后登录
2017-3-9
6
发表于 2014-4-21 18:47:10 | 只看该作者
看见这么长的都晕了。。
遥远的她         仿佛借风声跟我话
回复 支持 反对

使用道具 举报

5617

帖子

0

积分

3131

TBS

椛椛椛

UID
5984
积分
0
TBS
3131
智商
3302
节操
3374
海贝
0
阅读权限
0
在线时间
234 小时
注册时间
2014-2-27
最后登录
2015-4-19

二逼青年水货勋章在线时间长

QQ
7
发表于 2014-4-21 18:50:47 | 只看该作者
谢谢分享
虽然我看不懂。。。
这里是萌萌的小失落
回复 支持 反对

使用道具 举报

4567

帖子

4046

积分

-275

TBS

斜眼笑

UID
36
积分
4046
TBS
-275
智商
2980
节操
1968
海贝
19
阅读权限
60
在线时间
324 小时
注册时间
2014-1-1
最后登录
2023-11-17
8
发表于 2014-4-21 18:58:50 | 只看该作者
本帖最后由 Royan 于 2014-4-21 19:00 编辑

本渣起步晚 还在看primer plus

全站禁止灌水,后果自负 月光爆吧器 积分充值 签名档设置 积分记录 新人必备
梦殇qq群 欢迎加入群内禁止传播黄色信息!
①群:515706814 爆吧□顶贴□机器 ②群:94025161 贴吧推广□爆吧□软件 ③群:549343908 营销推广□贴吧□软件
回复 支持 反对

使用道具 举报

148

帖子

0

积分

791

TBS

UID
5263
积分
0
TBS
791
智商
1018
节操
1037
海贝
0
阅读权限
0
在线时间
7 小时
注册时间
2014-2-14
最后登录
2014-6-21
9
发表于 2014-4-21 19:13:28 | 只看该作者
好高深的东西

—— 「どうして彼女ができないの?」 仆は素敌だと君は言う? 「それなら仆と付き合ってよ!」 その苦笑の意味はなに !?
回复 支持 反对

使用道具 举报

229

帖子

3356

积分

5万

TBS

UID
549
积分
3356
TBS
51673
智商
1538
节操
1531
海贝
1
阅读权限
60
在线时间
147 小时
注册时间
2014-1-3
最后登录
2015-6-23
10
 楼主| 发表于 2014-4-21 19:31:20 | 只看该作者
smoke 发表于 2014-4-21 18:39
华彩大神好久不见啊

么么哒~

点评

摸摸扎  详情 回复 发表于 2014-4-21 19:50
全站禁止灌水,后果自负 月光爆吧器 积分充值 签名档设置 积分记录 新人必备
梦殇qq群 欢迎加入群内禁止传播黄色信息!
①群:515706814 爆吧□顶贴□机器 ②群:94025161 贴吧推广□爆吧□软件 ③群:549343908 营销推广□贴吧□软件
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

GMT+8, 2024-10-5 19:19,Processed in 0.114703 second(s), 34 queries.

Powered by Discuz!X3.4© 2001-2013 Comsenz Inc. 手机版|黑名单|站点地图|RGB转16进制|梦殇国际 MSI

贴吧交流群:172119290 | 编程交流群:232677917 | 官方YY频道:13234704 | 本站所有软件仅供学习交流使用!

工信部备案:赣ICP备14004172号-1 | 如有需要请联系 邮箱:541641237#qq.com (点击发邮件)

快速回复 返回顶部 返回列表