devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

常用的加密方式，C++_密码加密的方式有哪些 c++

作者：黑客灵魂 | 2024-08-17 02:38:41

赞

踩

密码加密的方式有哪些 c++

base64,DES，MD5

base64.h

  1. #pragma once
  2.  
  3. const char base[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  4. class CBase64
  5. {
  6. public:
  7. 	CBase64();
  8. 	~CBase64();
  9.  
  10. 	// 头文件 base64.h	
  11.  
  12. 	/* Base64 编码 */
  13. 	CString base64_encode(CString str);
  14.  
  15. 	/* Base64 解码 */
  16. 	char *base64_decode(const char* data, int data_len);
  17. 	static char find_pos(char ch);
  18.  
  19. };


base64.cpp

  1. #include "stdafx.h"
  2. #include "Base64.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. CBase64::CBase64()
  8. {
  9.  
  10. }
  11.  
  12.  
  13. CBase64::~CBase64()
  14. {
  15.  
  16. }
  17. /* Base64 编码 */
  18. CString CBase64::base64_encode(CString str)
  19. {
  20. 	//int data_len = strlen(data); 
  21. 	USES_CONVERSION;
  22. 	const char * data = T2A(str);
  23. 	int data_len = strlen(data);
  24. 	int prepare = 0;
  25. 	int ret_len;
  26. 	int temp = 0;
  27. 	char *ret = NULL;
  28. 	char *f = NULL;
  29. 	int tmp = 0;
  30. 	char changed[4];
  31. 	int i = 0;
  32. 	ret_len = data_len / 3;
  33. 	temp = data_len % 3;
  34. 	if (temp > 0)
  35. 	{
  36. 		ret_len += 1;
  37. 	}
  38. 	ret_len = ret_len * 4 + 1;
  39. 	ret = (char *)malloc(ret_len);
  40.  
  41. 	if (ret == NULL)
  42. 	{
  43. 		printf("No enough memory.\n");
  44. 		exit(0);
  45. 	}
  46. 	memset(ret, 0, ret_len);
  47. 	f = ret;
  48. 	while (tmp < data_len)
  49. 	{
  50. 		temp = 0;
  51. 		prepare = 0;
  52. 		memset(changed, '\0', 4);
  53. 		while (temp < 3)
  54. 		{
  55. 			//printf("tmp = %d\n", tmp); 
  56. 			if (tmp >= data_len)
  57. 			{
  58. 				break;
  59. 			}
  60. 			prepare = ((prepare << 8) | (data[tmp] & 0xFF));
  61. 			tmp++;
  62. 			temp++;
  63. 		}
  64. 		prepare = (prepare << ((3 - temp) * 8));
  65. 		//printf("before for : temp = %d, prepare = %d\n", temp, prepare); 
  66. 		for (i = 0; i < 4; i++)
  67. 		{
  68. 			if (temp < i)
  69. 			{
  70. 				changed[i] = 0x40;
  71. 			}
  72. 			else
  73. 			{
  74. 				changed[i] = (prepare >> ((3 - i) * 6)) & 0x3F;
  75. 			}
  76. 			*f = base[changed[i]];
  77. 			//printf("%.2X", changed[i]); 
  78. 			f++;
  79. 		}
  80. 	}
  81. 	*f = '\0';
  82.  
  83. 	//return ret;
  84. 	return A2W(ret);
  85.  
  86. }
  87.  
  88. /* 转换算子 */
  89. char CBase64::find_pos(char ch)
  90. {
  91. 	char *ptr = (char*)strrchr(base, ch);//the last position (the only) in base[] 
  92. 	return (ptr - base);
  93. }
  94.  
  95. /* Base64 解码 */
  96. char *CBase64::base64_decode(const char *data, int data_len)
  97. {
  98. 	int ret_len = (data_len / 4) * 3;
  99. 	int equal_count = 0;
  100. 	char *ret = NULL;
  101. 	char *f = NULL;
  102. 	int tmp = 0;
  103. 	int temp = 0;
  104. 	int prepare = 0;
  105. 	int i = 0;
  106. 	if (*(data + data_len - 1) == '=')
  107. 	{
  108. 		equal_count += 1;
  109. 	}
  110. 	if (*(data + data_len - 2) == '=')
  111. 	{
  112. 		equal_count += 1;
  113. 	}
  114. 	if (*(data + data_len - 3) == '=')
  115. 	{//seems impossible 
  116. 		equal_count += 1;
  117. 	}
  118. 	switch (equal_count)
  119. 	{
  120. 	case 0:
  121. 		ret_len += 4;//3 + 1 [1 for NULL] 
  122. 		break;
  123. 	case 1:
  124. 		ret_len += 4;//Ceil((6*3)/8)+1 
  125. 		break;
  126. 	case 2:
  127. 		ret_len += 3;//Ceil((6*2)/8)+1 
  128. 		break;
  129. 	case 3:
  130. 		ret_len += 2;//Ceil((6*1)/8)+1 
  131. 		break;
  132. 	}
  133. 	ret = (char *)malloc(ret_len);
  134. 	if (ret == NULL)
  135. 	{
  136. 		printf("No enough memory.\n");
  137. 		exit(0);
  138. 	}
  139. 	memset(ret, 0, ret_len);
  140. 	f = ret;
  141. 	while (tmp < (data_len - equal_count))
  142. 	{
  143. 		temp = 0;
  144. 		prepare = 0;
  145. 		while (temp < 4)
  146. 		{
  147. 			if (tmp >= (data_len - equal_count))
  148. 			{
  149. 				break;
  150. 			}
  151. 			prepare = (prepare << 6) | (find_pos(data[tmp]));
  152. 			temp++;
  153. 			tmp++;
  154. 		}
  155. 		prepare = prepare << ((4 - temp) * 6);
  156. 		for (i = 0; i < 3; i++)
  157. 		{
  158. 			if (i == temp)
  159. 			{
  160. 				break;
  161. 			}
  162. 			*f = (char)((prepare >> ((2 - i) * 8)) & 0xFF);
  163. 			f++;
  164. 		}
  165. 	}
  166. 	*f = '\0';
  167. 	return ret;
  168. }

DES.h 

  1. #pragma once
  2.  
  3. #include <string>
  4.  
  5. class CDes
  6. {
  7. private:
  8. 	
  9. public:
  10.  
  11. 	//加密
  12. 	CString Encrypt(CString str,BOOL bIsPwd=FALSE);
  13. 	char hexCiphertextAnyLength[16384], bitsCiphertextAnyLength[32768];
  14. 	void ConvertCiphertext2OtherFormat(int iBitsLen, char *szCipherInBytes);
  15. 	//解密
  16. 	CString Decrypt(CString str,BOOL bIsPwd = FALSE);
  17.  
  18. 	
  19.  
  20.  
  21. 	//类构造函数
  22. 	CDes();
  23.  
  24. 	//类析构函数
  25. 	~CDes();
  26.  
  27. 	//功能:产生16个28位的key
  28. 	//参数:源8位的字符串(key),存放key的序号0-1
  29. 	//结果:函数将调用private CreateSubKey将结果存于char SubKeys[keyN][16][48]
  30. 	void InitializeKey(char* srcBytes, unsigned int keyN);
  31.  
  32. 	//功能:加密8位字符串
  33. 	//参数:8位字符串,使用Key的序号0-1
  34. 	//结果:函数将加密后结果存放于private szCiphertext[16]
  35. 	//      用户通过属性Ciphertext得到
  36. 	void EncryptData(char* _srcBytes, unsigned int keyN);
  37.  
  38. 	//功能:解密16位十六进制字符串
  39. 	//参数:16位十六进制字符串,使用Key的序号0-1
  40. 	//结果:函数将解密候结果存放于private szPlaintext[8]
  41. 	//      用户通过属性Plaintext得到
  42. 	void DecryptData(char* _srcBytes, unsigned int keyN);
  43.  
  44. 	//功能:加密任意长度字符串
  45. 	//参数:任意长度字符串,长度,使用Key的序号0-1
  46. 	//结果:函数将加密后结果存放于private szFCiphertextAnyLength[8192]
  47. 	//      用户通过属性CiphertextAnyLength得到
  48. 	void EncryptAnyLength(char* _srcBytes, unsigned int _bytesLength, unsigned int keyN);
  49.  
  50. 	//功能:解密任意长度十六进制字符串
  51. 	//参数:任意长度字符串,长度,使用Key的序号0-1
  52. 	//结果:函数将加密后结果存放于private szFPlaintextAnyLength[8192]
  53. 	//      用户通过属性PlaintextAnyLength得到
  54. 	void DecryptAnyLength(char* _srcBytes, unsigned int _bytesLength, unsigned int keyN);
  55.  
  56. 	//功能:Bytes到Bits的转换,
  57. 	//参数:待变换字符串,处理后结果存放缓冲区指针,Bits缓冲区大小
  58. 	void Bytes2Bits(char *srcBytes, char* dstBits, unsigned int sizeBits);
  59.  
  60. 	//功能:Bits到Bytes的转换,
  61. 	//参数:待变换字符串,处理后结果存放缓冲区指针,Bits缓冲区大小
  62. 	void Bits2Bytes(char *dstBytes, char* srcBits, unsigned int sizeBits);
  63.  
  64. 	//功能:Int到Bits的转换,
  65. 	//参数:待变换字符串,处理后结果存放缓冲区指针
  66. 	void Int2Bits(unsigned int srcByte, char* dstBits);
  67.  
  68. 	//功能:Bits到Hex的转换
  69. 	//参数:待变换字符串,处理后结果存放缓冲区指针,Bits缓冲区大小
  70. 	void Bits2Hex(char *dstHex, char* srcBits, unsigned int sizeBits);
  71.  
  72. 	//功能:Bits到Hex的转换
  73. 	//参数:待变换字符串,处理后结果存放缓冲区指针,Bits缓冲区大小
  74. 	void Hex2Bits(char *srcHex, char* dstBits, unsigned int sizeBits);
  75.  
  76. 	//szCiphertextInBinary的get函数
  77. 	char* GetCiphertextInBinary();
  78.  
  79. 	//szCiphertextInHex的get函数
  80. 	char* GetCiphertextInHex();
  81.  
  82. 	//Ciphertext的get函数
  83. 	char* GetCiphertextInBytes();
  84.  
  85. 	//Plaintext的get函数
  86. 	char* GetPlaintext();
  87.  
  88. 	//CiphertextAnyLength的get函数
  89. 	char* GetCiphertextAnyLength();
  90.  
  91. 	//PlaintextAnyLength的get函数
  92. 	char* GetPlaintextAnyLength();
  93.  
  94. private:
  95. 	char szSubKeys[2][16][48];//储存2个16组48位密钥,第2个用于3DES
  96. 	char szCiphertextRaw[64]; //储存二进制密文(64个Bits) int 0,1
  97. 	char szPlaintextRaw[64]; //储存二进制密文(64个Bits) int 0,1
  98. 	char szCiphertextInBytes[8];//储存8位密文
  99. 	char szPlaintextInBytes[8];//储存8位明文字符串
  100.  
  101. 	char szCiphertextInBinary[65]; //储存二进制密文(64个Bits) char '0','1',最后一位存'\0'
  102. 	char szCiphertextInHex[17]; //储存十六进制密文,最后一位存'\0'
  103. 	char szPlaintext[9];//储存8位明文字符串,最后一位存'\0'
  104.  
  105. 	char szFCiphertextAnyLength[8192];//任意长度密文
  106. 	char szFPlaintextAnyLength[8192];//任意长度明文字符串
  107.  
  108. 	//功能:生成子密钥
  109. 	//参数:经过PC1变换的56位二进制字符串,生成的szSubKeys编号0-1
  110. 	//结果:将保存于char szSubKeys[16][48]
  111. 	void CreateSubKey(char* sz_56key, unsigned int keyN);
  112.  
  113. 	//功能:DES中的F函数,
  114. 	//参数:左32位,右32位,key序号(0-15),使用的szSubKeys编号0-1
  115. 	//结果:均在变换左右32位
  116. 	void FunctionF(char* sz_Li, char* sz_Ri, unsigned int iKey, unsigned int keyN);
  117.  
  118. 	//功能:IP变换
  119. 	//参数:待处理字符串,处理后结果存放指针
  120. 	//结果:函数改变第二个参数的内容
  121. 	void InitialPermuteData(char* _src, char* _dst);
  122.  
  123. 	//功能:将右32位进行扩展位48位,
  124. 	//参数:原32位字符串,扩展后结果存放指针
  125. 	//结果:函数改变第二个参数的内容
  126. 	void ExpansionR(char* _src, char* _dst);
  127.  
  128. 	//功能:异或函数,
  129. 	//参数:待异或的操作字符串1,字符串2,操作数长度,处理后结果存放指针
  130. 	//结果: 函数改变第四个参数的内容
  131. 	void XOR(char* szParam1, char* szParam2, unsigned int uiParamLength, char* szReturnValueBuffer);
  132.  
  133. 	//功能:S-BOX , 数据压缩,
  134. 	//参数:48位二进制字符串,
  135. 	//结果:返回结果:32位字符串
  136. 	void CompressFuncS(char* _src48, char* _dst32);
  137.  
  138. 	//功能:IP逆变换,
  139. 	//参数:待变换字符串,处理后结果存放指针
  140. 	//结果:函数改变第二个参数的内容
  141. 	void PermutationP(char* _src, char* _dst);
  142.  
  143. };

DES.cpp 

  1. #include "stdafx.h"
  2. #include "DES.h"
  3.  
  4. // permuted choice table (PC1)
  5. const static char PC1_Table[56] = {
  6. 	57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
  7. 	10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
  8. 	63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
  9. 	14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
  10. };
  11. // permuted choice key (PC2)
  12. const static char PC2_Table[48] = {
  13. 	14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
  14. 	23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
  15. 	41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
  16. 	44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
  17. };
  18. // number left rotations of pc1 
  19. const static char Shift_Table[16] = {
  20. 	1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
  21. };
  22. // initial permutation (IP)
  23. const static char IP_Table[64] = {
  24. 	58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
  25. 	62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
  26. 	57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
  27. 	61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
  28. };
  29. // expansion operation matrix (E)
  30. const static char E_Table[48] = {
  31. 	32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
  32. 	8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
  33. 	16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
  34. 	24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1
  35. };
  36. // The (in)famous S-boxes 
  37. const static char S_Box[8][4][16] = {
  38. 	// S1
  39. 	14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
  40. 	0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
  41. 	4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
  42. 	15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
  43. 	// S2 
  44. 	15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
  45. 	3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
  46. 	0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
  47. 	13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
  48. 	// S3 
  49. 	10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
  50. 	13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
  51. 	13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
  52. 	1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
  53. 	// S4 
  54. 	7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
  55. 	13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
  56. 	10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
  57. 	3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
  58. 	// S5 
  59. 	2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
  60. 	14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
  61. 	4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
  62. 	11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
  63. 	// S6 
  64. 	12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
  65. 	10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
  66. 	9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
  67. 	4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
  68. 	// S7 
  69. 	4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
  70. 	13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
  71. 	1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
  72. 	6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
  73. 	// S8 
  74. 	13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
  75. 	1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
  76. 	7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
  77. 	2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
  78. };
  79. // 32-bit permutation function P used on the output of the S-boxes 
  80. const static char P_Table[32] = {
  81. 	16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
  82. 	2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
  83. };
  84. // final permutation IP^-1 
  85. const static char IPR_Table[64] = {
  86. 	40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
  87. 	38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
  88. 	36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
  89. 	34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
  90. };
  91.  
  92. char KEY[8] =	 "1234678";//密匙
  93. char PWDKEY[8] = "2354123";
  94.  
  95. CDes::CDes()
  96. {
  97. 	memset(szCiphertextRaw, 0, 64);
  98. 	memset(szPlaintextRaw, 0, 64);
  99. 	memset(szCiphertextInBytes, 0, 8);
  100. 	memset(szPlaintextInBytes, 0, 8);
  101. 	memset(szCiphertextInBinary, 0, 65);
  102. 	memset(szCiphertextInHex, 0, 17);
  103. 	memset(szPlaintext, 0, 9);
  104. 	memset(szFCiphertextAnyLength, 0, 8192);
  105. 	memset(szCiphertextInHex, 0, 8192);
  106.  
  107. 	/dlj
  108.  
  109. 	/end
  110. }
  111. CDes::~CDes()
  112. {
  113. }
  114.  
  115. void CDes::InitializeKey(char* srcBytes, unsigned int keyN)
  116. {
  117. 	//convert 8 char-bytes key to 64 binary-bits
  118. 	char sz_64key[64] = { 0 };
  119. 	Bytes2Bits(srcBytes, sz_64key, 64);
  120. 	//PC 1
  121. 	char sz_56key[56] = { 0 };
  122. 	for (int k = 0; k < 56; k++)
  123. 	{
  124. 		sz_56key[k] = sz_64key[PC1_Table[k] - 1];
  125. 	}
  126. 	CreateSubKey(sz_56key, keyN);
  127. }
  128.  
  129. void CDes::CreateSubKey(char* sz_56key, unsigned int keyN)
  130. {
  131. 	char szTmpL[28] = { 0 };
  132. 	char szTmpR[28] = { 0 };
  133. 	char szCi[28] = { 0 };
  134. 	char szDi[28] = { 0 };
  135. 	memcpy(szTmpL, sz_56key, 28);
  136. 	memcpy(szTmpR, sz_56key + 28, 28);
  137.  
  138. 	for (int i = 0; i < 16; i++)
  139. 	{
  140. 		//shift to left
  141. 		//Left 28 bits
  142. 		memcpy(szCi, szTmpL + Shift_Table[i], 28 - Shift_Table[i]);
  143. 		memcpy(szCi + 28 - Shift_Table[i], szTmpL, Shift_Table[i]);
  144. 		//Right 28 bits
  145. 		memcpy(szDi, szTmpR + Shift_Table[i], 28 - Shift_Table[i]);
  146. 		memcpy(szDi + 28 - Shift_Table[i], szTmpR, Shift_Table[i]);
  147.  
  148. 		//permuted choice 48 bits key
  149. 		char szTmp56[56] = { 0 };
  150. 		memcpy(szTmp56, szCi, 28);
  151. 		memcpy(szTmp56 + 28, szDi, 28);
  152. 		for (int j = 0; j < 48; j++)
  153. 		{
  154. 			szSubKeys[keyN][i][j] = szTmp56[PC2_Table[j] - 1];
  155. 		}
  156. 		//Evaluate new szTmpL and szTmpR
  157. 		memcpy(szTmpL, szCi, 28);
  158. 		memcpy(szTmpR, szDi, 28);
  159. 	}
  160. }
  161.  
  162. void CDes::EncryptData(char* _srcBytes, unsigned int keyN)
  163. {
  164. 	char szSrcBits[64] = { 0 };
  165. 	char sz_IP[64] = { 0 };
  166. 	char sz_Li[32] = { 0 };
  167. 	char sz_Ri[32] = { 0 };
  168. 	char sz_Final64[64] = { 0 };
  169.  
  170. 	Bytes2Bits(_srcBytes, szSrcBits, 64);
  171. 	//IP
  172. 	InitialPermuteData(szSrcBits, sz_IP);
  173. 	memcpy(sz_Li, sz_IP, 32);
  174. 	memcpy(sz_Ri, sz_IP + 32, 32);
  175.  
  176. 	for (int i = 0; i < 16; i++)
  177. 	{
  178. 		FunctionF(sz_Li, sz_Ri, i, keyN);
  179. 	}
  180. 	//so D=LR
  181.  
  182. 	memcpy(sz_Final64, sz_Ri, 32);
  183. 	memcpy(sz_Final64 + 32, sz_Li, 32);
  184.  
  185. 	//~IP
  186. 	for (int j = 0; j < 64; j++)
  187. 	{
  188. 		szCiphertextRaw[j] = sz_Final64[IPR_Table[j] - 1];
  189. 	}
  190. 	Bits2Bytes(szCiphertextInBytes, szCiphertextRaw, 64);
  191. }
  192.  
  193. void CDes::DecryptData(char* _srcBytes, unsigned int keyN)
  194. {
  195. 	char szSrcBits[64] = { 0 };
  196. 	char sz_IP[64] = { 0 };
  197. 	char sz_Li[32] = { 0 };
  198. 	char sz_Ri[32] = { 0 };
  199. 	char sz_Final64[64] = { 0 };
  200. 	Bytes2Bits(_srcBytes, szSrcBits, 64);
  201. 	//IP --- return is sz_IP
  202. 	InitialPermuteData(szSrcBits, sz_IP);
  203. 	//divide the 64 bits data to two parts
  204. 	memcpy(sz_Ri, sz_IP, 32); //exchange L to R
  205. 	memcpy(sz_Li, sz_IP + 32, 32);  //exchange R to L
  206. 	//16 rounds F and xor and exchange
  207. 	for (int i = 0; i < 16; i++)
  208. 	{
  209. 		FunctionF(sz_Ri, sz_Li, 15 - i, keyN);
  210. 	}
  211. 	memcpy(sz_Final64, sz_Li, 32);
  212. 	memcpy(sz_Final64 + 32, sz_Ri, 32);
  213. 	// ~IP
  214. 	for (int j = 0; j < 64; j++)
  215. 	{
  216. 		szPlaintextRaw[j] = sz_Final64[IPR_Table[j] - 1];
  217. 	}
  218. 	Bits2Bytes(szPlaintextInBytes, szPlaintextRaw, 64);
  219. }
  220.  
  221. void CDes::FunctionF(char* sz_Li, char* sz_Ri, unsigned int iKey, unsigned int keyN)
  222. {
  223. 	char sz_48R[48] = { 0 };
  224. 	char sz_xor48[48] = { 0 };
  225. 	char sz_P32[32] = { 0 };
  226. 	char sz_Rii[32] = { 0 };
  227. 	char sz_Key[48] = { 0 };
  228. 	char s_Compress32[32] = { 0 };
  229. 	memcpy(sz_Key, szSubKeys[keyN][iKey], 48);
  230. 	ExpansionR(sz_Ri, sz_48R);
  231. 	XOR(sz_48R, sz_Key, 48, sz_xor48);
  232.  
  233. 	CompressFuncS(sz_xor48, s_Compress32);
  234. 	PermutationP(s_Compress32, sz_P32);
  235. 	XOR(sz_P32, sz_Li, 32, sz_Rii);
  236. 	memcpy(sz_Li, sz_Ri, 32);
  237. 	memcpy(sz_Ri, sz_Rii, 32);
  238. }
  239.  
  240. void CDes::InitialPermuteData(char* _src, char* _dst)
  241. {
  242. 	//IP
  243. 	for (int i = 0; i < 64; i++)
  244. 	{
  245. 		_dst[i] = _src[IP_Table[i] - 1];
  246. 	}
  247. }
  248.  
  249. void CDes::ExpansionR(char* _src, char* _dst)
  250. {
  251. 	for (int i = 0; i < 48; i++)
  252. 	{
  253. 		_dst[i] = _src[E_Table[i] - 1];
  254. 	}
  255. }
  256.  
  257. void CDes::XOR(char* szParam1, char* szParam2, unsigned int uiParamLength, char* szReturnValueBuffer)
  258. {
  259. 	for (unsigned int i = 0; i < uiParamLength; i++)
  260. 	{
  261. 		szReturnValueBuffer[i] = szParam1[i] ^ szParam2[i];
  262. 	}
  263. }
  264.  
  265. void CDes::CompressFuncS(char* _src48, char* _dst32)
  266. {
  267. 	char bTemp[8][6] = { 0 };
  268. 	char dstBits[4] = { 0 };
  269. 	for (int i = 0; i < 8; i++)
  270. 	{
  271. 		memcpy(bTemp[i], _src48 + i * 6, 6);
  272. 		int iX = (bTemp[i][0]) * 2 + (bTemp[i][5]);
  273. 		int iY = 0;
  274. 		for (int j = 1; j < 5; j++)
  275. 		{
  276. 			iY += bTemp[i][j] << (4 - j);
  277. 		}
  278. 		Int2Bits(S_Box[i][iX][iY], dstBits);
  279. 		memcpy(_dst32 + i * 4, dstBits, 4);
  280. 	}
  281.  
  282. }
  283.  
  284. void CDes::PermutationP(char* _src, char* _dst)
  285. {
  286. 	for (int i = 0; i < 32; i++)
  287. 	{
  288. 		_dst[i] = _src[P_Table[i] - 1];
  289. 	}
  290. }
  291.  
  292. void CDes::Bytes2Bits(char *srcBytes, char* dstBits, unsigned int sizeBits)
  293. {
  294. 	for (unsigned int i = 0; i < sizeBits; i++)
  295. 		dstBits[i] = ((srcBytes[i >> 3] << (i & 7)) & 128) >> 7;
  296. }
  297.  
  298. void CDes::Bits2Bytes(char *dstBytes, char* srcBits, unsigned int sizeBits)
  299. {
  300. 	memset(dstBytes, 0, sizeBits >> 3);
  301. 	for (unsigned int i = 0; i < sizeBits; i++)
  302. 		dstBytes[i >> 3] |= (srcBits[i] << (7 - (i & 7)));
  303. }
  304.  
  305. void CDes::Int2Bits(unsigned int _src, char* dstBits)
  306. {
  307. 	for (unsigned int i = 0; i < 4; i++)
  308. 		dstBits[i] = ((_src << i) & 8) >> 3;
  309. }
  310.  
  311. void CDes::Bits2Hex(char *dstHex, char* srcBits, unsigned int sizeBits)
  312. {
  313. 	memset(dstHex, 0, sizeBits >> 2);
  314. 	for (unsigned int i = 0; i < sizeBits; i++) //convert to int 0-15
  315. 		dstHex[i >> 2] += (srcBits[i] << (3 - (i & 3)));
  316. 	for (unsigned int j = 0; j < (sizeBits >> 2); j++)
  317. 		dstHex[j] += dstHex[j] > 9 ? 55 : 48; //convert to char '0'-'F'
  318. }
  319.  
  320. void CDes::Hex2Bits(char *srcHex, char* dstBits, unsigned int sizeBits)
  321. {
  322. 	memset(dstBits, 0, sizeBits);
  323. 	for (unsigned int i = 0; i < (sizeBits >> 2); i++)
  324. 		srcHex[i] -= srcHex[i] > 64 ? 55 : 48; //convert to char int 0-15
  325. 	for (unsigned int j = 0; j < sizeBits; j++)
  326. 		dstBits[j] = ((srcHex[j >> 2] << (j & 3)) & 15) >> 3;
  327.  
  328. }
  329.  
  330. char* CDes::GetCiphertextInBinary()
  331. {
  332. 	for (unsigned int i = 0; i < 64; i++)
  333. 	{
  334. 		szCiphertextInBinary[i] = szCiphertextRaw[i] + 48; // from int(0) to char('0') and int1 to char('1')
  335. 	}
  336. 	szCiphertextInBinary[64] = '\0';
  337. 	return szCiphertextInBinary;
  338. }
  339.  
  340. char* CDes::GetCiphertextInHex()
  341. {
  342. 	Bits2Hex(szCiphertextInHex, szCiphertextRaw, 64);
  343. 	szCiphertextInHex[16] = '\0';
  344. 	return szCiphertextInHex;
  345. }
  346.  
  347. char* CDes::GetCiphertextInBytes()
  348. {
  349. 	return szCiphertextInBytes;
  350. }
  351.  
  352. char* CDes::GetPlaintext()
  353. {
  354. 	memcpy(szPlaintext, szPlaintextInBytes, 8);
  355. 	szPlaintext[8] = '\0';
  356. 	return szPlaintext;
  357. }
  358.  
  359. char* CDes::GetCiphertextAnyLength()
  360. {
  361. 	return szFCiphertextAnyLength;
  362. }
  363.  
  364. char* CDes::GetPlaintextAnyLength()
  365. {
  366. 	return szFPlaintextAnyLength;
  367. }
  368.  
  369. void CDes::EncryptAnyLength(char* _srcBytes, unsigned int _bytesLength, unsigned int keyN)
  370. {
  371. 	if (_bytesLength == 8)
  372. 	{
  373. 		EncryptData(_srcBytes, keyN);
  374. 		memcpy(szFCiphertextAnyLength, szCiphertextInBytes, 8);
  375. 		szFCiphertextAnyLength[8] = '\0';
  376. 	}
  377. 	else if (_bytesLength < 8)
  378. 	{
  379. 		char _temp8bytes[8] = { 0 };
  380. 		memcpy(_temp8bytes, _srcBytes, _bytesLength);
  381. 		EncryptData(_temp8bytes, keyN);
  382. 		memcpy(szFCiphertextAnyLength, szCiphertextInBytes, 8);
  383. 		szFCiphertextAnyLength[8] = '\0';
  384. 	}
  385. 	else if (_bytesLength > 8)
  386. 	{
  387. 		int iParts = _bytesLength >> 3;
  388. 		int iResidue = _bytesLength % 8;
  389. 		char szLast8Bits[8] = { 0 };
  390. 		for (int i = 0; i < iParts; i++)
  391. 		{
  392. 			memcpy(szLast8Bits, _srcBytes + (i << 3), 8);
  393. 			EncryptData(szLast8Bits, keyN);
  394. 			memcpy(szFCiphertextAnyLength + (i << 3), szCiphertextInBytes, 8);
  395. 		}
  396. 		memset(szLast8Bits, 0, 8);
  397. 		memcpy(szLast8Bits, _srcBytes + (iParts << 3), iResidue);
  398.  
  399. 		EncryptData(szLast8Bits, keyN);
  400. 		memcpy(szFCiphertextAnyLength + (iParts << 3), szCiphertextInBytes, 8);
  401. 		szFCiphertextAnyLength[((iParts + 1) << 3)] = '\0';
  402. 	}
  403. }
  404.  
  405. void CDes::DecryptAnyLength(char* _srcBytes, unsigned int _bytesLength, unsigned int keyN)
  406. {
  407. 	if (_bytesLength == 8)
  408. 	{
  409. 		DecryptData(_srcBytes, keyN);
  410. 		memcpy(szFPlaintextAnyLength, szPlaintextInBytes, 8);
  411. 		szFPlaintextAnyLength[8] = '\0';
  412. 	}
  413. 	else if (_bytesLength < 8)
  414. 	{
  415. 		char _temp8bytes[8] = { 0 };
  416. 		memcpy(_temp8bytes, _srcBytes, 8);
  417. 		DecryptData(_temp8bytes, keyN);
  418. 		memcpy(szFPlaintextAnyLength, szPlaintextInBytes, _bytesLength);
  419. 		szFPlaintextAnyLength[_bytesLength] = '\0';
  420. 	}
  421. 	else if (_bytesLength > 8)
  422. 	{
  423. 		int iParts = _bytesLength >> 3;
  424. 		int iResidue = _bytesLength % 8;
  425. 		char szLast8Bits[8] = { 0 };
  426. 		for (int i = 0; i < iParts; i++)
  427. 		{
  428. 			memcpy(szLast8Bits, _srcBytes + (i << 3), 8);
  429. 			DecryptData(szLast8Bits, keyN);
  430. 			memcpy(szFPlaintextAnyLength + (i << 3), szPlaintextInBytes, 8);
  431. 		}
  432. 		if (iResidue != 0)
  433. 		{
  434. 			memset(szLast8Bits, 0, 8);
  435. 			memcpy(szLast8Bits, _srcBytes + (iParts << 3), 8);
  436. 			DecryptData(szLast8Bits, keyN);
  437. 			memcpy(szFPlaintextAnyLength + (iParts << 3), szPlaintextInBytes, iResidue);
  438. 		}
  439. 		szFPlaintextAnyLength[_bytesLength] = '\0';
  440. 	}
  441. }
  442. /dlj
  443. CString CDes::Encrypt(CString strPlaintext,BOOL bIsPwd)
  444. {
  445. 	if (bIsPwd)
  446. 	{
  447. 		InitializeKey(PWDKEY, 0);
  448. 	}
  449. 	else
  450. 	{
  451. 		InitializeKey(KEY, 0);
  452. 	}
  453. 	
  454. 	USES_CONVERSION;
  455. 	char *szPlaintextData = T2A(strPlaintext);
  456. 	//加密任意长度的字符串
  457. 	EncryptAnyLength(szPlaintextData, strlen(szPlaintextData), 0);
  458. 	ConvertCiphertext2OtherFormat(strlen(szPlaintextData) % 8 == 0 ? strlen(szPlaintextData) << 3 : ((strlen(szPlaintextData) >> 3) + 1) << 6, GetCiphertextAnyLength());
  459.  
  460. 	return A2W(hexCiphertextAnyLength);
  461.  
  462. }
  463.  
  464. void CDes::ConvertCiphertext2OtherFormat(int iBitsLen, char *szCipherInBytes)
  465. {
  466. 	
  467. 	memset(hexCiphertextAnyLength, 0, 16384);
  468. 	memset(bitsCiphertextAnyLength, 0, 32768);
  469. 	Bytes2Bits(szCipherInBytes, bitsCiphertextAnyLength, iBitsLen);
  470. 	Bits2Hex(hexCiphertextAnyLength, bitsCiphertextAnyLength, iBitsLen);
  471. 	for (int i = 0; i < iBitsLen; i++)
  472. 	{
  473. 		bitsCiphertextAnyLength[i] += 48;
  474. 	}
  475. }
  476.  
  477. CString CDes::Decrypt(CString strCiphertext,BOOL bIsPwd)
  478. {
  479. 	USES_CONVERSION;
  480. 	if (bIsPwd)
  481. 	{
  482. 		InitializeKey(PWDKEY, 0);
  483. 	}
  484. 	else
  485. 	{
  486. 		InitializeKey(KEY, 0);
  487. 	}
  488. 	//InitializeKey(KEY, 0);
  489. 	char *szCiphertext = T2A(strCiphertext);
  490.  
  491. 	int iLen = 0;
  492. 	char szCiphertextData[8192];
  493. 	memset(szCiphertextData, 0, 8192);
  494.  
  495. 	iLen = ((strlen(szCiphertext) >> 2) + (strlen(szCiphertext) % 4 == 0 ? 0 : 1)) << 4;
  496. 	memset(hexCiphertextAnyLength, 0, 16384);
  497. 	memcpy(hexCiphertextAnyLength, szCiphertext, strlen(szCiphertext));
  498. 	Hex2Bits(hexCiphertextAnyLength, bitsCiphertextAnyLength, iLen);
  499. 	Bits2Bytes(szCiphertextData, bitsCiphertextAnyLength, iLen);
  500.  
  501. 	
  502. 	DecryptAnyLength(szCiphertextData, iLen>>3, 0);
  503.  
  504. 	char *temp=GetPlaintextAnyLength();
  505. 	return A2W(temp);
  506. }

md5.h 

  1. #pragma once
  2.  
  3. typedef struct
  4. {
  5. 	unsigned int count[2];
  6. 	unsigned int state[4];
  7. 	unsigned char buffer[64];
  8. }MD5_CTX;
  9.  
  10.  
  11. #define F(x,y,z) ((x & y) | (~x & z))  
  12. #define G(x,y,z) ((x & z) | (y & ~z))  
  13. #define H(x,y,z) (x^y^z)  
  14. #define I(x,y,z) (y ^ (x | ~z))  
  15. #define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))  
  16. #define FF(a,b,c,d,x,s,ac) \
  17. {\
  18. a += F(b, c, d) + x + ac; \
  19. a = ROTATE_LEFT(a, s); \
  20. a += b; \
  21. }
  22. #define GG(a,b,c,d,x,s,ac) \
  23. { \
  24. a += G(b, c, d) + x + ac; \
  25. a = ROTATE_LEFT(a, s); \
  26. a += b; \
  27. }
  28. #define HH(a,b,c,d,x,s,ac) \
  29. { \
  30. a += H(b, c, d) + x + ac; \
  31. a = ROTATE_LEFT(a, s); \
  32. a += b; \
  33. }
  34. #define II(a,b,c,d,x,s,ac) \
  35. { \
  36. a += I(b, c, d) + x + ac; \
  37. a = ROTATE_LEFT(a, s); \
  38. a += b; \
  39. }
  40.  
  41. class CMD5
  42. {
  43. public:
  44. 	CMD5();
  45. 	~CMD5();
  46. 	void MD5Init(MD5_CTX *context);
  47. 	void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen);
  48. 	void MD5Final(MD5_CTX *context, unsigned char digest[16]);
  49. 	void MD5Transform(unsigned int state[4], unsigned char block[64]);
  50. 	void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);
  51. 	void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);
  52. 	CString Encrypt16(CString str);
  53. 	CString Encrypt32(CString str);
  54. };

