opensl学习——base16编码解码、base64编码解码、ASCII码表、扩展ASCII码

ASCII表概述

ASCII（American Standard Code for Information Interchange，美国信息互换标准代码）是一套基于拉丁字母的字符编码，共收录了 128 个字符，用一个字节就可以存储，它等同于国际标准 ISO/IEC 646。

ASCII 编码于 1967 年第一次发布，最后一次更新是在 1986 年，迄今为止共收录了 128 个字符，包含了基本的拉丁字母（英文字母）、阿拉伯数字（也就是 1234567890）、标点符号（,.!等）、特殊符号（@#$%^&等）以及一些具有控制功能的字符（往往不会显示出来）。

ASCII 编码是美国人给自己设计的，他们并没有考虑欧洲那些扩展的拉丁字母，也没有考虑韩语和日语，我大中华几万个汉字更是不可能被重视。计算机也是美国人发明的，起初使用的就是 ASCII 码，只能显示英文字符。各个国家为了让本国公民也能正常使用计算机，开始效仿 ASCII 开发自己的字符编码，例如 ISO/IEC 8859（欧洲字符集）、shift_Jis（日语字符集）、GBK（中文字符集）等。

base家族简单说明

ASCII 是用128（2^8）个字符，对二进制数据进行编码的方式，
base64 编码是用64（2^6）个字符，对二进制数据进行编码的方式
base32 就是用32（2^5）个字符，对二进制数据进行编码的方式
base16 就是用16（2^4）个字符，对二进制数据进行编码的方式

Hex(十六进制)编码、Base32编码、Base64编码、base256编码

Hex(十六进制)编码、Base32编码和Base64编码可以将原始数据编码为可视化字符串。它们的原理是一样的，都是将指定位数的原始数据编码为特定字符空间中的一个字符。

• Hex：也叫作Base16编码；每4位编码为一个字符，$2^4=16$ 字符空间为"0123456789abcdef"或"0123456789ABCDEF"；不区分大小写，其中的字母可以编码为大写也可以编码为小写，同时解码也不区分大小写，应该能对大小写的HEX字符串都能正确解码；
• Base32：每5位编码为一个字符，$2^5=32$ 字符空间为"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"，大小写敏感；
• Base64：每6位编码为一个字符，$2^6=64$ 字符空间为"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"，大小写敏感；
• Base256: 每8位编码为一个字符，也就是8位一个字节。因为$2^8=256$ 所以，可以把我们普通的编码叫base256。

base16编码与解码

Base16编码使用16个ASCII字符对任何数据进行编码，Base16与Base64的实现原理类似，同样是将原数据二进制形式取指定位数转换为ASCII码。首先获取数据的二进制形式，将其串联起来，每4个比特为一组进行切分，每一组内的4个比特可转换到指定的16个ASCII字符中的一个，将转换后的ASCII字符连接起来，就是编码后的数据。

base16编码与解码示例

#include 

using namespace std;
static const char BASE16_ENC_TAB[] = "0123456789ABCDEF";
// '0'~'9' =>48~57		'A'~'F' => 65~70
static const char BASE16_DEC_TAB[128] = {
	-1,								//0
	-1,-1,-1,-1,-1, -1,-1,-1,-1,-1, //1-10
	-1,-1,-1,-1,-1, -1,-1,-1,-1,-1, //11-20
	-1,-1,-1,-1,-1, -1,-1,-1,-1,-1, //21-30
	-1,-1,-1,-1,-1, -1,-1,-1,-1,-1, //31-40
	-1,-1,-1,-1,-1, -1,-1, 0, 1, 2, //41-50
	 3, 4, 5, 6, 7,  8, 9,-1,-1,-1, //51-60
	-1,-1,-1,-1,10, 11,12,13,14,15  //61-70 'A'-'F'
};

int Base16Encode(const unsigned char* in, int size, char* out)
{
	for (int i = 0; i < size; ++i) {
		char h = in[i] >> 4; //移位丢弃低位
		char l = in[i] & 0x0F; //0000 1111 去掉高位
		out[i * 2] = BASE16_ENC_TAB[h];
		out[i * 2 + 1] = BASE16_ENC_TAB[l];
	}
	//base16 转码后空间扩大一倍 4位转成一个字符 1个字节转成两个字符
	return size * 2;
}

