关于Base64编码

时间 2019-11-12

原文原文链接

做者：唐风html

Base 64是一种比较古老的编码方式，在通讯中很是常见。它实现很简单。ui

What？

“Base64是一种基于64个可打印字符来表示二进制数据的表示方法（来自维基）”。这句话我一开始没有看懂，如今我用我懂的方式再解释一下：咱们能够把通讯的数据流分为两种，“二进制流”和“文本流”。（注意，后面的定义并不严谨）。文本流是指数据串是以“人类可读的字符”组成的，数据流中出现的 0x00，0x0a，0x0d 等数据通常都是特殊的控制数据（文本结束，或是换行、或者是其它的），而不是数据自己。二进制流是任意的一串数据（每一个字节能够是从 0x00 到 0xff 的值，而不限于字符）。Base64 编码就是用可打印字符（A-Z，a-z，0-9，+/这64个“字符”）组成的“文本流”来表示任意的二进制流数据的一种编码方法。也就是：任意的二进制流，经过base64编码后会变成一串只由可见字符（A-Z，a-z，0-9，+/这64个“字符”）组成的文本数据流。编码

完整的base64定义可见参考RFC 1421和RFC 2045。spa

Why？

Base64有什么用？！base 64编码后的数据流会比原数据流更长（是原数据流长度的4/3，缘由见How的部分），那为何还要用这种方式进行编码呢？（一开始我很不理解的地方）设计

缘由是：通讯设备的种类繁多，设计各异，好比有些设备只能处理/传输7bit的数据，有些设备的通讯模块只能处理文本流，等等，为了保证在这些设备之间仍然能无障碍地进行任何二进制数据（8bit为单位）的通讯，就把这些数据从新编码成只由可打印字符组成的文本流。base64中选取的可打印字符几乎在任何设备上都支持（字符集采用US-ASCII标准）。另外还常会见到的一个场景是，要求数据从控制台（或者其它输入/输出设备）输入或是输出，因为这些输入输出设备只支持文本操做或显示，因此也须要把二进制数据流在可打印字符集之间进行转换（编解码）。 htm

How？

Base64编码其实很简单。将二进制数据流每三个字符一组进行分组（24bit），分组后，将24bit分红4个6bit数据，为每6bit数据前加上2个bit的0，就会获得4个8bit数据（变成了4byte），每一个byte的值都在0-63的范围之间。而后按预先设定的转换表，把这些值转换成对应的可打印字符。blog

前文本中引用的维基百科内容说明得也比较清楚。ip

过程参考下图：ci

这里有一个小细节须要注意，那就是若是要编码的数据串长度不是 3 的整数倍的状况下，须要在数据串后面补充若干（假设是N）个0x00使得数据长度刚好为 3 的整数倍。而后再进行处理。获得相应的base64字符流数据后，再把串最后面的N个A换成=号。get

Base64的解码过程只须要反过来就能够了。

