1.问题引出

计算机中数据使用ascii码存储，而ascii码在128~255之间是不可见字符，网络上传输数据时往往经过多个路由设备，不同设备不同的处理方式也可能导致数据传输过程中处理出现问题。所以我们通过Base64将数据全部编码成可见字符（A-Z, a-z, 0-9, +, / 共64个）可以降低出错的可能。

  • Base64应用：电子邮件的传输编码
    • 附件中图片、音视频都是二进制的文件，但邮件传输协议只支持ASCII字符传递，所以普通的二进制文件传输无法实现
    • HTTP协议要求请求行必须是ASCII编码
    • 数据库读写 blob 中存储中文
  • Base64算法
    • 把一组3个字节转换成一组4个字节（编码后字符串变大了）
    • 编码过程中如果最后一组3个字节凑不够，用0填充，输出字符使用’=’，可能补充1个或2个’=’来凑够3个字节一组

2. BIO

  • BIO对象的创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 创建BIO对象
BIO *BIO_new(const BIO_METHOD *type);
// 封装了base64编码方法的BIO,写的时候进行编码，读的时候解码
BIO_METHOD* BIO_f_base64();
// 封装了内存操作的BIO接口，包括了对内存的读写操作
BIO_METHOD* BIO_s_mem();

// 创建一个内存型的BIO对象
// BIO * bio = BIO_new(BIO_s_mem());
BIO *BIO_new_mem_buf(void *buf, int len);
// 创建一个磁盘文件操作的BIO对象
BIO* BIO_new_file(const char* filename, const char* mode);
// 释放整个bio链
void BIO_free_all(BIO *a);
  • BIO对象的读写操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 从BIO接口中读出len字节的数据到buf中。
// 成功就返回真正读出的数据的长度，失败返回0或－1，如果该BIO没有实现本函数则返回－2。
int BIO_read(BIO *b, void *buf, int len);
    - buf: 存储数据的缓冲区地址
    - len: buf的最大容量
// 往BIO中写入长度为len的数据。
// 成功返回真正写入的数据的长度，失败返回0或－1，如果该BIO没有实现本函数则返回－2。
int BIO_write(BIO *b, const void *buf, int len);
    - buf: 要写入的数据, 写入到b对应的设备(内存/磁盘文件)中
    - len: 要写入的数据的长度
// 将BIO内部缓冲区的数据都写出去, 成功: 1, 失败: 0或-1
int BIO_flush(BIO *b);
    - 在使用BIO_write()进行写操作的时候, 数据有时候在openssl提供的缓存中
    - 将openssl提供的缓存中的数据刷到设备(内存/磁盘文件)中
  • BIO对象插入到链表中
1
2
3
4
5
6
7
8
// 把参数中名为append的BIO附加到名为b的BIO上，并返回b
// 连接两个bio对象到链表中
// 在链表中的关系: b->append
BIO * BIO_push(BIO *b, BIO *append);
    - b: 要插入到链表中的头结点
    - append: 头结点的后继
// 把名为b的BIO从一个BIO链中移除并返回下一个BIO，如果没有下一个BIO，那么就返回NULL。
BIO * BIO_pop(BIO *b);
  • 通过定义BUF_MEM* ptr; 并使用 BIO_get_mem_ptr 函数来获取数据
1
2
3
4
5
6
7
8
9
10
typedef struct buf_mem_st BUF_MEM;
struct buf_mem_st {
    size_t length;              /* current number of bytes */
    char *data;
    size_t max;                 /* size of buffer */
    unsigned long flags;
};
// 该函数也是一个宏定义函数，它将b底层的BUF_MEM结构放在指针pp中。
BUF_MEM* ptr;
long BIO_get_mem_ptr(BIO *b, BUF_MEM **pp);
  • 一个BIO对象应用的例子，它可以很方便的完成一连串操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
BIO* md1 = BIO_new(xxx);    // md1 hash计算
BIO* md2 = BIO_new(xxx);    // md2 hash计算
BIO* b64 = BIO_new(xxx);    // base64 编解码
BIO* f = BIO_new(xxx);      // 操作磁盘文件

// 建立一个bio链
// b64->f
BIO_push(b64, f);// md2->b64->f
BIO_push(md2, b64);
// md1->md2->b64->f
BIO_push(md1, md2);
// 写数据操作 md1->md2->b64->f，读数据操作则相反
int BIO_write(md1, "hello, world", 11);
// 数据的处理过程  进行md1 的哈希计算 -> md2的哈希计算 -> base64编码 -> 数据被写到磁盘

2.1 Base64编解码

  • base64编码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
char* data = "hello, world";
// 创建base64编码的bio对象
BIO* b64 = BIO_new(BIO_f_base64());
// 最终在内存中得到一个base64编码之后的字符串
BIO* mem = BIO_new(BIO_s_mem());
// 将两个bio对象串联, 结构: b64->mem
BIO_push(b64, mem);
// 将要编码的数据写入到bio对象中，写数据应该传入头指针b64
BIO_write(b64, data, strlen(data)+1);
BIO_flush(BIO *b);
// 将数据从bio对象对应的内存中取出 -> char*
BUF_MEM* ptr;
// 数据通过ptr指针传出
long BIO_get_mem_ptr(b64, &ptr);
char* buf = new char[ptr->length];
memcpy(buf, ptr->data, ptr->length);
printf("编码之后的数据: %s\n", buf);
  • base64解码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 要解码的数据
char* data = "xxxxxxxxxxxxxxxxxxxx";
// 创建base64解码的bio对象
BIO* b64 = BIO_new(BIO_f_base64());
// 存储要解码的数据
BIO* mem = BIO_new(BIO_s_mem());
// 将数据写入到mem对应的内存中
BIO_write(mem, data, strlen(data));
    // 上面两句也可以合成下面一句写BIO *mem = BIO_new_mem_buf(data, strlen(data));
 
// 组织bio链
BIO_push(b64, mem);
// 读数据（给头节点）因为是read，所以反向流动 b64 <- mem，最后输出到给定的buf中
char buf[1024];
int BIO_read(b64, buf, 1024);
printf("base64解码的数据: %s\n", buf);