C/C++编程：实现Base64编码/解码

喜欢ヅ旅行 2023-03-13 02:13 52阅读 0赞

# 原理 #

所谓 Base64，就是说选出64个字符（小写字母a-z、大写字母A-Z、数字0-9、符号"+"、符号”/“、再加上作为垫底的”=“，实际上是65个字符）作为一个基本字符集。然后其他所有符号都转换成这个字符集中的字符。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

为什么不直接用ASCII码呢？因为我们输入的字符可能有ASCII码中不可见的字符，为了完全可见，就用了base64编码。

static const unsigned char to_b64[] =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

# 看个例子 #

比如Hello这个单词，我们把它变成base64编码怎么做呢？

1.  首先引入ASCII对照表：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

1.  一个字节是8个比特，先找到对应的ASCII码，再将其转化为8位的二进制，转化如下：

*  H 对应码值为72，它对应的二进制是 01001000
 *  e对应码值为101，它对应的二进制是：01100101
 *  l对应码值为108，它对应的二进制是：01101100
 *  l对应码值为108，它对应的二进制是：01101100
 *  o对应码值为111，它对应的二进制是：01101111

1.  将上面8位一组的二进制变成6位一组的二进制，

为什么要6位一组： base64的码值是0-63，所以用6位的二进制就可以完全表示base64的码值（如：000000对应十进制0，111111对应的十进制为63）

由于上面是5\*8=40个二进制，不能被6整除，所以要加一组0将其变成48个二进制数（如果还是不能整除，还要继续补8个0，其实就是最小公倍数的倍数）。

原来：01001000 01100101 01101100 01101100 01101111 00000000

现在：010010 000110 010101 101100 011011 000110 111100 000000

1.  然后将6位一组的二进制计算出十进制，再跟base64的编码表做对比，再将最后补位的0变成=,即可得到base64字符

*  010010 对应二进制是：18， 18对应base64字符为：S
 *  000110 对应二进制是：6， 6对应base64字符为：G
 *  010101 对应二进制是：21， 21对应base64字符为：V
 *  101100 对应二进制是：44， 44对应base64字符为：s
 *  011011 对应二进制是：27， 27对应base64字符为：b
 *  000110 对应二进制是：6， 6对应base64字符为：G
 *  111100 对应二进制是：18， 18对应base64字符为：8
 *  000000 补位的0变成=

所以Hello对应的base64编码就是:SGVsbG8=

具体来说，转换方式可以分为四步：

*  将每三个字节作为一组，一共是24个二进制位（三个字节）。
 *  将这24个二进制为分为四组，每组有6个二进制位。
 *  在每组前面加上两个00，扩展成32个二进制位，即四个字节。
 *  计算四个字节中每个字节对应的十进制的值。
 *  用十进制的值作为下标，根据上面的编码表，得到扩展后的每个字节的对应符号，这就是Base64的编码值。

# 版本2 #

//
    // Created by oceanstar on 2021/8/13.
    //
    
    #ifndef OCEANSTAR_HTTP_ACL_BASE64_H
    #define OCEANSTAR_HTTP_ACL_BASE64_H
    
    namespace oceanstar{
        
        /**
         * BASE64 编码函数
         * @param in {const char*} 源数据
         * @param len {int} in 源数据的长度
         * @return unsigned char * 编码结果，需要free释放
         */
        unsigned char *acl_base64_encode( const char *in, int len);
    
    
        /**
         * BASE64 解码函数
         * @param in {const char*} 编码后的数据
         * @param len {int} in 数据长度
         * @return unsigned char * NULL: 解码失败; !=NULL: 解码成功需要free释放
         */
        unsigned char *acl_base64_decode(const char *in, int len);
    }
    #endif //OCEANSTAR_HTTP_ACL_BASE64_H

