当前位置：首页 > news >正文

openssl中BIO的使用

news 2025/5/10 6:06:55

BIO是OpenSSL的一个重要的结构和概念，是对数据IO与传递处理的一种类型抽象和功能封装，这里所说的数据IO与传递的“介质”包括：内存、文件、日志、标准设备、网络socket等，“处理”包括简单、加/解密、摘要、ssl协议下的读/写等的数据变换。

本文主要介绍了BIO的结构和使用方法，并以示例方式给出了一种对BIO的封装，可为下一步与socket的相关操作结合，编写自定义的“加密/解密流”。

本文示例适用于openssl3.0+。

1.概念

BIO是针对数据传递而设计的逻辑结构，因此它基本的概念模型是“管道”：数据由BIO一端进入，另一端流出，中间也可能进行数据变换。这样的“管道”结构可以依据是否有“缓存”，出入口等条件进行划分。

OpenSSL中将BIO分为两种类型：

Filter BIO：就是纯管道型BIO，数据不能保存在其中。
source/sink BIO：自带有容器的BIO，数据进行缓存，如果进一步细分，source BIO就是只出不进BIO，sink BIO就是只进不出BIO。

两种类型的BIO的概念示意图如上图所示。可以想象，如果将BIO首尾连接起来，就会构成BIO链，也如上图所示。BIO链在使用上，虽然仅对首尾BIO进行了读写操作，但是这种操作是会依次传递给下一个BIO的，因而BIO链逻辑上看作是一个复杂的BIO。

2.类型

OpenSSL中已经预定义了若干种BIO，直接可以使用它们。

主要Source/Sink类型BIO

BIO_s_file/ BIO_s_fd：文件BIO，BIO_s_file对应FILE*，而BIO_s_fd对应POSIX文件描述符，它们可用于写入和读取文件。
BIO_s_socket：网络socketBIO，用于通过网络进行通信。
BIO_s_null：空BIO，类似/dev/null，只能写入，读取数据会导致EOF。
BIO_s_mem：内存BIO，用于写入和读取内存。
BIO_s_bio：一种特别的BIO，被称为BIO pair，后文单独说明。

主要Filter类型BIO

BIO_f_base64：base64 BIO，通过此BIO的BIO_write将数据编码为base64格式， BIO_read通过此BIO解码base64格式的数据。
BIO_f_cipher：密码BIO，通过它的数据会被加/解密，密码算法可以设置。
BIO_f_md：摘要计算BIO，它不会修改通过它的数据，而仅计算流经其中的数据摘要，摘要算法可以设置，使用特殊功能检索计算出的摘要。
BIO_f_buffer：缓冲BIO，它也不会更改通过它的数据。写入此BIO的数据被缓冲，因此并非每次对该BIO的写入操作都会导致将数据写入下一个BIO。至于阅读，情况类似。这样可以减少位于缓冲IO后面的BIO上的IO操作数。
BIO_f_ssl ：SSL/TLS 协议BIO，通过它的数据会按照协议规则进行加解密
3.基本使用函数

创建/释放函数为：

BIO *BIO_new(const BIO_METHOD *)
BIO_free_all(BIO *)

设置/控制基本函数为：

BIO_ctrl(BIO *,int,long ,void *)

以此函数为基础，定义了一些方便使用的宏：BIO_reset，BIO_tell，BIO_eof，BIO_flush等
读写操作的基本函数为：

int BIO_read_ex(BIO *, void *, size_t, size_t *)
int BIO_write_ex(BIO *, const void *, size_t, size_t *)

对于BIO链，bio_st结构中有变量next_bio，prev_bio，可以指向其前后的BIO，这也是BIO链式操作的基础。BIO链的基本操作函数为：

BIO * BIO_push(BIO *a,BIO *b);
BIO * BIO_pop(BIO *b);

前者将b链接到a之后，返回b，后者将b从链条上摘除，返回b，原来的链条依然完整。

BIO还有一些辅助函数，例如处理错误，获取状态等函数。

4.BIO Pair

BIO对是一种比较特别的BIO，它由两个BIO组成，但从它的实现代码来看，它似乎是与BIO平行的一种实现方式，因而不能单纯的用BIO链来说明，它的逻辑结构如下图所示。

BIO pair连接两个外部端A,B，从外部来看，A端写，则可从B端读出；B端写，则可从A端读出。从内部来看，有两个内存型BIOA和BIOB，分别与A端和B端相连，它们有各自的缓存，A端存入和B端读取的数据，利用的是BIOA缓存，B端写入A端读取则利用的是BIOB的缓存。

因此BIO pair类似于“双向有缓存管道”，从任一端写入，另一端读出，由于内存缓存的利用，使得一端的读/写操作都是“即刻”完成的，它不用关心另一端什么时候做写/读操作，这就是典型的异步操作。目前很多网络通信库采用的都是异步读写，因而BIO pair这种应用模型是OpenSSL适配这些网络库的一个重要方法。

创建BIO pair的简洁方法是BIO_new_bio_pair，它实际上是 BIO_new, BIO_make_bio_pair, BIO_set_write_buf_size的组合。

5.构造自定义BIO类型

