Base64编解码规则及代码实现（原创，欢迎提意见和建议）

阿杰

1. 编码规则
   
2. Base64编码的思想是是采用64个基本的ASCII码字符对数据进行重新编码。它将需要编码的数据拆分成字节数组。以3个字节为一组。按顺序排列24位数据，再把这24位数据分成4组，即每组6位。再在每组的的最高位前补两个0凑足一个字节。这样就把一个3字节为一组的数据重新编码成了4个字节。当所要编码的数据的字节数不是3的整倍数，也就是说在分组时最后一组不够3个字节。这时在最后一组填充1到2个0字节。并在最后编码完成后在结尾替换1到2个“=”,即替换末尾的1~2个A，也就是补位。
   
3. 例：将对ABC进行BASE64编码
   
4. 首先取ABC对应的ASCII码值。A（65）B（66）C（67）。
   
5. 再取二进制值A（01000001）B（01000010）C（01000011），然后把这三个字节的二进制码接起来（010000010100001001000011），再以6位为单位分成4个数据块并在最高位填充两个0后形成4个字节的编码后的值（00010000）（00010100）（00001001）（00000011）。蓝色部分为真实数据。再把这四个字节数据转化成10进制数得（16）（20）（9）（3）。最后根据BASE64给出的64个基本字符表，查出对应的ASCII码字符（Q）（U）（J）（D）。这里的值实际就是数据在字符表中的索引。
   
6. 注BASE64字符表：ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
   
7. 
   
8. 解码规则：根据编码的规则进行逆向解码
   
9. 
   
10. 主题思想体现了 移位,& ,^ 操作 来控制2进制数据
    
11. 
    
12. 代码实现：
    
13. 
    
14. // Base64.cpp : Defines the entry point for the console application.
    
15. //
    
16. 
    
17. #include "stdafx.h"
    
18. #include "wtypes.h"
    
19. #include "string.h"
    
20. 
    
21. typedef struct _ThreeBytes_
    
22. {
    
23. _ThreeBytes_()
    
24. {
    
25. memset((void*)&byte1,0,1);
    
26. memset((void*)&byte2,0,1);
    
27. memset((void*)&byte3,0,1);
    
28. }
    
29. BYTE byte1;
    
30. BYTE byte2;
    
31. BYTE byte3;
    
32. 
    
33. }ThreeBytes,*LPThreeBytes;
    
34. 
    
35. typedef struct _FourBytes_
    
36. {
    
37. _FourBytes_()
    
38. {
    
39. memset((void*)&byte1,0,1);
    
40. memset((void*)&byte2,0,1);
    
41. memset((void*)&byte3,0,1);
    
42. memset((void*)&byte4,0,1);
    
43. }
    
44. BYTE byte1;
    
45. BYTE byte2;
    
46. BYTE byte3;
    
47. BYTE byte4;
    
48. 
    
49. }FourBytes,*LPFourBytes;
    
50. 
    
51. char strBase64[] = {"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"};
    
52. 
    
53. int FindIndex(char c)
    
54. {
    
55. for (int i=0; i<64; i++)
    
56. {
    
57. if (strBase64[i] == c)
    
58. {
    
59. return i;
    
60. }
    
61. }
    
62. return -1;
    
63. }
    
64. //规则转换函数1
    
65. void Translate3To4(LPThreeBytes pThreeBytes,LPFourBytes pFourBytes)
    
66. {
    
67. pFourBytes->byte1 = (pThreeBytes->byte1>>2)&0x3F;
    
68. pFourBytes->byte2 = ((pThreeBytes->byte2>>4)&0x0F)^((pThreeBytes->byte1<<4)&0x30);
    
69. pFourBytes->byte3 = ((((pThreeBytes->byte2<<4)&0xF0)^((pThreeBytes->byte3>>4)&0x0C))>>2)&0x3F;
    
70. pFourBytes->byte4 = pThreeBytes->byte3&0x3F;
    
71. 
    
72. pFourBytes->byte1 = (BYTE)strBase64[pFourBytes->byte1];
    
73. pFourBytes->byte2 = (BYTE)strBase64[pFourBytes->byte2];
    
74. pFourBytes->byte3 = (BYTE)strBase64[pFourBytes->byte3];
    
75. pFourBytes->byte4 = (BYTE)strBase64[pFourBytes->byte4];
    
76. }
    