//
    // Created by oceanstar on 2021/8/13.
    //
    #include <cstdlib>
    #include "acl_base64.h"
    
    namespace oceanstar{
        
        static const unsigned char to_b64[] =
                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    
        static const unsigned char un_b64[] = {
        
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255, 255, 255, 63,
                52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255, 255, 255, 255, 255,
                255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,
                15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  255, 255, 255, 255, 255,
                255, 26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
                41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
        };
    
    #define UNSIG_CHAR_PTR(x) ((const unsigned char *)(x))
        unsigned char *acl_base64_encode( const char *in, int len){
        
            const unsigned char *cp;
            int     count, size = len * 4 /3;
    
            unsigned char * out = (unsigned char *)malloc(size + 1);
            int out_index = 0;
            for (cp = UNSIG_CHAR_PTR(in), count = len; count > 0; count -= 3, cp += 3) {
        
                out[out_index++] = to_b64[cp[0] >> 2];
                if (count > 1) {
        
                    out[out_index++] = to_b64[(cp[0] & 0x3) << 4 | cp[1] >> 4];
                    if (count > 2) {
        
                        out[out_index++] = to_b64[(cp[1] & 0xf) << 2 | cp[2] >> 6];
                        out[out_index++] = to_b64[cp[2] & 0x3f];
                    }else{
        
                        out[out_index++] = to_b64[(cp[1] & 0xf) << 2];
                        out[out_index++] = '=';
                        break;
                    }
                } else {
        
                    out[out_index++] = to_b64[(cp[0] & 0x3) << 4];
                    out[out_index++] = '=';
                    out[out_index++] = '=';
                    break;
                }
            }
            out[out_index] = 0;
            return out;
        }
    
        unsigned char *acl_base64_decode(const char *in, int len){
        
            const unsigned char *cp;
            int     count;
            int     ch0;
            int     ch1;
            int     ch2;
            int     ch3;
    
            /*
    	 * Sanity check.
    	 */
            if (len % 4)
                return (NULL);
    
    #define INVALID		0xff
    
            unsigned char * out = (unsigned char *)malloc(len + 1);
            int out_index = 0;
            for (cp = UNSIG_CHAR_PTR(in), count = 0; count < len; count += 4) {
        
                if ((ch0 = un_b64[*cp++]) == INVALID
                    || (ch1 = un_b64[*cp++]) == INVALID)
                    return (0);
                out[out_index++] = ch0 << 2 | ch1 >> 4;
                if ((ch2 = *cp++) == '=')
                    break;
                if ((ch2 = un_b64[ch2]) == INVALID)
                    return (0);
                out[out_index++] = ch1 << 4 | ch2 >> 2;
                if ((ch3 = *cp++) == '=')
                    break;
                if ((ch3 = un_b64[ch3]) == INVALID)
                    return (0);
                out[out_index++] = ch2 << 6 | ch3;
            }
    
            out[out_index] = 0;
            return out;
        }
    
    }

## 使用 ##

int main(void){
        
        const char * key = "a123456";
        char * enc = ( char *)acl_base64_encode(key, strlen(key));
        char * dec = ( char *)acl_base64_decode(enc, strlen(enc));
        printf("enc: [%s], dec: [%s]\n", enc, dec);
        free(enc);
        free(dec);
        return 0;
    }

# 版本1 #

/*base64.h*/  
    #ifndef _BASE64_H  
    #define _BASE64_H  
      
    #include <stdlib.h>  
    #include <string.h>  
      
    unsigned char *base64_encode(unsigned char *str);  
      
    unsigned char *bae64_decode(unsigned char *code);  
      
    #endif

