Base64加密解密原理以及代码实现（VC++）

Base64加密解密原理以及代码实现

转自：http://blog.csdn.net/jacky_dai/article/details/4698461

1. Base64使用A--Z,a--z,0--9,+,/ 这64个字符.
    2. 编码原理:将3个字节转换成4个字节( (3 X 8) = 24 = (4 X 6) )先读入3个字节,每读一个字节,左移8位,再右移四次,每次6位,这样就有4个字节了.
    3. 解码原理:将4个字节转换成3个字节.先读入4个6位(用或运算),每次左移6位,再右移3次,每次8位.这样就还原了.

Base64是一种很常见的编码规范，其作用是将二进制序列转换为人类可读的ASCII字符序列，常用在需用通过文本协议（比如HTTP和SMTP）来传输二进制数据的情况下。Base64并不是一种用于安全领域的加密解密算法（这类算法有DES等），尽管我们有时也听到使用Base64来加密解密的说法，但这里所说的加密与解密实际是指编码（encode）和解码（decode）的过程，其变换是非常简单的，仅仅能够避免信息被直接识别。

Base64采用了一种很简单的编码转换：对于待编码数据，以3个字节为单位，依次取6位数据并在前面补上两个0形成新的8位编码，由于3*8=4*6，这样3个字节的输入会变成4个字节的输出，长度上增加了1/3。

上面的处理还不能保证得到的字符都是可见字符，为了达到此目的，Base64制定了一个编码表，进行统一的转换。码表的大小为2^6=64，这也是Base64名称的由来。

Base64编码表

Value Encoding  Value Encoding  Value Encoding  Value Encoding
           0 A            17 R            34 i            51 z
           1 B            18 S            35 j            52 0
           2 C            19 T            36 k            53 1
           3 D            20 U            37 l            54 2
           4 E            21 V            38 m           55 3
           5 F            22 W           39 n           56 4
           6 G            23 X            40 o            57 5
           7 H            24 Y             41 p            58 6
           8 I            25 Z             42 q            59 7
           9 J            26 a             43 r             60 8
          10 K            27 b            44 s            61 9
          11 L            28 c            45 t             62 +
          12 M            29 d           46 u            63 /
          13 N            30 e           47 v
          14 O            31 f            48 w         (pad) =
          15 P            32 g           49 x
          16 Q            33 h           50 y

Base64编解码算法都很简单，网上有很多源码，这里就不介绍了。

另外还有一点要注意的地方，前面提到编码是以3个字节为单位，当剩下的字符数量不足3个字节时，则应使用0进行填充，相应的，输出字符则使用‘=‘占位，因此编码后输出的文本末尾可能会出现1至2个‘=‘。

这是一种典型的编码转换的处理方法，类似的可能还有UTF16与UTF8之间的转换。

[cpp] view plaincopy

  1. /**
  2. * /file base64.h
  3. */
  4. #ifndef XYSSL_BASE64_H
  5. #define XYSSL_BASE64_H
  6. #define XYSSL_ERR_BASE64_BUFFER_TOO_SMALL -0x0010
  7. #define XYSSL_ERR_BASE64_INVALID_CHARACTER -0x0012
  8. #ifdef __cplusplus
  9. extern "C" {
  10. #endif
  11. /**
  12. * /brief Encode a buffer into base64 format
  13. *
  14. * /param dst destination buffer
  15. * /param dlen size of the buffer
  16. * /param src source buffer
  17. * /param slen amount of data to be encoded
  18. *
  19. * /return 0 if successful, or XYSSL_ERR_BASE64_BUFFER_TOO_SMALL.
  20. * *dlen is always updated to reflect the amount
  21. * of data that has (or would have) been written.
  22. *
  23. * /note Call this function with *dlen = 0 to obtain the
  24. * required buffer size in *dlen
  25. */
  26. int base64_encode(const unsigned char *src, int slen,unsigned char *dst, int *dlen);
  27. /**
  28. * /brief Decode a base64-formatted buffer
  29. *
  30. * /param dst destination buffer
  31. * /param dlen size of the buffer
  32. * /param src source buffer
  33. * /param slen amount of data to be decoded
  34. *
  35. * /return 0 if successful, XYSSL_ERR_BASE64_BUFFER_TOO_SMALL, or
  36. * XYSSL_ERR_BASE64_INVALID_DATA if the input data is not
  37. * correct. *dlen is always updated to reflect the amount
  38. * of data that has (or would have) been written.
  39. *
  40. * /note Call this function with *dlen = 0 to obtain the
  41. * required buffer size in *dlen
  42. */
  43. int base64_decode(const unsigned char *src, int slen,unsigned char *dst, int *dlen);
  44. /**
  45. * /brief Checkup routine
  46. *
  47. * /return 0 if successful, or 1 if the test failed
  48. */
  49. int base64_self_test( int verbose );
  50. #ifdef __cplusplus
  51. }
  52. #endif
  53. class CBase64
  54. {
  55. public:
  56. CBase64();
  57. virtual ~CBase64();
  58. static BOOL Encrypt(const unsigned char *pSrc,int iSlen,unsigned char *pDst,int *iDlen,CString &strErrorInfo);
  59. static BOOL Decrypt(const unsigned char *pSrc,int iSlen,unsigned char *pDst,int *iDlen,CString &strErrorInfo);
  60. private:
  61. };
  62. #endif /* base64.h */