77. //规则转换函数2
    
78. void Translate4To3(LPFourBytes pFourBytes,LPThreeBytes pThreeBytes)
    
79. {
    
80. FourBytes tempFourBytes;
    
81. //memcpy((void *)&tempFourBytes,pFourBytes,sizeof(FourBytes));
    
82. tempFourBytes.byte1 = (BYTE)FindIndex(pFourBytes->byte1);
    
83. tempFourBytes.byte2 = (BYTE)FindIndex(pFourBytes->byte2);
    
84. tempFourBytes.byte3 = (BYTE)FindIndex(pFourBytes->byte3);
    
85. tempFourBytes.byte4 = (BYTE)FindIndex(pFourBytes->byte4);
    
86. 
    
87. pThreeBytes->byte1 = (tempFourBytes.byte1<<2&0xFC)^(tempFourBytes.byte2>>4&0x03);
    
88. pThreeBytes->byte2 = (tempFourBytes.byte2<<4&0xF0)^(tempFourBytes.byte3>>2&0x0F);
    
89. pThreeBytes->byte3 = (tempFourBytes.byte3<<6&0xC0)^(tempFourBytes.byte4&0x3F);
    
90. }
    
91. //编码函数
    
92. void EncodeBase64(char *strSource, int nSourceLen, char *strDest)
    
93. {
    
94. 
    
95. if (strSource == NULL||nSourceLen<1)
    
96. {
    
97. return;
    
98. }
    
99. char *pSource = strSource;
    
100. char *pDest = strDest;
     
101. ThreeBytes tempThreeBytes;
     
102. FourBytes tempFourBytes;
     
103. int nPack = nSourceLen/3;
     
104. int nRemainder = nSourceLen%3;
     
105. 
     
106. for (int i=0; i<nPack; i++)
     
107. {
     
108. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
109. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
110. memcpy((void *)&tempThreeBytes,pSource,sizeof(tempThreeBytes));
     
111. Translate3To4(&tempThreeBytes,&tempFourBytes);
     
112. memcpy(pDest,(void *)&tempFourBytes,sizeof(tempFourBytes));
     
113. pSource += sizeof(tempThreeBytes);
     
114. pDest += sizeof(tempFourBytes);
     
115. }
     
116. 
     
117. if (nRemainder == 0)
     
118. {
     
119. return;
     
120. }
     
121. else if(nRemainder == 1)
     
122. {
     
123. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
124. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
125. tempThreeBytes.byte1 = strSource[nSourceLen - 1];
     
126. tempThreeBytes.byte2 = 0;
     
127. tempThreeBytes.byte3 = 0;
     
128. Translate3To4(&tempThreeBytes,&tempFourBytes);
     
129. memcpy(pDest,(void *)&tempFourBytes,sizeof(tempFourBytes));
     
130. pDest += sizeof(tempFourBytes);
     
131. pDest -=2;
     
132. *pDest = '=';
     
133. pDest++;
     
134. *pDest = '=';
     
135. }
     
136. else
     
137. {
     
138. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
139. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
140. tempThreeBytes.byte1 = strSource[nSourceLen - 2];
     
141. tempThreeBytes.byte2 = strSource[nSourceLen - 1];
     
142. tempThreeBytes.byte3 = 0;
     
143. Translate3To4(&tempThreeBytes,&tempFourBytes);
     
144. memcpy(pDest,(void *)&tempFourBytes,sizeof(tempFourBytes));
     
145. pDest += sizeof(tempFourBytes);
     
146. pDest --;
     
147. *pDest = '=';
     
148. }
     
149. 
     
150. }
     