/*base64.c*/  
    #include "base64.h"  
      
    unsigned char *base64_encode(unsigned char *str)  
    {
          
        long len;  
        long str_len;  
        unsigned char *res;  
        int i,j;  
    //定义base64编码表  
        unsigned char *base64_table="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";  
      
    //计算经过base64编码后的字符串长度  
        str_len=strlen(str);  
        if(str_len % 3 == 0)  
            len=str_len/3*4;  
        else  
            len=(str_len/3+1)*4;  
      
        res=malloc(sizeof(unsigned char)*len+1);  
        res[len]='\0';  
      
    //以3个8位字符为一组进行编码  
        for(i=0,j=0;i<len-2;j+=3,i+=4)  
        {
          
            res[i]=base64_table[str[j]>>2]; //取出第一个字符的前6位并找出对应的结果字符  
            res[i+1]=base64_table[(str[j]&0x3)<<4 | (str[j+1]>>4)]; //将第一个字符的后位与第二个字符的前4位进行组合并找到对应的结果字符  
            res[i+2]=base64_table[(str[j+1]&0xf)<<2 | (str[j+2]>>6)]; //将第二个字符的后4位与第三个字符的前2位组合并找出对应的结果字符  
            res[i+3]=base64_table[str[j+2]&0x3f]; //取出第三个字符的后6位并找出结果字符  
        }  
      
        switch(str_len % 3)  
        {
          
            case 1:  
                res[i-2]='=';  
                res[i-1]='=';  
                break;  
            case 2:  
                res[i-1]='=';  
                break;  
        }  
      
        return res;  
    }  
      
    unsigned char *base64_decode(unsigned char *code)  
    {
          
    //根据base64表，以字符找到对应的十进制数据  
        int table[]={
        0,0,0,0,0,0,0,0,0,0,0,0,
        		 0,0,0,0,0,0,0,0,0,0,0,0,
        		 0,0,0,0,0,0,0,0,0,0,0,0,
        		 0,0,0,0,0,0,0,62,0,0,0,
        		 63,52,53,54,55,56,57,58,
        		 59,60,61,0,0,0,0,0,0,0,0,
        		 1,2,3,4,5,6,7,8,9,10,11,12,
        		 13,14,15,16,17,18,19,20,21,
        		 22,23,24,25,0,0,0,0,0,0,26,
        		 27,28,29,30,31,32,33,34,35,
        		 36,37,38,39,40,41,42,43,44,
        		 45,46,47,48,49,50,51
        	       };  
        long len;  
        long str_len;  
        unsigned char *res;  
        int i,j;  
      
    //计算解码后的字符串长度  
        len=strlen(code);  
    //判断编码后的字符串后是否有=  
        if(strstr(code,"=="))  
            str_len=len/4*3-2;  
        else if(strstr(code,"="))  
            str_len=len/4*3-1;  
        else  
            str_len=len/4*3;  
      
        res=malloc(sizeof(unsigned char)*str_len+1);  
        res[str_len]='\0';  
      
    //以4个字符为一位进行解码  
        for(i=0,j=0;i < len-2;j+=3,i+=4)  
        {
          
            res[j]=((unsigned char)table[code[i]])<<2 | (((unsigned char)table[code[i+1]])>>4); //取出第一个字符对应base64表的十进制数的前6位与第二个字符对应base64表的十进制数的后2位进行组合  
            res[j+1]=(((unsigned char)table[code[i+1]])<<4) | (((unsigned char)table[code[i+2]])>>2); //取出第二个字符对应base64表的十进制数的后4位与第三个字符对应bas464表的十进制数的后4位进行组合  
            res[j+2]=(((unsigned char)table[code[i+2]])<<6) | ((unsigned char)table[code[i+3]]); //取出第三个字符对应base64表的十进制数的后2位与第4个字符进行组合  
        }  
      
        return res;  
      
    }

/*一个测试程序*/  
    #include "base64.h"  
    #include <stdio.h> 
    #include <string.h>   
      
    int main(int argc,char **argv)  
    {
          
        unsigned char *buf =NULL;
        if(strcmp(argv[1],"-d") == 0) 
        {
         
    	buf = base64_decode(argv[2]);
            printf("%s\n",buf);  
        }
        else  
        {
        
    	buf = base64_encode(argv[1]);
            printf("%s\n",buf);   
        }
     
        free(buf);
      
        return 0;  
    }

编译  
gcc -o test test.c base64.c

./test a123456  
YTEyMzQ1Ng==

./test -d YTEyMzQ1Ng==  
a123456

--------------------

# 看个例子(乱⑦⑧糟的—待整理) #

演示字符串”Who“如何转为Base64编码。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]

1.  一个字节是8个比特，先找到对应的ASCII码，再将其转化为8位的二进制

转化如下：

*  ”W“、”h“、”o“的ASCII的值分别是87、104、111，对应的二进制值是01010111、01101000、01101111
 *  将它们连成一个24位的二进制字符串010101110110100001101111。

