【常见开源库的二次开发】基于openssl的加密与解密——Base的编解码（二进制转ascll）（二）

目录：

[一、 Base64概述和应用场景](#一、 Base64概述和应用场景)

[1.1 概述](#1.1 概述)

[1.2 应用场景](#1.2 应用场景)

二、Base16

[2.1 Base16编码](#2.1 Base16编码)

[2.2 Base16编解码](#2.2 Base16编解码)

三、Base64

[四、OpenSSL BIO接☐](#四、OpenSSL BIO接☐)

[4.1 Filter BIOs：](#4.1 Filter BIOs：)

[4.2 Source/Sink BIOs：](#4.2 Source/Sink BIOs：)

[4.3 应用场景：](#4.3 应用场景：)

[4.4 具体使用：](#4.4 具体使用：)

[4.5 进行BIO编码：](#4.5 进行BIO编码：)

4.6进行BIO解密：

1.Base64编码（Base64Encode函数）

[2. Base64解码（Base64Decode`函数）](#2. Base64解码（Base64Decode`函数）)

[3. main函数](#3. main函数)

一、 Base64概述和应用场景

1.1 概述

Base64是一种编码方式，用于将二进制数据转换为ASCII字符串，以便在只支持文本的媒体上进行存储和传输。它不是一种加密算法，而是一种数据编码技术。Base64编码是一种简单而有效的数据编码方式，它允许二进制数据在文本环境中安全地传输和存储。尽管它不提供安全性（数据在传输过程中可以被读取），但它确保了数据的完整性和可移植性。

1.2 应用场景

邮件编码(base64)

xml或者json存储二进制内容

网页传递数据URL

数据库中以文本形式存放二进制数据

可打印的比特币钱包地址base58 Check(hash校验)

比特币地址bech32(base32)

二、Base16

2.1 Base16编码

Base16是一种编码方法，它使用16个可打印的ASCII字符来表示二进制数据。这些字符包括数字0到9和字母A到F。每个字符代表4个二进制位，因此Base16有时也称为十六进制编码。

在Base16编码过程中，首先将原始数据（如文本或文件）转换成二进制形式。对于ASCII编码字符，这一步直接涉及将每个字符转换为其对应的8位二进制值。对于UTF-8或其他编码，可能涉及更复杂的转换过程。

接下来，将得到的二进制串按照每4位一组进行切分。由于每组4位可以对应一个0到15之间的十进制数，这个数可以直接映射到上述提到的16个字符之一 。例如，二进制组0101对应十进制数5，按Base16编码转换成字符5；二进制组1001对应十进制数9，转换成字符9；二进制组1010对应十进制数10，转换成字符A，依此类推。

由于Base16使用4位二进制表示一个字符，一个字节（8位）被编码为两个Base16字符。因此，Base16编码后的数据大小是原始数据大小的两倍。

cpp 复制代码

#include  <iostream>

using  namespace  std;
//  定义一个静态的常量字符数组，用于Base16编码的字符映射表
static  const  char  BASE16_ENC_TAB[] = "123456789ABCDEF";

//  函数：将输入的原始数据按照Base16编码规则编码到输出字符串中
//  参数：in  -  指向原始数据的指针；size  -  原始数据的字节数；out  -  指向输出编码字符串的指针
//  返回值：编码后的字符串长度，即原始数据长度的两倍
int  Base16Encode(const  unsigned  char* in, int  size, char* out)
{
    //  遍历原始数据的每个字节
    for (int i = 0; i < size; i++)
    {
        //  将当前字节的高四位右移四位，得到高四位的值
        char  h = in[i] >> 4;  //  例如：二进制1000  0001通过移位变为0000  1000
        //  将当前字节的低四位与0x0F进行与操作，得到低四位的值
        char  l = in[i] & 0x0F;  //  例如：二进制0000  1111与0x0F与操作后得到0000  0001
        //  根据高四位的值，在编码表中查找对应的字符，并存入输出字符串
        out[i * 2] = BASE16_ENC_TAB[h];  //  映射高四位到编码表对应的字符
        //  根据低四位的值，在编码表中查找对应的字符，并存入输出字符串
        out[i * 2 + 1] = BASE16_ENC_TAB[l];  //  映射低四位到编码表对应的字符
    }
    //  返回编码后的字符串长度，即原始数据长度的两倍
    return  size * 2;
}

int  main(int  argc, char* argv[])
{
    cout << "测试Base16编码" << endl;
    //  定义待编码的原始数据
    const  unsigned  char  data[] = "测试base16";
    //  获取原始数据的字节长度
    int  len = sizeof(data) - 1;  //  减1是因为sizeof包含了结尾的'\0'字符
    //  定义足够大的输出数组来存放编码后的字符串
    char  out1[1024] = { 0 };
    //  打印原始数据
    cout << "原始数据:  " << data << endl;
    //  调用Base16编码函数
    int  re = Base16Encode(data, len, out1);
    //  打印编码后的字符串及其长度
    cout << "编码后长度:  " << re << ",  编码结果:  " << out1 << endl;
    return  0;
}

（1）定义了一个静态常量字符数组`BASE16_ENC_TAB`，包含了Base16编码所需的字符（'0'-'9'和'A'-'F'）。

**（2）Base16Encode`函数接收三个参数：**指向原始数据的指针`in`，原始数据的字节数`size`，以及指向输出编码字符串的指针`out`。

**（3）在`Base16Encode`函数中，使用一个循环遍历输入数据的每个字节。**对于每个字节，进行以下操作：

将字节的高四位右移四位，得到一个0到15之间的值，这个值对应于该字节的高四位。

将字节与0x0F进行位与操作，得到一个0到15之间的值，这个值对应于该字节的低四位。

使用这两个值作为索引，在`BASE16_ENC_TAB`数组中查找对应的字符，并将这些字符分别存储到输出字符串的相应位置。

（4）循环结束后，返回编码后的字符串长度，即原始数据长度的两倍。

**（5）在`main`函数中，定义了一个待编码的字符串`data`，计算其长度（不包括结尾的空字符'\0'），**并声明了一个足够大的字符数组`out1`来存储编码后的字符串。

（6）`main`函数打印出原始数据，调用`Base16Encode`函数进行编码，并打印出编码后的字符串及其长度。

代码定义了一个Base16Encode函数，用于将输入的原始数据按照Base16编码规则编码到输出字符串中 ，并在main函数中进行了测试。sizeof(data)包含了字符串结尾的空字符\0，所以在计算长度时应该减去1，否则会将空字符也进行编码。

2.2 Base16编解码

Base16（或称为十六进制）编码是一种将二进制数据转换为一种使用16个可打印字符（0-9和A-F）表示的方法。Base16编码的解码过程是将编码后的字符串转换回原始的二进制数。

实现了Base16编码和解码的功能。

cpp 复制代码

#include  <iostream>
//  引入iostream库，用于输入输出操作

using  namespace  std;
//  使用std命名空间，避免在代码中重复写std::前缀

//  定义一个静态的常量字符数组，用于Base16编码的字符映射表
static  const  char  BASE16_ENC_TAB[] = "0123456789ABCDEF";    //  包含16进制编码的字符，从0到F

static  const  char  BASE16_DEC_TAB[128] = {
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码0-15，非16进制字符映射为-1
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码16-31，非16进制字符映射为-1
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码32-47，非16进制字符映射为-1
       0,    1,    2,    3,    4,    5,    6,    7,    8,    9,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码48-57，对应0-9
      -1,  10,  11,  12,  13,  14,  15,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码65-70，对应A-F
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码71-76，非16进制字符映射为-1
      -1,  10,  11,  12,  13,  14,  15,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码91-96，对应a-f
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1     //  ASCII码97-102，非16进制字符映射为-1
};    //  正确填充解码表，非16进制字符映射为-1

//  函数：将输入的原始数据按照Base16编码规则编码到输出字符串中
int  Base16Encode(const  unsigned  char* in, int  size, char* out) {
    for (int i = 0; i < size; i++) {
        char  h = in[i] >> 4;            //  获取字节的高4位
        char  l = in[i] & 0x0F;          //  获取字节的低4位
        out[i * 2] = BASE16_ENC_TAB[h];    //  将高4位转换为对应的16进制字符
        out[i * 2 + 1] = BASE16_ENC_TAB[l];    //  将低4位转换为对应的16进制字符
    }
    return  size * 2;    //  返回编码后的长度，是输入长度的两倍
}

//  函数：将Base16编码的字符串解码回原始数据
int  Base16Decode(const  string& in, char* out) {
    for (int i = 0; i < in.size(); i += 2) {    //  以2个字符为一组进行解码
        unsigned  char  h = BASE16_DEC_TAB[static_cast<unsigned  char>(in[i])];    //  获取高4位
        unsigned  char  l = BASE16_DEC_TAB[static_cast<unsigned  char>(in[i + 1])];    //  获取低4位
        out[i / 2] = (h << 4) | l;    //  将高4位和低4位合并成原始字节
    }
    return  in.size() / 2;    //  返回解码后的长度，与输入长度相同
}

int main(int argc, char* argv[]) {
    cout << "测试Base16编码" << endl;
    const unsigned char data[] = "测试base16编码";
    int len = sizeof(data) - 1;
    char out1[1024] = { 0 };
    unsigned char out2[1024] = { 0 };

    cout << "原始数据: " << data << endl;
    int encodedLength = Base16Encode(data, len, out1);
    cout << "编码后长度: " << encodedLength << ", 编码结果: " << out1 << endl;

    int decodedLength = Base16Decode(out1, reinterpret_cast<char*>(out2));
    cout << "解码后长度: " << decodedLength << ", 解码结果: " << out2 << endl;

    return 0;
}

1. 字符映射表：

BASE16_ENC_TAB 是一个包含16进制编码字符的静态常量字符数组，从'0'到'F'

BASE16_DEC_TAB 是一个静态常量字符数组，用于将ASCII码转换为对应的16进制数值。数组中索引0-15对应ASCII码0-9和A-F，其他索引为-1，表示不是16进制字符。

2. Base16Encode函数：

接受三个参数：输入数据的指针in，输入数据的大小size，输出字符串的指针out。

循环遍历输入数据的每个字节，提取高4位和低4位。

使用高4位和低4位索引`BASE16_ENC_TAB`数组，获取对应的16进制字符。

将两个字符依次写入输出字符串的相应位置。

函数返回编码后的长度，即输入长度的两倍。

3. Base16Decode函数：

接受两个参数：Base16编码的字符串`in`和输出数据的指针out。

以两个字符为一组进行解码，因为Base16编码是将每个字节转换为两个字符。

使用输入字符串的每个字符索引BASE16_DEC_TAB数组，获取对应的16进制数值。

将高4位和低4位合并成一个字节，写入输出数据。

函数返回解码后的长度，即输入长度的一半。

4. main函数：

定义测试数据data，它是要编码和解码的字符串。

定义输出缓冲区out1用于存储编码后的字符串，以及`out2`用于存储解码后的数据。

打印原始数据。

调用Base16Encode函数编码数据，并打印编码后的长度和结果。

调用Base16Decode函数解码数据，并打印解码后的长度和结果。

通过定义字符映射表和实现编码和解码函数，实现了对字符串进行Base16编码和解码的功能。在`main`函数中，通过示例数据展示了如何使用这些函数。

三、Base64

**1. 分组处理：**Base64编码将每3个字节的二进制数据（24位）作为一组进行处理。

**2. 转换：**将这3个字节的24位分成4组，每组6位。每组的6位二进制数转换成对应的4位Base64字符。

**3. 补齐：**如果原始数据不是3的倍数，那么在最后可能会剩下1个或2个字节。为了将这些数据也能编码，Base64会在编码后的字符串末尾添加'='字符。如果剩余1个字节，就会添加一个'='；如果剩余2个字节，就会添加两个'='。

四、OpenSSL BIO接☐

penSSL BIO（Basic I/O）是OpenSSL库中用于抽象I/O操作的一个组件。BIO提供了多种接口来控制不同类型的I/O操作

4.1 Filter BIOs：

这些BIOs用于在数据从一个BIO流向另一个BIO的过程中进行转换或过滤。

BIO_f_base64()：用于Base64编码和解码。

BIO_f_cipher()：用于加密和解密。

BIO_f_md5()：用于MD5散列。

BIO_f_md4()：用于MD4散列。

BIO_f_sha1()：用于SHA-1散列。

BIO_f_sm3()：用于SM3散列。

BIO_f_sign()：用于签名。

BIO_f_verify()：用于验证签名。

BIO_f_negotiate()：用于TLS/SSL协商。

BIO_f_buffer()：用于缓冲。

4.2 Source/Sink BIOs：

这些BIOs是数据源或接收器

BIO_new(BIO_s_mem())：创建一个内存BIO，用于存储数据。

BIO_new(BIO_s_file())：创建一个文件BIO，用于文件读写。

BIO_new(BIO_s_socket())：创建一个套接字BIO，用于网络通信。

BIO_new(BIO_s_fd())：创建一个文件描述符BIO。

BIO_new(BIO_s_open())：创建一个用于打开文件的BIO。

BIO_new(BIO_s_mem())：创建一个内存BIO。

BIO_new(BIO_s_connect())：创建一个用于连接的BIO。

BIO_new(BIO_s_accept())：创建一个用于接受连接的BIO。

4.3 应用场景：

BIOs常用于构建复杂的I/O操作，如加密通信、数据转换等。

在TLS/SSL通信中，BIOs用于封装底层的I/O操作，如读写数据。

4.4 具体使用：

BIO_new()：用于创建一个新的BIO对象。

数据源BIO，例如BIO_new(BIO_s_mem())，创建一个内存BIO。

过滤BIO，例如BIO_new(BIO_f_base64())，创建一个Base64编码和解码的过滤BIO。

创建BIO链，例如BIO_push(b64_bio, mem_bio)，将Base64过滤BIO和内存BIO连接起来。

BIO_write()：用于向BIO写入数据。当使用Base64过滤BIO时，数据会被编码。

BIO_read_ex()：用于**从BIO读取数据。**当使用Base64过滤BIO时，数据会被解码。

4.5 进行BIO编码：

通过**使用OpenSSL的BIO链表和Base64编码过滤器，将输入数据编码为Base64格式，并将结果输出到控制台。**主要思路是利用OpenSSL库提供的功能，通过BIO链表处理编码过程，最后将编码后的数据存储并输出。

cpp 复制代码

#include  <iostream>
#include  <openssl/rand.h>
#include  <openssl/evp.h>
#include  <openssl/buffer.h>
#include  <cstring> 

using  namespace  std;

int  Base64Encode(const  unsigned  char*  in,  int  len,  char*  out_base64)
{
      if  (!in  ||  len  <=  0  ||  !out_base64)
          return  0;

      //  内存源
      auto  mem_bio  =  BIO_new(BIO_s_mem());
      if  (!mem_bio)  return  0;

      //  base64  filter
      auto  b64_bio  =  BIO_new(BIO_f_base64());

      if  (!b64_bio)
      {
          BIO_free(mem_bio);
          return  0;
      }

      //  形成BIO链表
      //  b64-mem
      BIO_push(b64_bio,  mem_bio);

      //  写入到base64  filter  进行编码，结果会传递到链表的下一个节点
      //  到mem中读取结果（从链表头部，代表了整个链表）
      int  re  =  BIO_write(b64_bio,  in,  len);
      if  (re  <  0)
      {
          //  清空整个链表节点
          BIO_free_all(b64_bio);
          return  0;
      }

      //  刷新缓存，写入链表的mem
      BIO_flush(b64_bio);

      int  outsize  =  0;

      //  从链表源内存读取
      BUF_MEM*  p_data  =  NULL;
      BIO_get_mem_ptr(b64_bio,  &p_data);
      if  (p_data)
      {
          //  确保输出数组足够大
          if  (p_data->length  <  len  *  4  /  3  +  1)
          {
              BIO_free_all(b64_bio);
              return  0;
          }
          memcpy(out_base64,  p_data->data,  p_data->length);
          outsize  =  p_data->length;
      }
      BIO_free_all(b64_bio);
      return  outsize;
}

int  main(int  argc,  char  *argv[])
{
      cout  <<  "The  openssl  BIO  base64!"  <<  endl;
      unsigned  char  data[]  =  "测试Base64数据";
      int  len  =  sizeof(data);
      char  out[len  *  4  /  3  +  1];  //  基于最大编码长度分配内存
      int  encoded_len  =  Base64Encode(data,  len,  out);
      if  (encoded_len  >  0)
      {
          out[encoded_len]  =  '\0';  //  确保字符串以null终止
          cout  <<  out  <<  endl;
      }
      getchar();
      return  0;
}

1. 包含必要的头文件：

<iostream>：用于输入输出流。

<openssl/evp.h>：用于加密和编码操作。

<openssl/buffer.h>：用于缓冲区操作。

<cstring>：用于字符串操作。

2. 命名空间声明：

使用`using namespace std;`使得`std`命名空间下的元素可以直接使用，无需前缀。

3. 定义Base64编码函数`Base64Encode：

函数接收三个参数：输入数据指针`in`，输入数据长度`len`，输出Base64编码数据指针out_base64。

进行参数有效性检查，如果输入无效，则返回0。

创建一个`BIO`（BASIC I/O）对象`mem_bio`，用于内存操作。

创建一个`BIO`对象`b64_bio`，用于Base64编码。

将`b64_bio`连接到`mem_bio`后面，形成BIO链表，以便将编码后的数据写入内存。

使用`BIO_write`将输入数据写入到`b64_bio`。

使用`BIO_flush`将缓存中的数据写入到内存中。

获取编码后的数据长度，并确保输出数组足够大。

将编码后的数据复制到输出数组中。

释放BIO资源，并返回编码后的数据长度。

4. 主函数main：

打印一个信息字符串。

定义一个要编码的字符数组`data`。

调用`Base64Encode`函数进行编码。

如果编码成功，将编码后的数据输出到控制台。

等待用户按键，然后退出程序。

4.6进行BIO解密：

使用了OpenSSL库中的BIO（块I/O）抽象，它提供了一种灵活的方式来处理不同类型的I/O操作，包括加密和编码操作 。通过将Base64编码和解码功能封装在BIO链表中。

cpp 复制代码

#include  <iostream>
#include  <openssl/rand.h>
#include  <openssl/evp.h>
#include  <openssl/buffer.h>
#include  <cstring>

using  namespace  std;

int  Base64Encode(const  unsigned  char* in, int  len, char* out_base64)
{
    if (!in || len <= 0 || !out_base64)
        return  0;

    //  内存源
    auto  mem_bio = BIO_new(BIO_s_mem());
    if (!mem_bio) 
	return  0;

    //  base64  filter
    auto  b64_bio = BIO_new(BIO_f_base64());

    if (!b64_bio)
    {
        BIO_free(mem_bio);
        return  0;
    }

    //  形成BIO链表
    //  b64-mem
    BIO_push(b64_bio, mem_bio);

    //  写入到base64  filter  进行编码，结果会传递到链表的下一个节点
    //  到mem中读取结果（从链表头部，代表了整个链表）
    //write为编码  3字节-》4字节，不足3字节补充0和=
    int  re = BIO_write(b64_bio, in, len);
    if (re < 0)
    {
        //  清空整个链表节点
        BIO_free_all(b64_bio);
        return  0;
    }

    //  刷新缓存，写入链表的mem
    BIO_flush(b64_bio);

    int  outsize = 0;

    //  从链表源内存读取
    BUF_MEM* p_data = NULL;
    BIO_get_mem_ptr(b64_bio, &p_data);
    if (p_data)
    {
        //  确保输出数组足够大
        if (p_data->length < len * 4 / 3 + 1)
        {
            BIO_free_all(b64_bio);
            return  0;
        }
        memcpy(out_base64, p_data->data, p_data->length);
        outsize = p_data->length;
    }
    BIO_free_all(b64_bio);
    return  outsize;
}
        

int  Base64Decode(const  char*  in,  int  len,  unsigned  char*  out_data)
{
      if  (!in  ||  len  <=  0  ||  !out_data)
          return  0;

      //  内存源：密文
      BIO*  mem_bio  =  BIO_new_mem_buf(in,  len);
      if  (!mem_bio)
          return  0;

      //  base64过滤器
      BIO*  b64_bio  =  BIO_new(BIO_f_base64());
      if  (!b64_bio)
      {
          BIO_free(mem_bio);
          return  0;
      }

      //  形成BIO链
      BIO_push(b64_bio,  mem_bio);

      //  读取  解码
      //  read为解码  4字节  ->  3字节
      size_t  size  =  0;
      BIO_read_ex(b64_bio,  out_data,  len,  &size);
      BIO_free_all(b64_bio);

      //  将解码后的字节转换为字符串
      string  decoded_string((char*)out_data,  size);

      //  打印解码后的字符串，以便于检查
      cout  <<  "Decoded  data:  "  <<  decoded_string  <<  endl;

      return  size;
}


int  main(int  argc,  char*  argv[])  {
      cout  <<  "The    openssl    BIO    base64!"  <<  endl;
      unsigned  char  data[]  =  "测试Base数据的结果";
      int  len  =  sizeof(data);
      char  out[len  *  4  /  3  +  1];      //  基于最大编码长度分配内存
      unsigned  char  out2[len  *  4  /  3  +  1];      //  声明变量out2

      int  encoded_len;

      cout << "source:  " << data << endl << endl;
      encoded_len  =  Base64Encode(data,  len,  out);
      cout << "encode:  ";
      if  (encoded_len  >  0)  {
          out[encoded_len]  =  '\0';      //  确保字符串以null终止
          cout  <<  out  <<  endl;
      }

      encoded_len  =  Base64Decode(out,  encoded_len,  out2);      //  使用编码后的长度
      cout  << endl << "Decoded  data:   ";
      cout  <<  (const  char*)out2  <<  endl;
      getchar();
      return  0;
}

实现了两个主要功能：Base64编码和Base64解码。

1.Base64编码（Base64Encode函数）

**（1）. 输入验证：**首先检查输入参数是否有效，包括输入数据指针、长度和输出缓冲区指针。

（2）. BIO链表初始化：

创建一个内存BIO（`BIO_s_mem`），用于临时存储编码数据。

创建一个Base64过滤器BIO（`BIO_f_base64`），用于执行Base64编码。

**（3）. 形成BIO链表：**将Base64过滤器BIO插入到内存BIO的前面，形成链表。

**（4）. 写入数据：**使用`BIO_write`函数将输入数据写入Base64过滤器BIO。

**（5）. 刷新缓存：**使用`BIO_flush`函数刷新缓存，确保所有数据都被编码。

（6）. 读取编码数据：

使用`BIO_get_mem_ptr`函数获取内存BIO中的数据。

检查输出缓冲区是否足够大以存储编码数据。

使用`memcpy`将编码数据复制到输出缓冲区。

**（7）. 清理：**释放所有BIO资源。

2. Base64解码（Base64Decode`函数）

**（1）. 输入验证：**同样检查输入参数是否有效。

（2）. BIO链表初始化：

创建一个内存BIO，用于存储输入的Base64编码数据。

创建一个Base64过滤器BIO，用于执行Base64解码。

**（3）. 形成BIO链表：**将Base64过滤器BIO插入到内存BIO的前面。

（4）. 读取和解码数据：

使用`BIO_read_ex`函数从Base64过滤器BIO中读取和解码数据。

输出解码后的数据到用户提供的缓冲区。

**（5）. 清理：**释放所有BIO资源。

3. main函数

（1）. 打印欢迎信息。

（2）. 编码数据：

调用`Base64Encode`函数进行编码。

输出编码后的Base64字符串。

（3）. 解码数据：

调用`Base64Decode`函数进行解码。

输出解码后的原始数据。

（4）. 等待用户输入，以便用户可以看到输出并手动关闭程序。

到此我们就算对Base64的编解码都实现其功能