Base64编码与解码源码分析

介绍

Base64是一种基于64个可打印字符来表示二进制数据的表示方法，是一种编码方式，提及编码方式，必然有其对应的字符集合。在Base64编码中，相互映射的两个集合是：

• 二进制数据{0, 1}

• {A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, /}

Base64编码方式可使得信息在这两种字符集表示法之间相互等价转换。

Base64编码过程

由于base64的字符集大小为64，那么，需要6个比特的二进制数作为一个基本单元表示一个base64字符集中的字符。因为6个比特有2^6=64种排列组合。

具体来说，编码过程如下：

1. 将每三个字节作为一组，共24bit，若不足24bit在其后补充0；
2. 将这24个bit分为4组，每一组6个bit；
3. 在每组前加00扩展为8个bit，形成4个字节，每个字节表示base64字符集索引；
4. 扩展后的8bit表示的整数作为索引，对应base64字符集的一个字符，这就是base64编码值；在处理最后的不足3字节时，缺一个字节索引字节取3个，最后填充一个=，；缺两个字节取2个索引字节，最后填充==。

解码时将过程逆向即可。

Base64索引表：

ASCII码表

编码示例

示例一

Man的base64编码

1. 第一步，’M’, ‘a’, ‘n’的ASCII值分别为77, 97, 110，对应的二进制值分别为：01001101, 01100001, 01101110；取三个字节共24bit：010011010110000101101110
2. 第二步，将这24bit分为4组，每组6个bit：010011, 010110, 000101, 101110
3. 每组前面加00，形成4个字节的，00010011, 00010110, 00000101, 00101110, 即19, 22, 5, 46
4. 根据索引表，对应的base64字符分别是T, W, F, u
   最后的base64字符串是: TWFu。

解码时将过程逆向即可。

示例二

剩余两个字节，BC的base64编码

1. 第一步，’B’, ‘C’的ASCII值分别为66, 64, 对应二进制值分别为：01000010, 01000011；取三个字节，不足不0，共24bit：01000010, 01000011, 00000000
2. 第二步，将这24bit分为4组，每组6个bit：010000, 100100, 001100, 000000
3. 每组前面加00，形成4个字节的，00010000, 00100100, 00001100, 00000000，即16, 36, 12, 0
4. 由于’B’, ‘C’只有两个字节，缺一个字节，因此取3个索引；根据索引表，对应的base64字符分别是Q, k, M，最后填充一个=

最后的base64字符串是：QkM=

示例三

剩余一个字节，A的base64编码

1. 第一步，’A’的ASCII值65, 对应二进制值为：01000001; 取三个字节，不足不0，共24bit：01000001, 00000000, 00000000
2. 第二步，将这24bit分为4组，每组6个bit：010000, 010000, 000000, 000000
3. 每组前面加00，形成4个字节的，00010000, 00010000, 00000000, 00000000，即16, 16, 0, 0
4. 由于’A’只有一个字节，缺两个字节，因此取2个索引；根据索引表，对应的base64字符分别是Q, Q，最后填充==

最后的base64字符串是：QQ==

Python实现

base64编码方式一：

"""
base64实现
encode: 先编码，十进制化(汉字在utf-8编码下占三个字节，在gbk编码下占两个字节)，再转二进制进行+0填充后合并，不足6的倍数继续填充，切片，十进制化查表，拼接,不足4的倍数填充=
"""

def fillIt(string, factor, item):
    """
    指定倍数填充指定字符
    string：原字符串
    factor：倍数
    item：填充字符
    """
    length = len(string)
    remainder = length % factor
    if remainder:
        times = factor - remainder
        string = string + times * item
    return string

def splitIt(string, bits):
    """
    指定位数切片
    string：原字符串
    bits：每次切片数量
    """
    length = len(string)
    new_list = []
    for i in range(bits, length + 1, bits):
        new_list.append(string[i - bits:i])
        remain = length % bits
        if remain != 0:
            new_list.append(string[-remain:])
    return new_list