1.  将上面得到的24位字符串分组，每组6个二进制位，一共可以分为四组：

分组如下：

*  010101、110110、100001、101111。
 *  在每组前面加两个00，扩展成32个二进制位，即四个字节：00010101、00110110、00100001、00101111，它们的十进制值分别是21、54、33、47。
 *  根据上面定义的char数组，得到21、54、33、47下标对应的字符分别是V、2、h、v。

即 Who 的 Base64 编码是 V2hv。

# 字节数不足三怎么办 #

## 一个字节的情况 ##

将这一个字节的8个二进制位，按照上面的规则转成两组，最后一组除了前面加两个0以外，后面再加两个0，这样得到一个两位的Base64编码，再在末尾补上两个”=“号。  
如：”W“字符串是一个字节，可以转化为两组：00010101、00110000（？？？），对应的Base64值分别为 V、w，再补上两个”=“号，即”W“的Base64编码就是 Vw==。

## 两个字节的情况 ##

将这两个字节的16个二进制位，按照上面的规则转成三组，最后一组除了前面加两个0以外，后面也要加两个0，这样得到一个三位的Base64编码，再在末尾补上一个”=“号。  
如：”Wh“字符串是两个字节，可以转化为三组：00010101、00110110、00100000，对应的Base64值分别为 V、2、g，再补上一个”=“号，即”Wh“的Base64编码就是 V2g=。

# 汉字如何编码 #

汉字本身有很多编码，比如：GB2312、UTF-8、GBK等，每一种编码的Base64编码都是不一样的。下面以 UTF-8 编码为例，对汉字”吴“进行Base64编码。

”吴“的UTF-8编码为的十六进制是 0xE590B4（对应的十进制是 15044788），转化为二进制是 11100101、10010000、10110100。将这个24位的二进制字符串，转换成四组一共32位的二进制值是 00111001、00011001、00000010、00110100，相应的十进制数为 57、25、2、52，它们对应的Base64值为 5、Z、C、0。

# 其他乱⑦⑧糟的 #

编码过程：

*  以每三个8位字符型数据为一组，取这三个字符型数据的ASCII码，（ 一共是24个二进制位。三个字节，每个字节占8位）。
 *  然后以6位为一组组成4个新的数据，这4个新的数据有6位，所以它的最大值为2^6=64
 *  我们以4个6位数据的十进制数从base64表中得到最终编码后的字符。

>  *  由于base64编码是将编码前的3\*8位数据，分解成4个6位的数据，所以经过base64编码后的字符串长度是4的倍数。
>  *  但往往我们进行编码的数据长度并不是3的倍数，这就造成了“编码”后的位数不为4的倍数，
>     
>      *  比如Brisk：
>         
>          *  Brisk共5×8=40位，以6位为一组可以分为7组，
>             
>              *  这样“编码”后就有7个字符，但base64编码后的字符长度应该是4的倍数，
>              *  显然这里就出问题了，那么怎么办呢？
>              *  前面的不可以抛弃掉，所以就只有“追加”了，
>              *  所以Brisk经过base64编码后的长度应该是8个字符，而第8个编码后的字符是’=’，
>      *  再比如对单个字符a进行base64编码，
>         
>          *  由于它的长度（8）不是3的倍数，
>          *  以3个字节为一组它只能分一组，再以6位为一位它只能分两组，
>          *  所以经过“编码”后它的长度是2，但base64编码后的个数应该是4的倍数，所以它的长度应该是4，所以在后面补上两个‘=’,
>          *  由于一个数求余3后有三个不同的结果，0、1、2，
>  *  所以在对一个数据进行base64进行编码后它的长度为：
>     
>      *  （1）当进行编码的数据长度是3的倍数时，len=strlen(str\_in)/3\*4;
>      *  （2）当进行编码的数据长度不是3的倍数时，len=(strlen(str\_in)/3+1)\*4;

