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位二进制码,正好可以分为46位的二进制码块。有时候二进制序列不能正好的平分成6位的块,这时就需要进行填充。填充规则为如果源字节长度除以3,如果余数为0则不用填充,如果余数为1,则二进制序列末尾填充40Base64之后的字符串加两个=,即==,如果余数为2,则在二进制序列末尾填充20Base64之后的字符串加一个=
比如上例中在加一个!,对Ow!!编码,除3余数为1,则末尾填充40,前面3个字节的编码不变,最后一个!编码为IQOw!! Base64编码之后为:T3chIQ==

C语言实现方式

#include <stdio.h>
#include <string.h>
#include <stdlib.h>


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集序找到他其他的兄弟。

参考

推荐阅读更多精彩内容

  • 1、Base64编码原理 下图为Base64编码索引表: 字符选用了"A-Z、a-z、0-9、+、/" 64个可打...
    M_JCs阅读 1,122评论 1 8
  • Base64编码由来 Base64最早是用来解决电子邮件的传输问题。 传统的电子邮件是1982年定下技术规范的,详...
    Ashton阅读 2,116评论 0 6
  • 加密就是为了安全通信而诞生的。没有通信,加密也没有太大存在的意义。 虽说Base64算不上一种加密,只是一种具有固...
    王韩峰阅读 463评论 0 3
  • 编码原理 Base64编码就是把3个8位的二进制数据用4个ASCII可见字符展示出来。编码时,将3个8位二进制码重...
    awesome丁阅读 341评论 0 0
  • 相关文章:Base64 之 JavaScript 实现在Web前端还可以这样实现Base64 什么是Base64 ...
    JSON_NULL阅读 1,285评论 0 4