def encode(string):
    string_temp = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    # 索引编码表
    base64_dict = {}
    for i in range(2 ** 6):
        base64_dict[i] = string_temp[i]
        # 编码
    string_encode_byte = string.encode('utf-8')
    # 十进制化
    string_digit_list = list(string_encode_byte)

    # 二进制化 + 0填充到8位
    string_bin_list = []
    for item in string_digit_list:
        string_bin_list.append(str(bin(item))[2:].zfill(8))

        # 字符串合并
    string_sum = ''.join(string_bin_list)

    # 6 的倍数，不足 0 填充
    string_fill = fillIt(string_sum, factor=6, item='0')

    # 切片，6位一个单位
    string_bin_list2 = splitIt(string_fill, bits=6)

    # 十进制化
    string_digit_list2 = []
    for item in string_bin_list2:
        string_digit_list2.append(int(item, 2))

        # 查表
    string_base64_list = []
    for item in string_digit_list2:
        string_base64_list.append(base64_dict[item])

        # 拼接
    string_sum2 = ''.join(string_base64_list)
    # 4 的倍数，不足填充 =
    string_convert = fillIt(string_sum2, factor=4, item='=')
    return string_convert

if __name__ == '__main__':
    print(encode("123啊a"))

base64编码方式二：

base64_charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
def encode(string):
    """
    将bytes类型编码为base64
    :param string:需要编码的字符串
    :return:base64字符串
    """

    # 对字符串转字节
    origin_bytes = string.encode()

    # 将每一位bytes转换为二进制字符串, '{:0>8}'.format(str) 填充到8位
    base64_bytes = ['{:0>8}'.format(str(bin(b)).replace('0b', '')) for b in origin_bytes]

    resp = ''
    nums = len(base64_bytes) // 3
    remain = len(base64_bytes) % 3  # 余数

    integral_part = base64_bytes[0:3 * nums]  # 取3的倍数分组
    while integral_part:
        # 取三个字节，以每6比特，转换为4个整数（直接转换位十进制，不填充到8位在转十进制）, 对码表进行查找
        tmp_unit = ''.join(integral_part[0:3])
        tmp_unit = [int(tmp_unit[x: x + 6], 2) for x in [0, 6, 12, 18]]
        # 取对应base64字符
        resp += ''.join([base64_charset[i] for i in tmp_unit])
        integral_part = integral_part[3:]

    if remain:
        # 补齐三个字节，每个字节补充 0000 0000
        remain_part = ''.join(base64_bytes[3 * nums:]) + (3 - remain) * '0' * 8
        # 取三个字节，以每6比特，转换为4个整数
        # 剩余1字节可构造2个base64字符，补充==；剩余2字节可构造3个base64字符，补充=
        tmp_unit = [int(remain_part[x: x + 6], 2) for x in [0, 6, 12, 18]][:remain + 1]
        resp += ''.join([base64_charset[i] for i in tmp_unit]) + (3 - remain) * '='

    return resp

if __name__ == '__main__':
    s = "123啊a"
print(encode(s))

base64解码方式三：

def decode(base64_str):
    """
    解码base64字符串
    :param base64_str:base64字符串
    :return:解码后的bytearray；若入参不是合法base64字符串，返回空bytearray
    """
    # 判断是否符合base64的格式
    if len(base64_str) % 4:
        return

        # 去除末尾=
    while True:
        if base64_str[len(base64_str)-1:] == "=":
            base64_str = base64_str[:len(base64_str)-1]
            continue
        break

        # 遍历判断字符串元素是否在编码表里
    for m in base64_str:
        if m not in base64_str:
            return

            # 对每一个base64字符取下标索引，并转换为6为二进制字符串
    base64_bytes = ['{:0>6}'.format(str(bin(base64_charset.index(s))).replace('0b', '')) for s in base64_str if s != '=']

    resp = bytearray()
    nums = len(base64_bytes) // 4
    remain = len(base64_bytes) % 4
    # 截取4的整数倍
    integral_part = base64_bytes[0:4 * nums]

    while integral_part:
        # 取4个6位base64字符，作为3个字节
        tmp_unit = ''.join(integral_part[0:4])
        tmp_unit = [int(tmp_unit[x: x+8], 2) for x in [0, 8, 16]]
        for i in tmp_unit:
            resp.append(i)
        integral_part = integral_part[4:]

        # 取剩余的
    if remain:
        remain_part = ''.join(base64_bytes[nums*4:])
        tmp_unit = [int(remain_part[i*8:(i+1)*8], 2) for i in range(remain-1)]
        for i in tmp_unit:
            resp.append(i)

    return resp.decode()

