Base64编码

Base64编码可将任意二进制数据转换为字符编码，转换后的编码包括：A ~ Z a ~ z 0 ~ 9 + /及作为填充字符的=，一共65个字符。除去填充字符，剩下64个字符，需要6个状态位来表示，因此Base64的编码规则是将源信息中的6位编码为一个字符，这个字符是Base64编码表中的64个字符之一。由于Base64编码用8位字符来表示信息中的6位，所以Base64编码字符串大约比原始值扩大1/3。

图0-0 此篇文章的逻辑图

Base64编码表

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

Base64编码方式举例

以Ow!为例来说明Base64是如何编码的
(1)字符Ow!先按ASCII编码为：0x4F 0x77 0x21，转换为二进制码：01001111 01110111 00100001
(2)将上述二进制码按6位一组划分: 010011 110111 011100 100001，转换为十进制码：19 55 28 33
(3)根据上面编码表则Ow! Base64编码之后为：T3ch

Base64填充

上述例子中，24位二进制码，正好可以分为4个6位的二进制码块。有时候二进制序列不能正好的平分成6位的块，这时就需要进行填充。填充规则为如果源字节长度除以3，如果余数为0则不用填充，如果余数为1，则二进制序列末尾填充4个0，Base64之后的字符串加两个=，即==，如果余数为2，则在二进制序列末尾填充2个0，Base64之后的字符串加一个=。
比如上例中在加一个!，对Ow!!编码，除3余数为1，则末尾填充4个0，前面3个字节的编码不变，最后一个!编码为IQ，Ow!! Base64编码之后为：T3chIQ==

C语言实现方式

#include 
#include 
#include 


const char base[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

char find_pos(char ch);
char *base64_encode(const char *data, int *len) ;
char *base64_decode(const char *data, int *len);

int main(int argc, const char * argv[]) {
    
    int len;
    printf("%s\n", base64_encode("Ow!!", &len));
    printf("%d\n", len);
    
    printf("%s\n", base64_decode("T3chIQ==", &len));
    printf("%d\n", len);
    
    return 0;
}

char find_pos(char ch) {
    char *ptr = (char *)strrchr(base, ch);
    return ptr - base;
}

char *base64_encode(const char *data, int *len) {
    
    int data_len = (int)strlen(data);
    int prepare = 0;
    int tmp = 0;
    char changed[4];
    char *ret = NULL;
    char *f = NULL;
    int ret_len = data_len / 3;
    int temp = data_len % 3;
    *len = 0;
    if (temp > 0) {
        ret_len += 1;
    }
    
    ret_len = ret_len * 4 + 1; // 最后一位以 ' ' 结束
    ret = (char *)malloc(ret_len);
    
    if (!ret) {
        printf("no enough memory.\n");
        exit(0);
    }
    
    memset(ret, 0, ret_len);
    f = ret;
    
    while (tmp < data_len) {
        temp = 0;
        prepare = 0;
        memset(changed, 0, 4);
        while (temp < 3) {
            if (tmp >= data_len) {
                break;
            }
            
            prepare = (prepare << 8) | (data[tmp] & 0xFF);
            tmp++;
            temp++;
        }
        
        prepare = (prepare << (3 - temp) * 8);
        
        for (int i = 0; i < 4; i++) {
            if (temp < i) {
                changed[i] = 0x40;
            } else {
                changed[i] = (prepare >> ((3 - i) * 6)) & 0x3F;
            }
            *f = base[changed[i]];
            
            f++;
            (*len)++;
        }
    }
    *f = ' ';
    return ret;
}


char *base64_decode(const char *data, int *len) {
    
    int data_len = (int)strlen(data);
    int ret_len = (data_len / 4) * 3 + 1;
    int equal_count = 0;
    char *ret = NULL;
    char *f = NULL;
    *len = 0;
    int tmp = 0;
    int temp = 0;
    int prepare = 0;
    
    if (*(data + data_len - 1) == '=') {
        equal_count++;
    }
    if (*(data + data_len - 2) == '=') {
        equal_count++;
    }
    
    ret = (char *)malloc(ret_len);
    if (!ret) {
        printf("no enough memory./n");
        exit(0);
    }
    memset(ret, 0, ret_len);
    f = ret;
    while (tmp < (data_len - equal_count)) {
        temp  = 0;
        prepare = 0;
        while (temp < 4) {
            if (tmp >= (data_len - equal_count)) {
                break;
            }
            prepare = (prepare << 6) | (find_pos(data[tmp]));
            temp++;
            tmp++;
        }
        prepare = prepare << ((4-temp) * 6);
        for (int i = 0; i < 3; i++) {
            if (i == temp) {
                break;
            }
            *f = (char)((prepare >> ((2 - i) * 8)) & 0xFF);
            f++;
            (*len)++;
        }
    }
    *f = ' ';
    if (data[data_len - 1] == '=') {
        (*len)--;
    }
    
    return ret;
}

总结

Base64编码不论是做什么开发，都是会经常遇到，这里讲述一下编码原理，并给出C语言一个简单的实现方式作为参考。具体一些使用有HTTP的摘要认证，甚至一些前端做网络优化的时候，也有将图片转为Base64编码和文本结果一并返回，从而减少建立TCP连接的次数。由于Base64编码使用的都是可打印的普通字符，所以就能极大的减少在传输转换中的错误率。这是一系列文章的其中一篇，你可以在这儿Encode & Decode集序找到他其他的兄弟。

参考

• 陈娟,赵振平[译]. HTTP权威指南:人名邮电出版社
• C语言实现Base64算法