OpenSSL已定义了若干BIO，当然也可以自定义一个。下面的示例构造了一个简单的CMYBIO，以此来说明BIO的工作原理。

class CMYBIO
{
private:static int write_ex(BIO* h, const char* buf, size_t num, size_t * len){printf("CMYBIO::write_ex\n");for (int i = 0; i < num; ++i)  printf("%c", buf[i]);printf("\n");*len = num;return 1;}static int read_ex(BIO* h, char* buf, size_t size, size_t* len){printf("CMYBIO::read_ex\n");unsigned int* opt = (unsigned int*)BIO_get_data(h);if (*opt == 0){size = size > 6 ? 6 : size;memcpy(buf, "openss", size);*len = size;
//			BIO_clear_retry_flags(h);
//			BIO_copy_next_retry(h);return 1;}if (*opt == 1){size = 9;memcpy(buf, "MTIzNDU2\n", size);           //base64("123456")*len = size;BIO_clear_retry_flags(h);
//			BIO_copy_next_retry(h);return 1;}return 0;}static long ctrl(BIO* h, int cmd, long arg1, void* arg2){printf("CMYBIO::ctrl[%d]\n", cmd);if (cmd == 0xff){unsigned int* opt = (unsigned int*)BIO_get_data(h);*opt = arg1;}return 1;}static int create(BIO* bio){printf("CMYBIO::create\n");BIO_set_init(bio, 1);            //”init” must be set explicitly,otherwise “read”/”write” methods will be invoked. Although it seems odd, the “framework” would not do It for you by the returned value. unsigned int* opt =(unsigned int*) malloc(sizeof(int));*opt = 0;BIO_set_data(bio,opt);return 1;}static int destory(BIO* bio){printf("CMYBIO::destory\n");unsigned int* opt=(unsigned int*)BIO_get_data(bio);free(opt);return 1;}static BIO_METHOD* method;
public:static BIO_METHOD* BIO_s_my(){return CMYBIO::method;}static void UnInit(){BIO_meth_free(CMYBIO::method);}static void Init(void){CMYBIO::method = BIO_meth_new((100 | BIO_TYPE_SOURCE_SINK), "My BIO");int r;r = BIO_meth_set_create(CMYBIO::method, CMYBIO::create);r = BIO_meth_set_destroy(CMYBIO::method, CMYBIO::destory);r = BIO_meth_set_write_ex(CMYBIO::method,  CMYBIO::write_ex);r=BIO_meth_set_read_ex(CMYBIO::method, CMYBIO::read_ex);r=BIO_meth_set_puts(CMYBIO::method,  nullptr);r=BIO_meth_set_gets(CMYBIO::method, nullptr);        r=BIO_meth_set_ctrl(CMYBIO::method, CMYBIO::ctrl);r=BIO_meth_set_callback_ctrl(CMYBIO::method, nullptr);}};BIO_METHOD* CMYBIO::method=nullptr;

下面的代码使用了上面构造的CMYBIO，其中第一段是单独使用CMYBIO，第二段是与BIO_f_base64组成链式应用。CMYBIO作为单独应用，构造的功能已经够用，但组成链式应用，由于链式调用需要在每个具体的实现方法内来完成，因此上面的代码还不够，为简化，这里仅把CMYBIO作为链式应用的最后一级来使用。

long bio_cb(BIO* b, int oper, const char* argp, size_t len, int argi, long argl, int ret, size_t* processed)
{printf("bio callback:%d, %u\n", oper,(unsigned int)len);return 1;
}
void test_bio()
{BIO* bmy = NULL;size_t s = 0;int len = 0;char* out = NULL;char cc[24];memset(cc, 0, sizeof(cc));CMYBIO::Init();bmy = BIO_new(CMYBIO::BIO_s_my());BIO_set_callback_ex(bmy, bio_cb);len = BIO_write_ex(bmy, "openssl", 7, &s);printf("BIO_write_ex return [%d, %u]\n\n", len, (unsigned int)s);len = 7;out = (char*)OPENSSL_malloc(len);memset(out, 0, len);len = BIO_read_ex(bmy, out, len-1, &s);printf("BIO_read_ex return [%d,%u]%s\n", len, (unsigned int)s, out);OPENSSL_free(out);BIO_free(bmy);printf("--------------------------------\n");BIO* b64 = BIO_new(BIO_f_base64());BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);bmy = BIO_new(CMYBIO::BIO_s_my());BIO_push(b64, bmy);len=BIO_write_ex(b64, "123456", 6, &s);printf("BIO_write_ex return [%d, %u]\n\n", len, (unsigned int)s);BIO_flush(b64);             //important!!!BIO_ctrl(bmy, 0xff, 1, nullptr);len = BIO_read_ex(b64, cc, sizeof(cc)- 1, &s);printf("BIO_read_ex return [%d,%u]%s\n\n", len, (unsigned int)s, cc);//OPENSSL_free(out);BIO_free_all(b64);CMYBIO::UnInit();
}

整个过程输出如下图所示。前一个示例主要展示CMYBIO中各方法的调用过程，其中还设置了“钩子”函数，从输出可以清晰看出BIO的工作过程。后一个示例稍有些麻烦，其中增加了CMYBIO内部的设置，从而可以实现不同的效果。