151. //解码函数
     
152. void DecodeBase64(char *strSource, int nSourceLen, char *strDest)
     
153. {
     
154. if (strSource == NULL||nSourceLen<1)
     
155. {
     
156. return;
     
157. }
     
158. char *pSource = strSource;
     
159. char *pDest = strDest;
     
160. ThreeBytes tempThreeBytes;
     
161. FourBytes tempFourBytes;
     
162. int nPack = nSourceLen/4;
     
163. for (int i=0; i<nPack-1; i++)
     
164. {
     
165. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
166. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
167. memcpy((void *)&tempFourBytes,pSource,sizeof(tempFourBytes));
     
168. Translate4To3(&tempFourBytes,&tempThreeBytes);
     
169. memcpy(pDest,(void *)&tempThreeBytes,sizeof(tempThreeBytes));
     
170. pSource += sizeof(tempFourBytes);
     
171. pDest += sizeof(tempThreeBytes);
     
172. }
     
173. //有2个等号
     
174. if ((nSourceLen>1)&&(strSource[nSourceLen - 2]=='='))
     
175. {
     
176. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
177. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
178. memcpy((void *)&tempFourBytes,pSource,sizeof(tempFourBytes));
     
179. 
     
180. tempThreeBytes.byte1 = ((BYTE)FindIndex(tempFourBytes.byte1)<<2&0xFC)^((BYTE)FindIndex(tempFourBytes.byte2)>>4&0x03);
     
181. memcpy(pDest,(void *)&tempThreeBytes,1);
     
182. return;
     
183. }
     
184. //有1个等号
     
185. if (strSource[nSourceLen - 1] == '=')
     
186. {
     
187. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
188. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
189. memcpy((void *)&tempFourBytes,pSource,sizeof(tempFourBytes));
     
190. 
     
191. tempThreeBytes.byte1 = ((BYTE)FindIndex(tempFourBytes.byte1)<<2&0xFC)^((BYTE)FindIndex(tempFourBytes.byte2)>>4&0x03);
     
192. tempThreeBytes.byte2 = ((BYTE)FindIndex(tempFourBytes.byte2)<<4&0xF0)^((BYTE)FindIndex(tempFourBytes.byte3)>>2&0x0F);
     
193. memcpy(pDest,(void *)&tempThreeBytes,2);
     
194. return;
     
195. }
     
196. //没等号 此时少做了一次循环 再补上
     
197. memset((void *)&tempThreeBytes,0,sizeof(tempThreeBytes));
     
198. memset((void *)&tempFourBytes,0,sizeof(tempFourBytes));
     
199. memcpy((void *)&tempFourBytes,pSource,sizeof(tempFourBytes));
     
200. Translate4To3(&tempFourBytes,&tempThreeBytes);
     
201. memcpy(pDest,(void *)&tempThreeBytes,sizeof(tempThreeBytes));
     
202. // pSource += sizeof(tempFourBytes);
     
203. // pDest += sizeof(tempThreeBytes);
     
204. }
     
205. int main(int argc, char* argv[])
     
206. {
     
207. printf("编码******************************************\n");
     
208. char strInput[500] = {"娃哈哈"};
     
209. printf(""%s" Base64编码为:",strInput);
     
210. char strOutput[500] = {0};
     
211. EncodeBase64(strInput,strlen(strInput),strOutput);
     
212. printf("%s\n",strOutput);
     
213. 
     
214. printf("解码******************************************\n");
     
215. memset(strInput,0,sizeof(char)*500);
     
216. printf(""%s" Base64解码为:",strOutput);
     
217. DecodeBase64(strOutput,strlen(strOutput),strInput);
     
218. printf("%s\n",strInput);
     
219. return 0;
     
220. }
     

复制代码

来源:http://hi.baidu.com/blueapple_c/ ... b6342ecffca38b.html