我们以Brisk这个例子来说明一下base64编码的过程。首先我们以3个字符为一组将Brisk进行分组，Brisk被氛围两组：Bri 和 sk；然后我们取出这两个分组中每个字节的ASCII码，B:66 r:114 i:105 s:115 k:107。它们对应的二进制数为  B:01000010 r:01110010 i:01101001 s:01110011 k:01101011；
    
       第一组，我们以6位为一组对每一个3字节分组进行再分组就变成了010000 100111 001001 101001。所对应的十进制数是16 39 9 41，对应base64表中的结果是 Q n J p；
    
       第二组，011100 110110 101100(不够补0)，所以对应的十进制数是 28 54 44，对应base64表中的结果是 c 2 s，最终结果为QnJpc2s=（因为第二组“编码”后只有三个字节）。

解码的过程是一个逆过程，我们将经过编码后的字符按4个字符为一组，然后对照base64表得到相应的十进制数，再将其通过拆分和组合，组成3个8位数据，这个数据就是解码后的数据

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20230312/658aae394de44461902a1a77c0cb35ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20230312/25ef26fe2bd141c4b38cf013316f078b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: /images/20230312/c871ab5df5764a84bcd8b63cca7b12e9.png

发表评论取消回复

表情：

评论列表（有 0 条评论，52人围观）

还没有评论，来说两句吧...

相关阅读

相关 C/C++编程：实现Base64编码/解码

原理所谓 Base64，就是说选出64个字符（小写字母a-z、大写字母A-Z、数字0-9、符号"+"、符号”/“、再加上作为垫底的”=“，实际上是65个字符）作为一个基

喜欢ヅ旅行/ 2023年03月13日 02:13/ 0 赞/ 53 阅读

相关 js base64 编码解码

js base64 编码解码 encode decode，可以直接使用 function Base64() { // private

小鱼儿/ 2023年03月04日 09:17/ 0 赞/ 202 阅读

相关 C语言实现Base64编码/解码

Bse64是一种以64个可打印字符对二进制数据进行编码的编码算法。base64在对数据进行编码时以三个8位字符型数据为一组，取这三个字符型数据的ASCII码，然后以6位为一组组

﹏ヽ暗。殇╰゛Y/ 2023年01月23日 15:59/ 0 赞/ 259 阅读

相关 base64编码解码

调用： ---js var s = new base64InOut(); //编码 var values = s.base64Encodes(

﹏ヽ暗。殇╰゛Y/ 2022年08月21日 11:54/ 0 赞/ 318 阅读

相关 Base64编码解码算法

Base64不是什么新奇的算法了，不过如果你没从事过页面开发（或者说动态页面开发，尤其是邮箱服务），你都不怎么了解过，只是听起来很熟悉。对于黑客来说，Base64与MD5算

桃扇骨/ 2022年08月13日 13:36/ 0 赞/ 419 阅读

相关 C语言实现Base64编码/解码

Bse64是一种以64个可打印字符对二进制数据进行编码的编码算法。base64在对数据进行编码时以三个8位字符型数据为一组，取这三个字符型数据的ASCII码，然后以6位为一组组

小灰灰/ 2022年06月03日 04:38/ 0 赞/ 231 阅读

相关 BASE64编码解码

BASE64,是一种公共编解码算法大家都是遵循同一种算法来对字节数组进行编解码,所以可以通用. java在很多公共的框架中都有BASE64的实现. 可以用: A

痛定思痛。/ 2022年05月30日 08:27/ 0 赞/ 453 阅读

相关 java：Base64编码解码方式

1.使用jdk自带包解码编码： package com.cl; import java.io.IOException; impor

Dear 丶/ 2022年05月08日 14:38/ 0 赞/ 354 阅读

相关 base64编码和解码

base64编码和解码原理 1. 计算机中，每个字节是8位的二进制数 2. base64编码中，每一个8位的二进制数中只有后6位时有

你的名字/ 2022年02月13日 04:47/ 0 赞/ 433 阅读

相关 base64编码解码方法

不推荐使用jdk1.8以下的Base64加解密,虽然jdk加解密的效率比其他两种都要高，下面是相关的测试结果 base64 jar：jdk

心已赠人/ 2021年09月23日 10:08/ 0 赞/ 472 阅读