int Base16Decode(const string& in, unsigned char* out)
{
	//将两个字符拼成一个字节 B2E2CAD442617365313600
	for (int i = 0; i < in.size(); i +=2)
	{
		unsigned char ch = in[i];	//高位转换的字符 'B'=> 66 : 10
		unsigned char cl = in[i + 1]; //低位转换的字符 '2'=> 50 : 2
		unsigned char h = BASE16_DEC_TAB[ch]; //转换成原来的值
		unsigned char l = BASE16_DEC_TAB[cl];

		//两个4位拼成一个字节 (8位)
		// 1000 >> 4		1000 0000
		// 0001				0000 0001
		//				   |1000 0001
		out[i / 2] = (int)(h << 4 | l);
	}
	return in.size() / 2;
}

int main(int argc, char* argv[])
{
	cout << " Test Base16" << endl;
	const unsigned char data[] = "测试Base16";
	int len = sizeof(data);
	char out1[1024] = { 0 };
	cout << data << endl;
	int re = Base16Encode(data, len, out1);
	unsigned char out2[1024] = { 0 };
	re = Base16Decode(out1, out2);
	cout << re << ":" << out2 << endl;
	return 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
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
52
53
54
55
56
57
58
59
60
61

base64编码概述

Base64 是一种基于 64 个可打印字符来表示二进制数据的表示方法，由于 2^6=64，所以每 6 个比特为一个单元，对应某个可打印字符。

Base64 常用于在通常处理文本数据的场合，表示、传输、存储一些二进制数据，包括 MIME 的电子邮件及 XML 的一些复杂数据。

Base64 编码要求把 3 个 8 位字节（3*8=24）转化为 4 个 6 位的字节（4*6=24），之后在 6 位的前面补两个 0，形成 8 位一个字节的形式。 如果剩下的字符不足 3 个字节，则用 0 填充，输出字符使用 =，因此编码后输出的文本末尾可能会出现 1 或 2 个 =。

为了保证所输出的编码位可读字符，Base64 制定了一个编码表，以便进行统一转换。编码表的大小为 2^6=64，这也是 Base64 名称的由来。

在 Base64 中的可打印字符包括26个大写字母 A-Z、26个小写字母a-z、数字 0-9，这样共有 62 个字符，此外两个可打印符号在不同的系统中而不同。

以下是 Base64 编码的基本步骤：

• 将数据划分为 3 个字节一组（24位）。
• 将每个字节转换为 8 位二进制形式。
• 将 24 位数据按照 6 位一组进行划分，得到 4 个 6 位的组。
• 将每个 6 位的组转换为对应的 Base64 字符。
• 如果数据不足 3 字节，进行填充。
• 将所有转换后的 Base64 字符连接起来，形成最终的编码结果。

解码 Base64 编码的过程与编码相反，将每个 Base64 字符转换为对应的6位二进制值，然后将这些 6 位值组合成原始的二进制数据。

Base64 编码具有以下特点：

• 编码后的数据长度总是比原始数据长约 1/3。
• 编码后的数据可以包含 A-Z、a-z、0-9 和两个额外字符的任意组合。
• Base64 编码是一种可逆的编码方式，可以通过解码还原原始数据。

转换过程

编码 “Man” 的结果为 TWFu，转换过程如下：

不足 3 字节处理方法

例子一,不足3字节，只有一个字节

已知末尾文本为A，对应原始数据二进制为01000001，一个字节，不满足转换要求。转换要求必须要有三个字节，这里只有一个字节，所以要进行填充。从上图可知，填充分两种情况，A对应原始数据二进制的前六位可以正常转换，后两位之后填充0，现在已经两个单元，但是四个单元才可以转换。这里根据Base64编码规则用两个等于号来填充。这样就保证了数据内容不变，长度可观测。

例子二,不足3字节，只有两个字节

已知末尾文本为B，C。对应原始数据二进制为0100001001000011，两个字节，不满足转换要求。转换要求必须要有三个字节，这里只有两个字节，所以要进行填充。

base64示例代码1

//
// Created by oceanstar on 2021/8/13.
//
#include 
#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;
    }

}

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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

