Chinaunix首页 | 论坛 | 博客

michael

首页　| 　博文目录　| 　关于我

bjpiao

  • 博客访问： 1006390
  • 博文数量： 96
  • 博客积分： 1553
  • 博客等级： 上尉
  • 技术积分： 1871
  • 用 户 组： 普通用户
  • 注册时间： 2011-12-25 14:50
个人简介

专注点，细心点，耐心点 知行合一

文章分类

全部博文（96）

文章存档

2018年（1）

2014年（4）

2013年（31）

2012年（56）

2011年（4）

我的朋友
最近访客
推荐博文
相关博文
md5加密

分类： C/C++

2012-02-07 10:23:11

1.使用openssl库
编写test.cpp文件
  1. #include<stdio.h>
  2. #include<openssl/md5.h>
  3. #include<string.h>

  5. int main( int argc, char **argv )
  6. {
  7. MD5_CTX ctx;
  8. char *data="19870617";
  9. unsigned char md[16];
  10. char buf[33]={'\0'};
  11. char tmp[3]={'\0'};
  12. int i;

  14. MD5_Init(&ctx);
  15. MD5_Update(&ctx,(unsigned char *)data,strlen(data));
  16. MD5_Final(md,&ctx);

  18. for( i=0; i<16; i++ ){
  19. sprintf(tmp,"%02X",md[i]);
  20. //sprintf(tmp, "%2.2x", md[i]);
  21. strcat(buf,tmp);
  22. }
  23. printf("%s\n",buf);
  24. return 0;
  25. }

编译
g++ test.cpp -I./include/ -L./lib/ -lssl -lcrypto