md5.cpp 

  1. #include "stdafx.h"
  2. #include "MD5.h"
  3.  
  4.  
  5. unsigned char PADDING[] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  6. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  7. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  8. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  9.  
  10. CMD5::CMD5()
  11. {
  12.  
  13. }
  14.  
  15.  
  16. CMD5::~CMD5()
  17. {
  18. }
  19.  
  20.  
  21.  
  22. void CMD5::MD5Init(MD5_CTX *context)
  23. {
  24. 	context->count[0] = 0;
  25. 	context->count[1] = 0;
  26. 	context->state[0] = 0x67452301;
  27. 	context->state[1] = 0xEFCDAB89;
  28. 	context->state[2] = 0x98BADCFE;
  29. 	context->state[3] = 0x10325476;
  30. }
  31. void CMD5::MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)
  32. {
  33. 	unsigned int i = 0, index = 0, partlen = 0;
  34. 	index = (context->count[0] >> 3) & 0x3F;
  35. 	partlen = 64 - index;
  36. 	context->count[0] += inputlen << 3;
  37. 	if (context->count[0] < (inputlen << 3))
  38. 		context->count[1]++;
  39. 	context->count[1] += inputlen >> 29;
  40.  
  41. 	if (inputlen >= partlen)
  42. 	{
  43. 		memcpy(&context->buffer[index], input, partlen);
  44. 		MD5Transform(context->state, context->buffer);
  45. 		for (i = partlen; i + 64 <= inputlen; i += 64)
  46. 			MD5Transform(context->state, &input[i]);
  47. 		index = 0;
  48. 	}
  49. 	else
  50. 	{
  51. 		i = 0;
  52. 	}
  53. 	memcpy(&context->buffer[index], &input[i], inputlen - i);
  54. }
  55. void CMD5::MD5Final(MD5_CTX *context, unsigned char digest[16])
  56. {
  57. 	unsigned int index = 0, padlen = 0;
  58. 	unsigned char bits[8];
  59. 	index = (context->count[0] >> 3) & 0x3F;
  60. 	padlen = (index < 56) ? (56 - index) : (120 - index);
  61. 	MD5Encode(bits, context->count, 8);
  62. 	MD5Update(context, PADDING, padlen);
  63. 	MD5Update(context, bits, 8);
  64. 	MD5Encode(digest, context->state, 16);
  65. }
  66. void CMD5::MD5Encode(unsigned char *output, unsigned int *input, unsigned int len)
  67. {
  68. 	unsigned int i = 0, j = 0;
  69. 	while (j < len)
  70. 	{
  71. 		output[j] = input[i] & 0xFF;
  72. 		output[j + 1] = (input[i] >> 8) & 0xFF;
  73. 		output[j + 2] = (input[i] >> 16) & 0xFF;
  74. 		output[j + 3] = (input[i] >> 24) & 0xFF;
  75. 		i++;
  76. 		j += 4;
  77. 	}
  78. }
  79. void CMD5::MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)
  80. {
  81. 	unsigned int i = 0, j = 0;
  82. 	while (j < len)
  83. 	{
  84. 		output[i] = (input[j]) |
  85. 			(input[j + 1] << 8) |
  86. 			(input[j + 2] << 16) |
  87. 			(input[j + 3] << 24);
  88. 		i++;
  89. 		j += 4;
  90. 	}
  91. }
  92. void CMD5::MD5Transform(unsigned int state[4], unsigned char block[64])
  93. {
  94. 	unsigned int a = state[0];
  95. 	unsigned int b = state[1];
  96. 	unsigned int c = state[2];
  97. 	unsigned int d = state[3];
  98. 	unsigned int x[64];
  99. 	MD5Decode(x, block, 64);
  100. 	FF(a, b, c, d, x[0], 7, 0xd76aa478);
  101. 	FF(d, a, b, c, x[1], 12, 0xe8c7b756);
  102. 	FF(c, d, a, b, x[2], 17, 0x242070db);
  103. 	FF(b, c, d, a, x[3], 22, 0xc1bdceee);
  104. 	FF(a, b, c, d, x[4], 7, 0xf57c0faf);
  105. 	FF(d, a, b, c, x[5], 12, 0x4787c62a);
  106. 	FF(c, d, a, b, x[6], 17, 0xa8304613);
  107. 	FF(b, c, d, a, x[7], 22, 0xfd469501);
  108. 	FF(a, b, c, d, x[8], 7, 0x698098d8);
  109. 	FF(d, a, b, c, x[9], 12, 0x8b44f7af);
  110. 	FF(c, d, a, b, x[10], 17, 0xffff5bb1);
  111. 	FF(b, c, d, a, x[11], 22, 0x895cd7be);
  112. 	FF(a, b, c, d, x[12], 7, 0x6b901122);
  113. 	FF(d, a, b, c, x[13], 12, 0xfd987193);
  114. 	FF(c, d, a, b, x[14], 17, 0xa679438e);
  115. 	FF(b, c, d, a, x[15], 22, 0x49b40821);
  116.  
  117.  
  118. 	GG(a, b, c, d, x[1], 5, 0xf61e2562);
  119. 	GG(d, a, b, c, x[6], 9, 0xc040b340);
  120. 	GG(c, d, a, b, x[11], 14, 0x265e5a51);
  121. 	GG(b, c, d, a, x[0], 20, 0xe9b6c7aa);
  122. 	GG(a, b, c, d, x[5], 5, 0xd62f105d);
  123. 	GG(d, a, b, c, x[10], 9, 0x2441453);
  124. 	GG(c, d, a, b, x[15], 14, 0xd8a1e681);
  125. 	GG(b, c, d, a, x[4], 20, 0xe7d3fbc8);
  126. 	GG(a, b, c, d, x[9], 5, 0x21e1cde6);
  127. 	GG(d, a, b, c, x[14], 9, 0xc33707d6);
  128. 	GG(c, d, a, b, x[3], 14, 0xf4d50d87);
  129. 	GG(b, c, d, a, x[8], 20, 0x455a14ed);
  130. 	GG(a, b, c, d, x[13], 5, 0xa9e3e905);
  131. 	GG(d, a, b, c, x[2], 9, 0xfcefa3f8);
  132. 	GG(c, d, a, b, x[7], 14, 0x676f02d9);
  133. 	GG(b, c, d, a, x[12], 20, 0x8d2a4c8a);
  134.  
  135.  
  136. 	HH(a, b, c, d, x[5], 4, 0xfffa3942);
  137. 	HH(d, a, b, c, x[8], 11, 0x8771f681);
  138. 	HH(c, d, a, b, x[11], 16, 0x6d9d6122);
  139. 	HH(b, c, d, a, x[14], 23, 0xfde5380c);
  140. 	HH(a, b, c, d, x[1], 4, 0xa4beea44);
  141. 	HH(d, a, b, c, x[4], 11, 0x4bdecfa9);
  142. 	HH(c, d, a, b, x[7], 16, 0xf6bb4b60);
  143. 	HH(b, c, d, a, x[10], 23, 0xbebfbc70);
  144. 	HH(a, b, c, d, x[13], 4, 0x289b7ec6);
  145. 	HH(d, a, b, c, x[0], 11, 0xeaa127fa);
  146. 	HH(c, d, a, b, x[3], 16, 0xd4ef3085);
  147. 	HH(b, c, d, a, x[6], 23, 0x4881d05);
  148. 	HH(a, b, c, d, x[9], 4, 0xd9d4d039);
  149. 	HH(d, a, b, c, x[12], 11, 0xe6db99e5);
  150. 	HH(c, d, a, b, x[15], 16, 0x1fa27cf8);
  151. 	HH(b, c, d, a, x[2], 23, 0xc4ac5665);
  152.  
  153.  
  154. 	II(a, b, c, d, x[0], 6, 0xf4292244);
  155. 	II(d, a, b, c, x[7], 10, 0x432aff97);
  156. 	II(c, d, a, b, x[14], 15, 0xab9423a7);
  157. 	II(b, c, d, a, x[5], 21, 0xfc93a039);
  158. 	II(a, b, c, d, x[12], 6, 0x655b59c3);
  159. 	II(d, a, b, c, x[3], 10, 0x8f0ccc92);
  160. 	II(c, d, a, b, x[10], 15, 0xffeff47d);
  161. 	II(b, c, d, a, x[1], 21, 0x85845dd1);
  162. 	II(a, b, c, d, x[8], 6, 0x6fa87e4f);
  163. 	II(d, a, b, c, x[15], 10, 0xfe2ce6e0);
  164. 	II(c, d, a, b, x[6], 15, 0xa3014314);
  165. 	II(b, c, d, a, x[13], 21, 0x4e0811a1);
  166. 	II(a, b, c, d, x[4], 6, 0xf7537e82);
  167. 	II(d, a, b, c, x[11], 10, 0xbd3af235);
  168. 	II(c, d, a, b, x[2], 15, 0x2ad7d2bb);
  169. 	II(b, c, d, a, x[9], 21, 0xeb86d391);
  170. 	state[0] += a;
  171. 	state[1] += b;
  172. 	state[2] += c;
  173. 	state[3] += d;
  174. }
  175.  
  176. CString CMD5::Encrypt16(CString str)
  177. {
  178. 	MD5_CTX md5;
  179. 	MD5Init(&md5);
  180. 	int i;
  181. 	USES_CONVERSION;
  182. 	char *chTemp = T2A(str);
  183. 	unsigned char *encrypt = (unsigned char*)chTemp;// = T2A(str);//21232f297a57a5a743894a0e4a801fc3  
  184. 	
  185. 	unsigned char decrypt[16];
  186. 	MD5Update(&md5, encrypt, strlen((char *)encrypt));
  187. 	MD5Final(&md5, decrypt);
  188. 	CString szRe;
  189. 	for (i = 4; i < 12; i++)
  190. 	{
  191. 		CString strtemp;
  192. 		strtemp.Format(L"%02x", decrypt[i]);
  193. 		szRe += strtemp;
  194. 		printf("%02x", decrypt[i]);  //02x前需要加上 %  
  195. 	}
  196. 	return szRe;
  197. }
  198. CString CMD5::Encrypt32(CString str)
  199. {
  200. 	MD5_CTX md5;
  201. 	MD5Init(&md5);
  202. 	int i;
  203. 	USES_CONVERSION;
  204. 	char *chTemp = T2A(str);
  205. 	unsigned char *encrypt = (unsigned char*)chTemp;// = T2A(str);//21232f297a57a5a743894a0e4a801fc3  
  206.  
  207. 	unsigned char decrypt[16];
  208. 	MD5Update(&md5, encrypt, strlen((char *)encrypt));
  209. 	MD5Final(&md5, decrypt);
  210. 	CString szRe;
  211. 	for (i = 0; i < 16; i++)
  212. 	{
  213. 		CString strtemp;
  214. 		strtemp.Format(L"%02x", decrypt[i]);
  215. 		szRe += strtemp;
  216. 		printf("%02x", decrypt[i]);  //02x前需要加上 %  
  217. 	}
  218. 	return szRe;
  219. }


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/990852
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号