[cpp] view plaincopy

  1. //source file: base64.cpp
  2. /*
  3. * RFC 1521 base64 encoding/decoding
  4. *
  5. * Copyright (C) 2006-2007 Christophe Devine
  6. *
  7. * This library is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU Lesser General Public
  9. * License, version 2.1 as published by the Free Software Foundation.
  10. *
  11. * This library is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with this library; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19. * MA 02110-1301 USA
  20. */
  21. #include "stdafx.h"
  22. #include "base64.h"
  23. static const unsigned char base64_enc_map[64] =
  24. {
  25. ‘A‘, ‘B‘, ‘C‘, ‘D‘, ‘E‘, ‘F‘, ‘G‘, ‘H‘, ‘I‘, ‘J‘,
  26. ‘K‘, ‘L‘, ‘M‘, ‘N‘, ‘O‘, ‘P‘, ‘Q‘, ‘R‘, ‘S‘, ‘T‘,
  27. ‘U‘, ‘V‘, ‘W‘, ‘X‘, ‘Y‘, ‘Z‘, ‘a‘, ‘b‘, ‘c‘, ‘d‘,
  28. ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘, ‘m‘, ‘n‘,
  29. ‘o‘, ‘p‘, ‘q‘, ‘r‘, ‘s‘, ‘t‘, ‘u‘, ‘v‘, ‘w‘, ‘x‘,
  30. ‘y‘, ‘z‘, ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘,
  31. ‘8‘, ‘9‘, ‘+‘, ‘/‘
  32. };
  33. static const unsigned char base64_dec_map[128] =
  34. {
  35. 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  36. 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  37. 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  38. 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  39. 127, 127, 127, 62, 127, 127, 127, 63, 52, 53,
  40. 54, 55, 56, 57, 58, 59, 60, 61, 127, 127,
  41. 127, 64, 127, 127, 127, 0, 1, 2, 3, 4,
  42. 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
  43. 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
  44. 25, 127, 127, 127, 127, 127, 127, 26, 27, 28,
  45. 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
  46. 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
  47. 49, 50, 51, 127, 127, 127, 127, 127
  48. };
  49. /*
  50. * Encode a buffer into base64 format
  51. */
  52. int base64_encode(const unsigned char *src, int slen,unsigned char *dst, int *dlen)
  53. {
  54. int i, n;
  55. int C1, C2, C3;
  56. unsigned char *p;
  57. if( slen == 0 )
  58. return( 0 );
  59. n = (slen << 3) / 6;
  60. switch( (slen << 3) - (n * 6) )
  61. {
  62. case 2: n += 3; break;
  63. case 4: n += 2; break;
  64. default: break;
  65. }
  66. if( *dlen < n + 1 )
  67. {
  68. *dlen = n + 1;
  69. return( XYSSL_ERR_BASE64_BUFFER_TOO_SMALL );
  70. }
  71. n = (slen / 3) * 3;
  72. for( i = 0, p = dst; i < n; i += 3 )
  73. {
  74. C1 = *src++;
  75. C2 = *src++;
  76. C3 = *src++;
  77. *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
  78. *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
  79. *p++ = base64_enc_map[(((C2 & 15) << 2) + (C3 >> 6)) & 0x3F];
  80. *p++ = base64_enc_map[C3 & 0x3F];
  81. }
  82. if( i < slen )
  83. {
  84. C1 = *src++;
  85. C2 = ((i + 1) < slen) ? *src++ : 0;
  86. *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
  87. *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
  88. if( (i + 1) < slen )
  89. *p++ = base64_enc_map[((C2 & 15) << 2) & 0x3F];
  90. else *p++ = ‘=‘;
  91. *p++ = ‘=‘;
  92. }
  93. *dlen =static_cast<int>(p - dst);
  94. *p = 0;
  95. return( 0 );
  96. }
  97. /*
  98. * Decode a base64-formatted buffer
  99. */
  100. int base64_decode(const unsigned char *src, int slen,unsigned char *dst, int *dlen)
  101. {
  102. int i, j, n;
  103. unsigned long x;
  104. unsigned char *p;
  105. for( i = j = n = 0; i < slen; i++ )
  106. {
  107. if( ( slen - i ) >= 2 &&
  108. *(src+i) == ‘/r‘ && *(src+i+1) == ‘/n‘ )
  109. continue;
  110. if(*(src+i) == ‘/n‘ )
  111. continue;
  112. if(*(src+i) == ‘=‘ && ++j > 2 )
  113. return( XYSSL_ERR_BASE64_INVALID_CHARACTER );
  114. if(*(src+i) > 127 || base64_dec_map[*(src+i)] == 127 )
  115. return( XYSSL_ERR_BASE64_INVALID_CHARACTER );
  116. if( base64_dec_map[*(src+i)] < 64 && j != 0 )
  117. return( XYSSL_ERR_BASE64_INVALID_CHARACTER );
  118. n++;
  119. }
  120. if( n == 0 )
  121. return( 0 );
  122. n = ((n * 6) + 7) >> 3;
  123. if( *dlen < n )
  124. {
  125. *dlen = n;
  126. return( XYSSL_ERR_BASE64_BUFFER_TOO_SMALL );
  127. }
  128. for( j = 3, n = x = 0, p = dst; i > 0; i--, src++ )
  129. {
  130. if( *src == ‘/r‘ || *src == ‘/n‘ )
  131. continue;
  132. j -= ( base64_dec_map[*src] == 64 );
  133. x = (x << 6) | ( base64_dec_map[*src] & 0x3F );
  134. if( ++n == 4 )
  135. {
  136. n = 0;
  137. if( j > 0 ) *p++ = (unsigned char)( x >> 16 );
  138. if( j > 1 ) *p++ = (unsigned char)( x >> 8 );
  139. if( j > 2 ) *p++ = (unsigned char)( x );
  140. }
  141. }
  142. *dlen =static_cast<int>(p - dst);
  143. return( 0 );
  144. }
  145. BOOL CBase64::Encrypt(const unsigned char *pSrc,int iSlen,unsigned char *pDst,int *iDlen,CString &strErrorInfo)
  146. {
  147. strErrorInfo=_T("");
  148. int iRet=base64_encode(pSrc,iSlen,pDst,iDlen);
  149. if(iRet==XYSSL_ERR_BASE64_BUFFER_TOO_SMALL)
  150. strErrorInfo=_T("分配的缓冲区太小!");
  151. else if(iRet==XYSSL_ERR_BASE64_INVALID_CHARACTER)
  152. strErrorInfo=_T("无效数据!");
  153. return iRet==0;
  154. }
  155. BOOL CBase64::Decrypt(const unsigned char *pSrc,int iSlen,unsigned char *pDst,int *iDlen,CString &strErrorInfo)
  156. {
  157. strErrorInfo=_T("");
  158. int iRet=base64_decode(pSrc,iSlen,pDst,iDlen);
  159. if(iRet==XYSSL_ERR_BASE64_BUFFER_TOO_SMALL)
  160. strErrorInfo=_T("分配的缓冲区太小!");
  161. else if(iRet==XYSSL_ERR_BASE64_INVALID_CHARACTER)
  162. strErrorInfo=_T("无效数据!");
  163. return iRet==0;
  164. }