2.改进版
  1. #include<stdio.h>
  2. #include<openssl/md5.h>
  3. #include<string.h>

  5. char c_b2s[256][4] = {
  6. "00","01","02","03","04","05","06","07","08","09",
  7. "0a","0b","0c","0d","0e","0f","10","11","12","13",
  8. "14","15","16","17","18","19","1a","1b","1c","1d",
  9. "1e","1f","20","21","22","23","24","25","26","27",
  10. "28","29","2a","2b","2c","2d","2e","2f","30","31",
  11. "32","33","34","35","36","37","38","39","3a","3b",
  12. "3c","3d","3e","3f","40","41","42","43","44","45","46",
  13. "47","48","49","4a","4b","4c","4d","4e","4f","50","51",
  14. "52","53","54","55","56","57","58","59","5a","5b","5c",
  15. "5d","5e","5f","60","61","62","63","64","65","66","67",
  16. "68","69","6a","6b","6c","6d","6e","6f","70","71","72",
  17. "73","74","75","76","77","78","79","7a","7b","7c","7d","7e",
  18. "7f","80","81","82","83","84","85","86","87","88","89","8a",
  19. "8b","8c","8d","8e","8f","90","91","92","93","94","95","96",
  20. "97","98","99","9a","9b","9c","9d","9e","9f","a0","a1","a2","a3",
  21. "a4","a5","a6","a7","a8","a9","aa","ab","ac","ad","ae","af","b0",
  22. "b1","b2","b3","b4","b5","b6","b7","b8","b9","ba","bb","bc","bd",
  23. "be","bf","c0","c1","c2","c3","c4","c5","c6","c7","c8","c9","ca","cb",
  24. "cc","cd","ce","cf","d0","d1","d2","d3","d4","d5","d6","d7","d8","d9",
  25. "da","db","dc","dd","de","df","e0","e1","e2","e3","e4","e5","e6","e7",
  26. "e8","e9","ea","eb","ec","ed","ee","ef","f0","f1","f2","f3","f4","f5","f6",
  27. "f7","f8","f9","fa","fb","fc","fd","fe","ff"
  28. };

  30. string Char2Str16(char *pBuff,int iBuffLen)
  31. {
  32.     int i;
  33.     unsigned char iTmp = 0;
  34.     int index = 0;
  35.     char cTemp[1024];

  37.     string ret = "";

  39.     for(i=0; i<iBuffLen; i++)
  40.     {
  41.         iTmp = (unsigned char) pBuff[i];
  42.         cTemp[index++] = c_b2s[iTmp][0];
  43.         cTemp[index++] = c_b2s[iTmp][1];
  44.     }
  45.     cTemp[index] = '\0';
  46.     ret += cTemp;
  47.     return ret;
  48. }

  50. int Md5(const string& src, string &output)
  51. {
  52.     MD5_CTX c;
  53.     unsigned char md[MD5_DIGEST_LENGTH];        
  54.     int i;
  55.     char buf[MAXPSWLEN];    
  56.     memset(buf, 0, MAXPSWLEN);
  57.     strncpy(buf, src.c_str(), src.size());
  58.     i = src.size();

  60.     MD5_Init(&c);            
  61.     MD5_Update(&c,(unsigned char *)buf,(unsigned long)i);            
  62.     MD5_Final(&(md[0]),&c);

  64.     output = Char2Str16((char *)md, MD5_DIGEST_LENGTH);
  65.     return 0;
  66. ｝

3. 生成md5类
md5.h
  1. #ifndef _MD5_H_
  2. #define _MD5_H_

  4. typedef unsigned char *POINTER;
  5. typedef unsigned short int UINT2;
  6. typedef unsigned long int UINT4;

  8. //CDESCrypt类的定义
  9. class MD5
  10. {
  11. public:

  13. typedef struct {
  14.   UINT4 state[4]; /* state (ABCD) */
  15.   UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */
  16.   unsigned char buffer[64]; /* input buffer */
  17. } MD5_CTX;

  19. public:
  20.     MD5(){}
  21.     virtual ~MD5(){}

  23.     // 供外部使用的哈希函数：生成16bytes的hash值
  24.     static void encode(unsigned char* p_pszDest, const char* p_pszSrc);

  26.     // 供外部使用的哈希函数：生成long long的字符串形式hash值
  27.     static void Hash64(const char* sInputUrl, char* sOutputDocID);    

  29.     // 供外部使用的哈希函数：生成long long的hash值
  30.     static void Hash64(const char* sInputUrl, long long & ddwDocID);

  32. private:
  33.     // MD5 初始化. 开始一个MD5操作, 写一个新的上下文
  34.     static void MD5Init (MD5_CTX *);

  36.     // MD5块的更新操作，继续MD5报文摘要操作，处理另外的报文块，并更新上下文
  37.     static void MD5Update(MD5_CTX *, unsigned char *, unsigned int);

  39.     // MD5结束操作，写报文摘要并清空上下文
  40.     static void MD5Final (unsigned char [16], MD5_CTX *);

  42.     // MD5的主要变换过程
  43.     static void MD5Transform (UINT4 [4], unsigned char [64]);

  45.     // 把输入的UINT4数据编码后输出成unsigned char
  46.     static void innerEncode (unsigned char *, UINT4 *, unsigned int);

  48.     // 把输入的unsigned char数据解码后输出成UINT4
  49.     static void innerDecode (UINT4 *, unsigned char *, unsigned int);

  51.     // 两个内存块数据之间复制,注意：这里不能用strcpy
  52.     static void MD5_memcpy (POINTER, POINTER, unsigned int);

  54.     // 把一块内存全部初始化为某一个值
  55.     static void MD5_memset (POINTER, int, unsigned int);
  56.     
  57. };

  59. #endif
  60. //

md5.cpp
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <assert.h>
  5. #include "md5.h"

  7. #define S11 7 //这是md5变换时要用到的常量数据
  8. #define S12 12
  9. #define S13 17
  10. #define S14 22
  11. #define S21 5
  12. #define S22 9
  13. #define S23 14
  14. #define S24 20
  15. #define S31 4
  16. #define S32 11
  17. #define S33 16
  18. #define S34 23
  19. #define S41 6
  20. #define S42 10
  21. #define S43 15
  22. #define S44 21

  24. static unsigned char PADDING[64] = { //这是补位时第一个要加上的数
  25.   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  26.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  27.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

  29. // F, G, H and I 是基本的MD5处理位操作函数，X，Y，Z为32位整数
  30. #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  31. #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  32. #define H(x, y, z) ((x) ^ (y) ^ (z))
  33. #define I(x, y, z) ((y) ^ ((x) | (~z)))

  35. // 把x左移n位
  36. #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

  38. //第1轮变换：以[a b c d x s ac]表示如下操作a = b + ((a + F(b,c,d) + X[k] + T[ac]) <<< s).
  39. #define FF(a, b, c, d, x, s, ac) { \
  40.  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
  41.  (a) = ROTATE_LEFT ((a), (s)); \
  42.  (a) += (b); }

  44. //第2轮变换：以[a b c d x s ac]表示如下操作a=b + ((a + G(b,c,d) + X[k] + T[ac]) <<< s).
  45. #define GG(a, b, c, d, x, s, ac) { \
  46.  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
  47.  (a) = ROTATE_LEFT ((a), (s)); \
  48.  (a) += (b); \
  49.   }

  51. //第3轮变换：以[a b c d x s ac]表示如下操作a = b + ((a + H(b,c,d) + X[k] + T[ac]) <<< s).
  52. #define HH(a, b, c, d, x, s, ac) { \
  53.  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
  54.  (a) = ROTATE_LEFT ((a), (s)); \
  55.  (a) += (b); \
  56.   }

  58. //第4轮变换：以[a b c d x s ac]表示如下操作a = b + ((a + I(b,c,d) + X[k] + T[ac]) <<< s).
  59. #define II(a, b, c, d, x, s, ac) { \
  60.  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
  61.  (a) = ROTATE_LEFT ((a), (s)); \
  62.  (a) += (b); \
  63.   }

  65. /**
  66.  *功能描述： MD5 初始化. 开始一个MD5操作, 写一个新的上下文
  67.  *入口参数： MD5_CTX *context 加密上下文
  68.  *返回值： 无
  69.  */
  70.  void MD5::MD5Init (MD5_CTX *context)
  71. {
  72.     //这两个32位整数是用来保存待加密数据的长度，这里先初始化为0
  73.     context->count[0] = context->count[1] = 0;

  75.     //四个32位整数 (A,B,C,D) 用来计算信息摘要，初始化使用的是十六进制表示的数字
  76.     context->state[0] = 0x67452301;
  77.     context->state[1] = 0xefcdab89;
  78.     context->state[2] = 0x98badcfe;
  79.     context->state[3] = 0x10325476;
  80. }

  82. /**
  83.  *功能描述：MD5块的更新操作，继续MD5报文摘要操作，处理另外的报文块，并更新上下文
  84.  *入口参数：
  85.  *             MD5_CTX *context 加密上下文
  86.  *             unsigned char * input 待加密的数据
  87.  *             unsigned int inputLen 待加密的数据的长度
  88.  *返回值： 无
  89.  */
  90. void MD5::MD5Update (MD5_CTX * context, unsigned char * input, unsigned int inputLen)
  91. {
  92.     unsigned int i, index, partLen;

  94.     //按模64计算字节数
  95.     index = (unsigned int)((context->count[0] >> 3) & 0x3F);

  97.     // Update number of bits
  98.     if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3))
  99.         context->count[1]++;
  100.     context->count[1] += ((UINT4)inputLen >> 29);

  102.     partLen = 64 - index;

  104.     if (inputLen >= partLen)
  105.     {
  106.         // 被64整除余下的部分先进行加密
  107.         MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
  108.         MD5Transform (context->state, context->buffer);

  110.         // 以64个字节为一个单位来进行变换
  111.         for (i = partLen; i + 63 < inputLen; i += 64)
  112.             MD5Transform (context->state, &input[i]);

  114.         index = 0;
  115.     }
  116.     else
  117.         i = 0;

  119.     /* Buffer remaining input */
  120.     MD5_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
  121. }

  123. /**
  124.  *功能描述： MD5结束操作，写报文摘要并清空上下文
  125.  *入口参数：
  126.  *            unsigned char digest[16],
  127.  *            MD5_CTX * context
  128.  *返回值： 无
  129.  */
  130. void MD5::MD5Final (unsigned char digest[16], MD5_CTX * context)
  131. {
  132.     unsigned char bits[8];
  133.     unsigned int index, padLen;

  135.     /* Save number of bits */
  136.     innerEncode (bits, context->count, 8);

  138.     /* Pad out to 56 mod 64.*/
  139.     index = (unsigned int)((context->count[0] >> 3) & 0x3f);
  140.     padLen = (index < 56) ? (56 - index) : (120 - index);
  141.     MD5Update (context, PADDING, padLen);

  143.     /* Append length (before padding) */
  144.     MD5Update (context, bits, 8);

  146.     // 保存状态到摘要
  147.     innerEncode (digest, context->state, 16);

  149.     // 把x所指向的内存块清0
  150.     MD5_memset ((POINTER)context, 0, sizeof (*context));
  151. }

  153. /**
  154.  *功能描述：MD5的主要变换过程
  155.  *入口参数：
  156.  *            UINT4 state[4] 四个32位整数，用来计算信息摘要
  157.  *            unsigned char block[64]
  158.  *返回值： 无
  159.  *算法说明：512位的报文数据分成4个128位的数据块，依次被送到不同的散列函数进行4轮计算；
  160.  * 每一轮都按32位的小数据块进行复杂的运算，计算完成后全部写入ABCD寄存器，用于下
  161.  * 一轮的计算。等到最后计算完毕，在寄存器ABCD中的数据就是我们要求的MD5代码
  162.  */
  163. void MD5::MD5Transform (UINT4 state[4], unsigned char block[64])
  164. {
  165.     UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

  167.     //每一次，把数据原文存放在16个元素的数组X中
  168.     innerDecode (x, block, 64);

  170.     // 第一轮变换
  171.     FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
  172.     FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
  173.     FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
  174.     FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
  175.     FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
  176.     FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
  177.     FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
  178.     FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
  179.     FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
  180.     FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
  181.     FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
  182.     FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
  183.     FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
  184.     FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
  185.     FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
  186.     FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

  188.     // 第二轮变换
  189.     GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
  190.     GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
  191.     GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
  192.     GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
  193.     GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
  194.     GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
  195.     GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
  196.     GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
  197.     GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
  198.     GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
  199.     GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
  200.     GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
  201.     GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
  202.     GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
  203.     GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
  204.     GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

  206.     // 第三轮变换
  207.     HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
  208.     HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
  209.     HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
  210.     HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
  211.     HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
  212.     HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
  213.     HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
  214.     HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
  215.     HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
  216.     HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
  217.     HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
  218.     HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
  219.     HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
  220.     HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
  221.     HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
  222.     HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

  224.     // 第四轮变换
  225.     II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
  226.     II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
  227.     II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
  228.     II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
  229.     II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
  230.     II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
  231.     II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
  232.     II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
  233.     II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
  234.     II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
  235.     II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
  236.     II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
  237.     II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
  238.     II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
  239.     II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
  240.     II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

  242.     state[0] += a;
  243.     state[1] += b;
  244.     state[2] += c;
  245.     state[3] += d;

  247.     //把x所指向的内存块清0
  248.     MD5_memset ((POINTER)x, 0, sizeof (x));
  249. }

  251. /**
  252.  *功能描述： 把输入的UINT4数据编码后输出成unsigned char，假设长度len是4的倍数
  253.  *入口参数：
  254.  *            unsigned char *output;
  255.  *            UINT4 *input;
  256.  *            unsigned int len
  257.  *返回值： 无
  258.  */
  259. void MD5::innerEncode (unsigned char * output, UINT4 * input,unsigned int len)
  260. {
  261.     unsigned int i, j;

  263.     for (i = 0, j = 0; j < len; i++, j += 4)
  264.     {
  265.         output[j] = (unsigned char)(input[i] & 0xff);
  266.         output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
  267.         output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
  268.         output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
  269.     }
  270. }

  272. /**
  273.  *功能描述： 把输入的unsigned char数据解码后输出成UINT4，假设长度len是4的倍数
  274.  *入口参数：
  275.  *            UINT4 *output;
  276.  *            unsigned char *input;
  277.  *            unsigned int len;
  278.  *返回值： 无
  279.  */
  280. void MD5::innerDecode (UINT4 * output, unsigned char * input, unsigned int len)
  281. {
  282.     unsigned int i, j;

  284.     for (i = 0, j = 0; j < len; i++, j += 4)
  285.     {
  286.         output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
  287.                  (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
  288.     }
  289. }

  291. /**
  292.  *功能描述：两个内存块数据之间复制
  293.  *入口参数：
  294.  *            POINTER output 要复制到的目的数据
  295.  *            POINTER input 要复制的源数据
  296.  *            unsigned int len 要复制的长度
  297.  *返回值： 无
  298.  */
  299. void MD5::MD5_memcpy (POINTER output, POINTER input, unsigned int len)
  300. {
  301.     unsigned int i;

  303.     for (i = 0; i < len; i++)
  304.         output[i] = input[i];
  305. }

  307. /**
  308.  *功能描述： 把一块内存全部初始化为某一个值
  309.  *入口参数：
  310.  *            POINTER output 要初始化的内存块
  311.  *            int value 初值
  312.  *            unsigned int len 要初始化的长度
  313.  *返回值： 无
  314.  */
  315. void MD5::MD5_memset (POINTER output, int value, unsigned int len)
  316. {
  317.     unsigned int i;

  319.     for (i = 0; i < len; i++)
  320.         ((char *)output)[i] = (char)value;
  321. }

  323. /**
  324.  * 功能描述： 供外部使用的加密函数
  325.  * 入口参数：
  326.  * unsigned char* p_pszDest
  327.  * const char* p_pszSrc
  328.  * 返回值： 无
  329.  */
  330. void MD5::encode(unsigned char* p_pszDest, const char* p_pszSrc)
  331. {
  332.     MD5_CTX context;
  333.     unsigned int len = strlen (p_pszSrc);

  335.     MD5Init (&context);
  336.     MD5Update (&context, (unsigned char* )p_pszSrc, len);
  337.     MD5Final (p_pszDest, &context);
  338. }

  340. void MD5::Hash64(const char* sInputUrl, char* sOutputDocID)
  341. {
  342.     char sLine[16];
  343.     char szResult[8];
  344.     memset(sLine, 0, 16);
  345.     
  346.     encode((unsigned char* )sLine, (const char* )sInputUrl);
  347.     memcpy(szResult, sLine, 8);

  349. #ifdef WIN32
  350.     __int64 ddwDocID = *((__int64 *)(szResult));
  351.     _i64toa(ddwDocID, sOutputDocID, 10); //转换为10进制数
  352. #else
  353.     long long ddwDocID = *((long long *)(szResult));
  354.     sprintf (sOutputDocID, "%llu", ddwDocID);
  355. #endif
  356. }

  358. void MD5::Hash64(const char* sInputUrl, long long& ddwDocID)
  359. {
  360.     char sLine[16];
  361.     char szResult[8];
  362.     memset(sLine, 0, 16);

  364.     encode((unsigned char* )sLine, (const char* )sInputUrl);
  365.     memcpy(szResult, sLine, 8);

  367.     ddwDocID = *((long long *)(szResult));
  368. }

  370. //#define __MD5_MAIN__
  371. #ifdef __MD5_MAIN__
  372. void main()
  373. {
  374.     unsigned char digest[16];
  375.     char *string = "hello world";

  377.     MD5 md5;
  378.     md5.encode(digest, string);

  380.     std::cout << "Before MD5: " << string << std::endl;
  381.     std::cout << "After MD5: " << digest << std::endl;
  382.  
  383. }
  384. #endif

阅读(4344) | 评论(0) | 转发(1) |
0

上一篇：SecureCRT 常用技巧

下一篇：获取进程的可执行文件的绝对路径

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6