下面是C++的代码实现

    Base 64 encoding and decoding 
  
 
   vector 
   < 
   char 
   > Bin2Base64( 
   vector 
   < 
   uint8_t 
   >  
   const 
   &  
   _bin 
   ) { 
   
      
    
   static 
     
   char 
     
   const 
    convert_table[] =  
   "ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" 
   ; 
   
 
   
      
    
   vector 
   < 
   char 
   > output; 
   
      
   output.reserve(( 
   _bin 
   .size() * 4) / 3); 
   
 
   
      
    
   auto 
    con_3bytes_to_4bytes = [&]( 
   uint8_t 
     
   const 
    *  
   _3bytes_bin_data 
   ) { 
   
          
   output.push_back(convert_table[ 
   _3bytes_bin_data 
   [0] >> 2]); 
   
          
   output.push_back(convert_table[(( 
   _3bytes_bin_data 
   [0] & 0x03) << 4) | (( 
   _3bytes_bin_data 
   [1] >> 4) & 0x0f)]); 
   
          
   output.push_back(convert_table[(( 
   _3bytes_bin_data 
   [1] << 2) & 0x3c) | ( 
   _3bytes_bin_data 
   [2] >> 6)]); 
   
          
   output.push_back(convert_table[ 
   _3bytes_bin_data 
   [2] & 0x3f]); 
   
      
   }; 
   
 
   
      
    
   auto 
    i = 0u; 
   
      
    
   for 
    (; (i + 3) <=  
   _bin 
   .size(); i += 3) { 
   
          
   con_3bytes_to_4bytes(& 
   _bin 
   [i]); 
   
      
   } 
   
 
   
      
    
   if 
    (i !=  
   _bin 
   .size()) { 
   
          
    
   uint8_t 
    left_data[3] = { 0 }; 
   
          
   std::copy(begin( 
   _bin 
   ) + i, end( 
   _bin 
   ), left_data); 
   
          
   con_3bytes_to_4bytes(left_data); 
   
          
   std::fill(rbegin(output), rbegin(output) + (3 - ( 
   _bin 
   .size() % 3)),  
   '=' 
   ); 
   
      
   }     
   
 
   
      
    
   return 
    output; 
   
 
   } 
   
 
   
 
   vector 
   < 
   uint8_t 
   > Base64ToBin( 
   vector 
   < 
   char 
   >  
   const 
    &  
   _base64stream 
   ) { 
   
      
    
   vector 
   < 
   uint8_t 
   > output; 
   
      
   output.reserve( 
   _base64stream 
   .size() * 3 / 4); 
   
 
   
      
    
   static 
     
   hash_map 
   < 
   char 
   ,  
   uint8_t 
   > convert_table = { 
   
              
   {  
   'A' 
   , 0  }, {  
   'B' 
   , 1  }, {  
   'C' 
   , 2  }, {  
   'D' 
   , 3  }, {  
   'E' 
   , 4  }, {  
   'F' 
   , 5  }, {  
   'G' 
   , 6  }, {  
   'H' 
   , 7  }, 
   
              
   {  
   'I' 
   , 8  }, {  
   'J' 
   , 9  }, {  
   'K' 
   , 10 }, {  
   'L' 
   , 11 }, {  
   'M' 
   , 12 }, {  
   'N' 
   , 13 }, {  
   'O' 
   , 14 }, {  
   'P' 
   , 15 }, 
   
              
   {  
   'Q' 
   , 16 }, {  
   'R' 
   , 17 }, {  
   'S' 
   , 18 }, {  
   'T' 
   , 19 }, {  
   'U' 
   , 20 }, {  
   'V' 
   , 21 }, {  
   'W' 
   , 22 }, {  
   'X' 
   , 23 }, 
   
              
   {  
   'Y' 
   , 24 }, {  
   'Z' 
   , 25 }, {  
   'a' 
   , 26 }, {  
   'b' 
   , 27 }, {  
   'c' 
   , 28 }, {  
   'd' 
   , 29 }, {  
   'e' 
   , 30 }, {  
   'f' 
   , 31 }, 
   
              
   {  
   'g' 
   , 32 }, {  
   'h' 
   , 33 }, {  
   'i' 
   , 34 }, {  
   'j' 
   , 35 }, {  
   'k' 
   , 36 }, {  
   'l' 
   , 37 }, {  
   'm' 
   , 38 }, {  
   'n' 
   , 39 }, 
   
              
   {  
   'o' 
   , 40 }, {  
   'p' 
   , 41 }, {  
   'q' 
   , 42 }, {  
   'r' 
   , 43 }, {  
   's' 
   , 44 }, {  
   't' 
   , 45 }, {  
   'u' 
   , 46 }, {  
   'v' 
   , 47 }, 
   
              
   {  
   'w' 
   , 48 }, {  
   'x' 
   , 49 }, {  
   'y' 
   , 50 }, {  
   'z' 
   , 51 }, {  
   '0' 
   , 52 }, {  
   '1' 
   , 53 }, {  
   '2' 
   , 54 }, {  
   '3' 
   , 55 }, 
   
              
   {  
   '4' 
   , 56 }, {  
   '5' 
   , 57 }, {  
   '6' 
   , 58 }, {  
   '7' 
   , 59 }, {  
   '8' 
   , 60 }, {  
   '9' 
   , 61 }, {  
   '+' 
   , 62 }, {  
   '/' 
   , 63 }, 
   
              
   {  
   '=' 
   , 0 }, 
   
      
   }; 
   
 
   
      
    
   auto 
    i = 0u; 
   
      
    
   for 
    ( ; i <  
   _base64stream 
   .size(); i += 4) { 
   
          
    
   auto 
     
   const 
    byte1 = convert_table[ 
   _base64stream 
   [i]]; 
   
          
    
   auto 
     
   const 
    byte2 = convert_table[ 
   _base64stream 
   [i + 1]]; 
   
          
    
   auto 
     
   const 
    byte3 = convert_table[ 
   _base64stream 
   [i + 2]]; 
   
          
    
   auto 
     
   const 
    byte4 = convert_table[ 
   _base64stream 
   [i + 3]]; 
   
 
   
          
   output.push_back((byte1 << 2) | (byte2 >> 4)); 
   
          
   output.push_back(((byte2 & 0x0f) << 4) | (byte3 >> 2)); 
   
          
   output.push_back(((byte3 & 0x03) << 6) | byte4); 
   
      
   } 
   
 
   
      
   output.erase(end(output) - count(rbegin( 
   _base64stream 
   ), rbegin( 
   _base64stream 
   ) + 4,  
   '=' 
   ), 
   
                   
   end(output)); 
   
 
   
      
    
   return 
    output; 
   
 
   } 
  