时间： 2024-10-10 02:14:09

Base64加密解密原理以及代码实现（VC++）的相关文章

Base64加密解密原理以及代码实现

1. Base64使用A--Z,a--z,0--9,+,/ 这64个字符.    2. 编码原理:将3个字节转换成4个字节( (3 X 8) = 24 = (4 X 6) )先读入3个字节,每读一个字节,左移8位,再右移四次,每次6位,这样就有4个字节了.    3. 解码原理:将4个字节转换成3个字节.先读入4个6位(用或运算),每次左移6位,再右移3次,每次8位.这样就还原了. Base64是一种非经常见的编码规范,其作用是将二进制序列转换为人类可读的ASCII字符序列,经常使用在需用通过文

Java Base64加密、解密原理Java代码

Java Base64加密.解密原理Java代码 转自:http://blog.csdn.net/songylwq/article/details/7578905 Base64是什么: Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一,大家可以查看RFC2045-RFC2049,上面有MIME的详细规范.Base64编码可用于在HTTP环境下传递较长的标识信息.例如,在Java Persistence系统Hibernate中,就采用了Base64来将一个较长的唯一标识符(一般为

【代码笔记】3DES+Base64加密解密

一,工程目录. 二,代码. RootViewController.m #import "RootViewController.h" #import "NSString+TripleDES.h" #import "GTMBase64.h" @interface RootViewController () @end @implementation RootViewController - (id)initWithNibName:(NSString *

