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

文章目录

• ASCII表概述
• • base家族简单说明
• Hex(十六进制)编码、Base32编码、Base64编码、base256编码
• base16编码与解码
• base64编码概述
• • 转换过程
  • [不足 3 字节处理方法](#不足 3 字节处理方法)
  • • 例子一,不足3字节，只有一个字节
    • 例子二,不足3字节，只有两个字节
  • base64示例代码1
  • • [代码分析 acl_base64_encode](#代码分析 acl_base64_encode)
    • [代码分析 acl_base64_decode](#代码分析 acl_base64_decode)
• [base64示例代码2------openssl 实现](#base64示例代码2——openssl 实现)
• Base16与Base64优劣对比
• 扩展的ASCII码
• [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 {2}^{4}=16 24=16 字符空间为"0123456789abcdef "或"0123456789ABCDEF"；不区分大小写，其中的字母可以编码为大写也可以编码为小写，同时解码也不区分大小写，应该能对大小写的HEX字符串都能正确解码；
• Base32：每5位编码为一个字符， 2 5 = 32 {2}^{5}=32 25=32 字符空间为"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"，大小写敏感；
• Base64：每6位编码为一个字符， 2 6 = 64 {2}^{6}=64 26=64 字符空间为"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"，大小写敏感；
• Base256: 每8位编码为一个字符，也就是8位一个字节。因为 2 8 = 256 {2}^{8}=256 28=256 所以，可以把我们普通的编码叫base256。

base16编码与解码

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

base16编码与解码示例

#include <iostream>

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;
}

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 <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;
    }

}

代码分析 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++] = '=';

代码分析 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;

base64示例代码2------openssl 实现

#include <openssl/sha.h>
#include <openssl/pem.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
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;
}

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 编码一览表

控制字符

二进制	十进制	十六进制	字符/缩写	解释
00000000	0	00	NUL (NULL)	空字符
00000001	1	01	SOH (Start Of Headling)	标题开始
00000010	2	02	STX (Start Of Text)	正文开始
00000011	3	03	ETX (End Of Text)	正文结束
00000100	4	04	EOT (End Of Transmission)	传输结束
00000101	5	05	ENQ (Enquiry)	请求
00000110	6	06	ACK (Acknowledge)	回应/响应/收到通知
00000111	7	07	BEL (Bell)	响铃
00001000	8	08	BS (Backspace)	退格
00001001	9	09	HT (Horizontal Tab)	水平制表符
00001010	10	0A	LF/NL(Line Feed/New Line)	换行键
00001011	11	0B	VT (Vertical Tab)	垂直制表符
00001100	12	0C	FF/NP (Form Feed/New Page)	换页键
00001101	13	0D	CR (Carriage Return)	回车键
00001110	14	0E	SO (Shift Out)	不用切换
00001111	15	0F	SI (Shift In)	启用切换
00010000	16	10	DLE (Data Link Escape)	数据链路转义
00010001	17	11	DC1/XON (Device Control 1/Transmission On)	设备控制1/传输开始
00010010	18	12	DC2 (Device Control 2)	设备控制2
00010011	19	13	DC3/XOFF (Device Control 3/Transmission Off)	设备控制3/传输中断
00010100	20	14	DC4 (Device Control 4)	设备控制4
00010101	21	15	NAK (Negative Acknowledge)	无响应/非正常响应/拒绝接收
00010110	22	16	SYN (Synchronous Idle)	同步空闲
00010111	23	17	ETB (End of Transmission Block)	传输块结束/块传输终止
00011000	24	18	CAN (Cancel)	取消
00011001	25	19	EM (End of Medium)	已到介质末端/介质存储已满/介质中断
00011010	26	1A	SUB (Substitute)	替补/替换
00011011	27	1B	ESC (Escape)	逃离/取消
00011100	28	1C	FS (File Separator)	文件分割符
00011101	29	1D	GS (Group Separator)	组分隔符/分组符
00011110	30	1E	RS (Record Separator)	记录分离符
00011111	31	1F	US (Unit Separator)	单元分隔符
01111111	127	7F	DEL (Delete)	删除

可显示字符

二进制	十进制	十六进制	字符/缩写	解释
00100000	32	20	(Space)	空格
00100001	33	21	!
00100010	34	22	"
00100011	35	23	#
00100100	36	24	$
00100101	37	25	%
00100110	38	26	&
00100111	39	27	'
00101000	40	28	(
00101001	41	29	)
00101010	42	2A	*
00101011	43	2B	+
00101100	44	2C	,
00101101	45	2D	-
00101110	46	2E	.
00101111	47	2F	/
00110000	48	30	0
00110001	49	31	1
00110010	50	32	2
00110011	51	33	3
00110100	52	34	4
00110101	53	35	5
00110110	54	36	6
00110111	55	37	7
00111000	56	38	8
00111001	57	39	9
00111010	58	3A	:
00111011	59	3B	;
00111100	60	3C	<
00111101	61	3D	=
00111110	62	3E	>
00111111	63	3F	?
01000000	64	40	@
01000001	65	41	A
01000010	66	42	B
01000011	67	43	C
01000100	68	44	D
01000101	69	45	E
01000110	70	46	F
01000111	71	47	G
01001000	72	48	H
01001001	73	49	I
01001010	74	4A	J
01001011	75	4B	K
01001100	76	4C	L
01001101	77	4D	M
01001110	78	4E	N
01001111	79	4F	O
01010000	80	50	P
01010001	81	51	Q
01010010	82	52	R
01010011	83	53	S
01010100	84	54	T
01010101	85	55	U
01010110	86	56	V
01010111	87	57	W
01011000	88	58	X
01011001	89	59	Y
01011010	90	5A	Z
01011011	91	5B	[
01011100	92	5C	\
01011101	93	5D	]
01011110	94	5E	^
01011111	95	5F	_
01100000	96	60	`
01100001	97	61	a
01100010	98	62	b
01100011	99	63	c
01100100	100	64	d
01100101	101	65	e
01100110	102	66	f
01100111	103	67	g
01101000	104	68	h
01101001	105	69	i
01101010	106	6A	j
01101011	107	6B	k
01101100	108	6C	l
01101101	109	6D	m
01101110	110	6E	n
01101111	111	6F	o
01110000	112	70	p
01110001	113	71	q
01110010	114	72	r
01110011	115	73	s
01110100	116	74	t
01110101	117	75	u
01110110	118	76	v
01110111	119	77	w
01111000	120	78	x
01111001	121	79	y
01111010	122	7A	z
01111011	123	7B	{
01111100	124	7C	|
01111101	125	7D	}
01111110	126	7E	~