c++实现

//
// Created by zsk on 2022/9/13.
//
#include <iostream>
#include <cstring>

class Base64 {
public:
//base64 加密
static void encode(const char *data, char *out) {
    char Base64Code[] = {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
};
    // 计算长度
    int data_len = strlen(data);
    if (data_len == 0) {
        out[0] = '\0';
        return;
    }

    int i;
    //主编码循环, & 同为 1 的位，结果为 1，否则结果为 0。 | 只要有1个是1的位，结果为1，否则为0
    for (i = 0; i < data_len / 3; ++i) {
        out[i * 4] = Base64Code[data[i * 3] >> 2];
        out[i * 4 + 1] = Base64Code[((data[i * 3] & 0x03) << 4) | (data[i * 3 + 1] >> 4)];
        out[i * 4 + 2] = Base64Code[((data[i * 3 + 1] & 0x0F) << 2) | (data[i * 3 + 2]) >> 6];
        out[i * 4 + 3] = Base64Code[data[i * 3 + 2] & 0x3F];
    }

    //长度不为3的倍数
    if (data_len % 3 == 1) {
        out[i * 4] = Base64Code[data[i * 3] >> 2];
        out[i * 4 + 1] = Base64Code[((data[i * 3] & 0x03) << 4)];
        out[i * 4 + 2] = '=';
        out[i * 4 + 3] = '=';
    }

    if (data_len % 3 == 2) {
        out[i * 4] = Base64Code[data[i * 3] >> 2];
        out[i * 4 + 1] = Base64Code[((data[i * 3] & 0x03) << 4) | (data[i * 3 + 1] >> 4)];
        out[i * 4 + 2] = Base64Code[((data[i * 3 + 1] & 0x0F) << 2)];
        out[i * 4 + 3] = '=';
    }
}

//base64 解密
static void decode(const char *data, char *out) {
    static char _ucode[] = {
    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, 64, 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, 0, 0, 0, 0, 0,
};
    int i;
    int len = strlen(data);
    ptrdiff_t len2 = len / 4 * 3;
    //判断末位是否有等号、有几个等号
    if ('=' == data[len - 2])
        len2 -= 2;
    else if ('=' == data[len - 1])
        len2--;
    else if (len % 4)
        len2 += (len % 4 - 1);
    //主解密循环
    for (i = 0; i < len2 / 3; ++i) {
        out[i * 3] = (_ucode[data[i * 4]] << 2) | (_ucode[data[i * 4 + 1]] >> 4);
        out[i * 3 + 1] = ((_ucode[data[i * 4 + 1]] & 0x0F) << 4) | (_ucode[data[i * 4 + 2]] >> 2);
        out[i * 3 + 2] = ((_ucode[data[i * 4 + 2]] & 0x03) << 6) | (_ucode[data[i * 4 + 3]]);
            }
            //末位为一个或两个等号的情况，这时候不能通过主解密循环进行解密
            if (len2 % 3 == 1) {
            out[i * 3] = (_ucode[data[i * 4]] << 2) | (_ucode[data[i * 4 + 1]] >> 4);
            }
            if (len2 % 3 == 2) {
            out[i * 3] = (_ucode[data[i * 4]] << 2) | (_ucode[data[i * 4 + 1]] >> 4);
            out[i * 3 + 1] = ((_ucode[data[i * 4 + 1]] & 0x0F) << 4) | (_ucode[data[i * 4 + 2]] >> 2);
            }
            }
            };

            int main() {
            const char *text = "12345";
            char out[100] = {0};
            char out2[100] = {0};
            Base64::encode(text, out);
            printf("encode==>%s\n", out);
            Base64::decode(out, out2);
            printf("decode==>%s", out2);
            }

中文的base64编码

其实base64编码只是在二进制与base64字符集之间映射的编码，与其他字符集毫无关系。其他字符集想要转换为base64编码，只需先将其转换为二进制，再做base64编码即可。

那么对于Unicode字符集而言，有多种编码方式将其装换为二进制，所以在编码过程中就需要统一编码，以免造成乱码。上述Python示例就将中文转换为base64，首先使用默认编码utf-8将字符串转换为二进制（使用Python的str.encode()），再做base64编码；解码时候同样如此，先将base64字符串解码为二进制，再将二进制转换为字符串（使用Python的str.decode()）