密码学——Java BASE64加密解密

Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一,大家可以查看RFC2045-RFC2049,上面有MIME的详细规范.Base64编码可用于在HTTP环境下传递较长的标识信息.例如,在Java Persistence系统Hibernate中,就采用了Base64来将一个较长的唯一标识符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数.在其他应用程序中,也常常需要把二进制数据编码为适合放在URL(包括隐藏表单域)中的形式.此

Base64 URL image CSS &amp; 在线base64 加密/解密 link: $ svg path 线宽：stroke-width

Base64 URL image CSSData URI scheme是在RFC2397中定义的svg path 线宽:stroke-width 在线base64 加密/解密 link: 那么这是什么呢?这是Data URI scheme. Data URI scheme是在RFC2397中定义的,目的是将一些小的数据,直接嵌入到网页中,从而不用再从外部文件载入.比如上面那串字符,其实是一张小图片,将这些字符复制黏贴到火狐的地址栏中并转到,就能看到它了,一张1X36的白灰png图片. 在上面的D

Openssl加密解密原理与命令使用--尚未完善

Openssl加密解密原理: 示例: 比如A与B通信发送数据: 加密原理: 在A把要发送的内容通过单向加密方式进行数据指纹计算,计算出数据指纹后,会用自己的私钥加密数据指纹,并把加密的数据指纹添加到原数据的后面.然后对整个数据(原数据+数据指纹)进行对称加密算法进行计算(让明文转换成密文),得出的数据为整个数据的密码,再用B的公钥进行这个密码进行加密,并放到这个数据的后面一并发给B. 解密原理: 1.B用自己的私钥能够解密---------至此说明数据保密的. 2.B用私钥解密出来的密码,去解密

Linux运维之加密/解密原理、自建CA及搭建基于https的Apache

上几次博文我们具体讨论了Apache(httpd)的基础知识: HTTP协议基础(参见博文:http://sweetpotato.blog.51cto.com/533893/1656137) Apache2.2的基本配置(参见博文:http://sweetpotato.blog.51cto.com/533893/1657668) Apache2.2的虚拟主机(参见博文:http://sweetpotato.blog.51cto.com/533893/1660229) 本次博文我们具体讨论下加密/

Java android DES+Base64加密解密

服务器与客户端加密解密传输, 中间遇到各种坑,客户端无论用AES还是DES解密时都会出现错误,后来才看到好多人说要用AES/DES加完密后还要BASE64加密,照做时发现android和java的Base64加密解密不一致,只好不使用java或android的Base64重新在网上找了一个,感谢以下两位提供的代码,两段分别转载自以下博客. https://www.cnblogs.com/xuhaiqing/archive/2013/03/12/2955837.html https://www.c

c#中base64加密解密

using System; using System.Text; namespace Common { /// <summary> /// 实现Base64加密解密 /// </summary> public sealed class Base64 { /// <summary> /// Base64加密 /// </summary> /// <param name="codeName">加密采用的编码方式</param