代码分析 acl_base64_encode

编码过程简单来说就是8 x 3===> 6 x 4的过程。

// 当count等于3时，执行的是
out[out_index++] = to_b64[cp[0] >> 2];
out[out_index++] = to_b64[(cp[0] & 0x3) << 4 | cp[1] >> 4]; // 0x3 ---> 0000 0011
out[out_index++] = to_b64[(cp[1] & 0xf) << 2 | cp[2] >> 6]; // 0xf ---> 0000 1111
out[out_index++] = to_b64[cp[2] & 0x3f];	// 0x3f ---> 0011 1111

// 当count等于2时，执行的是
out[out_index++] = to_b64[cp[0] >> 2];
out[out_index++] = to_b64[(cp[0] & 0x3) << 4 | cp[1] >> 4];
out[out_index++] = to_b64[(cp[1] & 0xf) << 2];
out[out_index++] = '=';

// 当count等于1时，执行的是
out[out_index++] = to_b64[cp[0] >> 2];
out[out_index++] = to_b64[(cp[0] & 0x3) << 4];
out[out_index++] = '=';
out[out_index++] = '=';
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

代码分析 acl_base64_decode

解码过程简单来说就是6 x 4===> 8 x 3的过程。

//当满足4个单元时
out[out_index++] = ch0 << 2 | ch1 >> 4;
out[out_index++] = ch1 << 4 | ch2 >> 2;
out[out_index++] = ch2 << 6 | ch3;
1
2
3
4

base64示例代码2——openssl 实现

#include 
#include 
#include 
#include 
int base64_encode(char *in_str, int in_len, char *out_str) {
    BIO *b64, *bio;
    BUF_MEM *bptr = NULL;
    size_t size = 0;

    if (in_str == NULL || out_str == NULL)
        return -1;

    b64 = BIO_new(BIO_f_base64());
    bio = BIO_new(BIO_s_mem());
    bio = BIO_push(b64, bio);

    BIO_write(bio, in_str, in_len);
    BIO_flush(bio);

    BIO_get_mem_ptr(bio, &bptr);
    memcpy(out_str, bptr->data, bptr->length);
    out_str[bptr->length-1] = '\0';
    size = bptr->length;

    BIO_free_all(bio);
    return size;
}

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
26
27
28

Base16与Base64优劣对比

• Base16使用了更小的字典，Base16包含16个字符（0-9A-F），Base64包含65个字符（a-zA-Z0-9+/=或a-zA-Z0-9-_=）。

• Base16编码规则是4比特为一分组，Base64编码规则是6比特为一分组。

• 由于编码规则的不同，Base16正好可以完全切分数据，无需补位；Base64无法完全切分数据，需要使用=补位， 补位的个数在{0，1，2}范围之内。

• Base16编码后数据会膨胀一倍，Base64编码后数据会膨胀1/3。

• Base16编码后数据无特殊字符，而Base64包含特殊字符。Base64在URL传输等场景下需要尤为注意特殊字符的处理。

扩展的ASCII码

ASCII码值在128-255间的ASCII码称作扩展的ASCII码。

ASCII 码使用指定的7 位或8 位二进制数组合来表示128 或256 种可能的字符。标准ASCII 码也叫基础ASCII码，使用7 位二进制数（剩下的1位二进制为0）来表示所有的大写和小写字母，数字0 到9、标点符号， 以及在美式英语中使用的特殊控制字符。

其中：0～31及127(共33个)是控制字符或通信专用字符（其余为可显示字符），如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（响铃）等。

32～126(共95个)是字符(32是空格），其中48～57为0到9十个阿拉伯数字。

65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。

后128个称为扩展ASCII码。许多基于x86的系统都支持使用扩展（或“高”）ASCII。扩展ASCII 码允许将每个字符的第8 位用于确定附加的128 个特殊符号字符、外来语字母和图形符号。

ASCII 编码一览表

ASCII 编码一览表

控制字符

可显示字符