从零构建：用C++、Libevent与OpenSSL打造高性能异步HTTPS客户端

最近在重构一个内部的数据采集服务时，我遇到了一个经典问题：如何用C++高效、稳定地抓取大量HTTPS页面？市面上的HTTP客户端库要么功能臃肿，要么在异步处理上不够灵活。最终，我决定回归底层，用Libevent和OpenSSL自己动手。这听起来有点“硬核”，但当你真正理解事件驱动和TLS握手的每一个环节后，那种掌控感是无与伦比的。这篇文章，就是把我踩过的坑、调试过的细节，以及最终跑起来的完整代码，毫无保留地分享给你。如果你也在为C++网络编程中的异步、SSL验证和性能问题头疼，那么接下来的内容，或许能给你一条清晰的路径。

1. 基石：为什么是Libevent + OpenSSL？

在开始写代码之前，我们得先搞清楚手里的工具。选择Libevent和OpenSSL，不是一个随意的决定，而是基于它们在各自领域的绝对地位和互补性。

Libevent 的核心价值在于它抽象并统一了不同操作系统下的高性能I/O多路复用机制。在Linux上是epoll，在BSD/macOS上是kqueue，在老的系统上可能是select或poll。Libevent帮你屏蔽了这些差异，让你用一套统一的API就能构建出可移植的高并发网络程序。它的bufferevent更是神器，将套接字读写、缓冲区管理、事件回调封装在一起，让我们从繁琐的非阻塞I/O细节中解放出来，专注于业务逻辑。

OpenSSL 则是密码学和安全通信领域的“事实标准”。虽然近年来有像BoringSSL、LibreSSL这样的分支，但OpenSSL的生态和文档依然是最丰富的。HTTPS的本质就是在HTTP之下加了一层TLS/SSL，而OpenSSL正是实现这一层的核心库。

那么，为什么要把它们俩结合起来？因为Libevent本身不处理加密。你可以用Libevent轻松地管理成千上万个TCP连接，但一旦涉及到HTTPS，数据流的加密解密、证书握手就必须由OpenSSL来完成。libevent_openssl这个扩展模块，正是为了桥接这两者而生。它创建了一种特殊的bufferevent，内部集成了SSL会话对象，使得加密通信对开发者来说，几乎和普通TCP通信一样简单——当然，“几乎”之外的那些细节，正是我们需要攻克的重点。

提示：在项目启动前，请务必通过系统包管理器安装开发库。例如在Ubuntu上：sudo apt-get install libevent-dev libssl-dev。在macOS上使用Homebrew：brew install libevent openssl。编译时需要正确链接这些库。

2. 项目骨架与核心数据结构设计

好的开始是成功的一半。在动手实现具体功能前，我们先搭建好项目的骨架，并设计一个贯穿始终的上下文结构。这能避免在回调函数中陷入全局变量或混乱的参数传递。

首先，创建一个https_async_client.cpp文件，并引入所有必要的头文件：

#include <iostream>
#include <string>
#include <memory>
#include <cstring>
#include <system_error>

// Libevent 核心头文件
#include <event2/event.h>
#include <event2/bufferevent.h>
#include <event2/bufferevent_ssl.h>
#include <event2/dns.h>
#include <event2/buffer.h>
#include <event2/util.h>

// OpenSSL 头文件
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/x509v3.h>

接下来，我们定义一个ClientContext结构体。在异步编程中，回调函数是执行的主体，但它们往往缺乏直接的“状态”感知。这个上下文对象就是我们的“状态携带者”，它会在各个回调函数之间传递。

struct ClientContext {
    // 核心事件循环和DNS解析器
    event_base* base = nullptr;
    evdns_base* dns_base = nullptr;

    // SSL上下文（配置工厂）和SSL会话对象
    SSL_CTX* ssl_ctx = nullptr;
    SSL* ssl = nullptr; // 注意：此对象生命期最终由bufferevent管理

    // 目标服务器信息
    std::string hostname;
    unsigned short port = 443;

    // 请求状态标志
    bool request_sent = false;
    bool connection_verified = false;

    // 用于构造HTTP请求的路径
    std::string request_path = "/";

    // 析构函数，确保资源释放
    ~ClientContext() {
        // 注意：bufferevent会在回调中释放，并连带清理ssl对象
        if (dns_base) evdns_base_free(dns_base, 0);
        if (base) event_base_free(base);
        if (ssl_ctx) SSL_CTX_free(ssl_ctx);
        // ssl 对象不应在此手动释放，除非它未被成功移交
    }
};

这个结构体有几个关键点：

  1. 资源所有权清晰：base、dns_base、ssl_ctx由上下文对象在析构时负责释放。
  2. 状态跟踪：request_sent和connection_verified确保我们不会重复发送请求，并能记录证书验证结果。
  3. RAII思想：虽然我们用了原始指针（因为C接口需要），但通过析构函数来管理生命周期，模仿了智能指针的部分行为，减少了资源泄漏的风险。

3. 深入TLS核心：SSL_CTX的配置与陷阱规避

创建SSL_CTX是整个HTTPS客户端中最需要谨慎对待的环节之一。一个配置不当的SSL_CTX，轻则导致连接失败，重则引入严重的安全漏洞。下面这个create_ssl_context函数，我融合了多个生产环境项目的经验。

std::unique_ptr<SSL_CTX, decltype(&SSL_CTX_free)> create_ssl_context(const std::string& hostname_for_sni) {
    // 使用unique_ptr配合自定义删除器，实现异常安全
    const SSL_METHOD* method = TLS_client_method();
    if (!method) {
        throw std::runtime_error("无法创建TLS客户端方法");
    }

    SSL_CTX* ctx = SSL_CTX_new(method);
    if (!ctx) {
        throw std::runtime_error("无法创建SSL_CTX: " + std::string(ERR_error_string(ERR_get_error(), nullptr)));
    }

    // 1. 禁用不安全的旧协议
    SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1);
    // 优先使用TLS 1.2 或 1.3
    SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);

    // 2. 配置密码套件，确保使用强加密
    if (!SSL_CTX_set_cipher_list(ctx, "ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20:!aNULL:!MD5:!DSS")) {
        SSL_CTX_free(ctx);
        throw std::runtime_error("设置密码套件失败");
    }

    // 3. 证书验证：这是安全通信的基石
    // 首先尝试加载系统默认的CA证书存储
    if (!SSL_CTX_set_default_verify_paths(ctx)) {
        std::cerr << "[警告] 加载系统默认CA证书路径失败。连接可能因证书验证而失败。" << std::endl;
        // 生产环境中，这里应该失败或加载指定的CA证书包
        // SSL_CTX_load_verify_locations(ctx, "/path/to/your/ca-bundle.crt", nullptr);
    }
    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, nullptr); // 启用对等证书验证
    SSL_CTX_set_verify_depth(ctx, 4); // 设置证书链验证深度

    // 4. 为SNI（服务器名称指示）做准备
    // SNI信息将在创建SSL对象时设置，此处确保CTX支持
    // OpenSSL 1.1.1+ 默认支持，但显式设置无妨

    return {ctx, SSL_CTX_free}; // 返回管理指针
}

这里有几个极易踩坑的细节：

  • 协议版本：明确禁用SSLv2、SSLv3、TLSv1.0和TLSv1.1，这些协议已被证实存在安全缺陷。将最低版本设为TLSv1.2是当前的最佳实践。
  • 密码套件：SSL_CTX_set_cipher_list的字符串参数定义了握手时协商加密算法的优先级。上面给出的列表优先选择前向保密（Forward Secrecy）的椭圆曲线算法套件，并排除已知不安全的算法（如!aNULL:!MD5）。
  • 证书验证：SSL_CTX_set_default_verify_paths()会尝试加载操作系统预置的受信任根证书。这在大多数桌面和服务器系统上有效，但在某些定制化环境或容器中可能失败。对于关键应用，务必准备一个可靠的CA证书包（如从curl项目获取的cacert.pem），并通过SSL_CTX_load_verify_locations指定其路径。
  • SNI的重要性：现代Web服务器普遍使用虚拟主机，一个IP地址承载多个域名。SNI允许客户端在TLS握手之初就告诉服务器它要访问的具体域名，服务器才能返回对应的证书。没有SNI，访问很多云服务商托管的站点会直接失败或收到错误的证书。

为了更清晰地对比不同配置选项的影响，可以参考下表：

配置项推荐设置错误设置示例可能导致的问题
最低TLS版本TLS1_2_VERSIONSSL_OP_NO_TLSv1 (仅禁用，未设最低)可能意外协商到不安全的TLSv1.1
证书验证SSL_VERIFY_PEER + 正确CA路径SSL_VERIFY_NONE中间人攻击风险，HTTPS形同虚设
SNI设置创建SSL对象后立即设置不设置访问共享IP的站点失败（证书域名不匹配）
密码套件包含ECDHE、AESGCMALL:!aNULL (过于宽泛)可能协商到强度较弱或过时的算法

4. 异步引擎：事件回调的编写与资源管理

这是整个客户端异步逻辑的核心。我们将实现两个回调函数：event_callback处理连接、断开、错误等事件；read_callback处理接收到的数据。这里的每一行代码，都关系到程序的稳定性和健壮性。

首先看event_callback，它像是一个连接的生命周期管家：

void event_callback(struct bufferevent* bev, short events, void* ptr) {
    auto* ctx = static_cast<ClientContext*>(ptr);

    if (events & BEV_EVENT_CONNECTED) {
        std::cout << "[信息] 连接已建立至 " << ctx->hostname << ":" << ctx->port << std::endl;

        // 关键：获取SSL对象并进行事后检查
        SSL* ssl = bufferevent_openssl_get_ssl(bev);
        if (ssl) {
            std::cout << "[信息] 使用的加密套件: " << SSL_get_cipher_name(ssl) << std::endl;

            // 检查证书验证结果
            long verify_result = SSL_get_verify_result(ssl);
            if (verify_result == X509_V_OK) {
                std::cout << "[成功] 服务器证书验证通过。" << std::endl;
                ctx->connection_verified = true;
            } else {
                std::cerr << "[警告] 证书验证失败: "
                          << X509_verify_cert_error_string(verify_result) << std::endl;
                // 生产环境应终止连接，此处为演示继续
                ctx->connection_verified = false;
            }

            // 可选：打印证书信息（调试用）
            X509* cert = SSL_get_peer_certificate(ssl);
            if (cert) {
                char* subj = X509_NAME_oneline(X509_get_subject_name(cert), nullptr, 0);
                char* issuer = X509_NAME_oneline(X509_get_issuer_name(cert), nullptr, 0);
                std::cout << "  证书主题: " << (subj ? subj : "N/A") << std::endl;
                std::cout << "  颁发者: " << (issuer ? issuer : "N/A") << std::endl;
                OPENSSL_free(subj);
                OPENSSL_free(issuer);
                X509_free(cert);
            }
        }

        // 连接建立后，发送HTTP请求
        if (!ctx->request_sent) {
            std::string request = "GET " + ctx->request_path + " HTTP/1.1\r\n"
                                  "Host: " + ctx->hostname + "\r\n"
                                  "User-Agent: Libevent-HTTPS-Client/1.0\r\n"
                                  "Accept: */*\r\n"
                                  "Connection: close\r\n"
                                  "\r\n"; // 注意最后的空行

            std::cout << "[发送] HTTP请求：" << std::endl;
            std::cout << request << std::endl;

            bufferevent_write(bev, request.data(), request.size());
            ctx->request_sent = true;
        }
        return;
    }

    // 处理错误和结束事件
    if (events & BEV_EVENT_EOF) {
        std::cout << "[信息] 连接被服务器关闭。" << std::endl;
    } else if (events & BEV_EVENT_ERROR) {
        std::cerr << "[错误] 连接发生错误。" << std::endl;
        // 尝试获取OpenSSL特定错误
        unsigned long ssl_err;
        while ((ssl_err = bufferevent_get_openssl_error(bev)) != 0) {
            std::cerr << "  OpenSSL错误: " << ERR_reason_error_string(ssl_err) << std::endl;
        }
        // 打印系统套接字错误
        if (errno) {
            std::cerr << "  系统错误: " << std::strerror(errno) << std::endl;
        }
    } else if (events & BEV_EVENT_TIMEOUT) {
        std::cerr << "[错误] 连接超时。" << std::endl;
    }

    // 发生错误或EOF，清理当前连接并退出事件循环
    bufferevent_free(bev); // 这会自动关闭socket并清理SSL
    event_base_loopexit(ctx->base, nullptr); // 通知主循环退出
}

然后是read_callback，它负责处理服务器返回的数据流。这里演示的是最简单的打印，实际应用中你需要一个HTTP响应解析器。

void read_callback(struct bufferevent* bev, void* ptr) {
    auto* ctx = static_cast<ClientContext*>(ptr);
    struct evbuffer* input = bufferevent_get_input(bev);
    size_t len = evbuffer_get_length(input);

    if (len > 0) {
        // 分配缓冲区并读取数据
        std::vector<char> buffer(len + 1);
        evbuffer_remove(input, buffer.data(), len);
        buffer[len] = '\0';

        std::cout << "[接收] 数据块 (" << len << " 字节):" << std::endl;
        std::cout << "----------------------------------------" << std::endl;
        // 注意：这里打印的是原始响应，包含HTTP头和可能的二进制体
        // 对于非文本内容（如图片），直接打印会乱码
        std::cout.write(buffer.data(), len);
        std::cout << "\n----------------------------------------" << std::endl;
    }
}

注意：在event_callback中，一旦发生BEV_EVENT_ERROR或BEV_EVENT_EOF，我们调用bufferevent_free(bev)和event_base_loopexit。这是单连接客户端的典型做法。如果你要构建一个多连接并发的客户端（如爬虫），则不应轻易退出整个事件循环，而应只释放出错的连接，让其他连接继续工作。

5. 主流程串联：从初始化到事件循环

现在，我们把所有模块像拼图一样组合起来，形成完整的main函数。这个函数体现了异步编程的典型流程：初始化 -> 配置 -> 启动 -> 等待 -> 清理。

int main(int argc, char* argv[]) {
    // 默认目标，可以通过命令行参数覆盖
    std::string target_host = "www.example.com";
    std::string target_path = "/";
    if (argc > 1) target_host = argv[1];
    if (argc > 2) target_path = argv[2];

    std::cout << "目标: HTTPS://" << target_host << target_path << std::endl;

    try {
        // 1. 全局初始化
        // OpenSSL 1.1.0+ 后，以下调用通常不是必须的，但为了兼容性保留
        SSL_library_init();
        SSL_load_error_strings();
        OpenSSL_add_all_algorithms();

        // 2. 创建并配置应用上下文
        auto ctx = std::make_unique<ClientContext>();
        ctx->hostname = target_host;
        ctx->port = 443;
        ctx->request_path = target_path;

        // 3. 创建SSL上下文（配置工厂）
        ctx->ssl_ctx = create_ssl_context(target_host).release(); // unique_ptr释放所有权

        // 4. 创建Libevent事件基础
        ctx->base = event_base_new();
        if (!ctx->base) throw std::runtime_error("无法创建event_base");
        ctx->dns_base = evdns_base_new(ctx->base, 1); // 1 表示使用系统DNS配置
        if (!ctx->dns_base) throw std::runtime_error("无法创建evdns_base");

        // 5. 创建SSL会话对象并设置SNI
        ctx->ssl = SSL_new(ctx->ssl_ctx);
        if (!ctx->ssl) throw std::runtime_error("无法创建SSL对象");
        if (!SSL_set_tlsext_host_name(ctx->ssl, target_host.c_str())) {
            std::cerr << "[警告] 设置SNI主机名失败，可能影响证书验证。" << std::endl;
        }

        // 6. 创建支持SSL的bufferevent
        struct bufferevent* bev = bufferevent_openssl_socket_new(
            ctx->base,
            -1, // -1 表示由libevent自动创建套接字
            ctx->ssl, // SSL对象，其生命期将由bufferevent接管
            BUFFEREVENT_SSL_OPENING, // 客户端，正在打开SSL连接
            BEV_OPT_CLOSE_ON_FREE | BEV_OPT_DEFER_CALLBACKS
        );
        if (!bev) {
            SSL_free(ctx->ssl); // bev创建失败，需手动清理ssl
            throw std::runtime_error("无法创建SSL bufferevent");
        }
        // bev创建成功，ctx->ssl 对象已被接管，后续不应再手动释放

        // 允许“脏”关闭（某些服务器可能不发送TLS close_notify警报）
        bufferevent_openssl_set_allow_dirty_shutdown(bev, 1);

        // 7. 设置回调函数
        bufferevent_setcb(bev, read_callback, nullptr, event_callback, ctx.get());

        // 8. 发起异步连接（包含DNS解析）
        std::cout << "[信息] 正在发起异步连接..." << std::endl;
        if (bufferevent_socket_connect_hostname(bev, ctx->dns_base, AF_UNSPEC,
                                                target_host.c_str(), ctx->port) < 0) {
            bufferevent_free(bev);
            throw std::runtime_error("发起连接失败");
        }

        // 9. 启用读写事件
        bufferevent_enable(bev, EV_READ | EV_WRITE);

        // 10. 启动事件循环（阻塞，直到event_base_loopexit被调用）
        std::cout << "[信息] 进入事件循环..." << std::endl;
        event_base_dispatch(ctx->base);
        std::cout << "[信息] 事件循环结束。" << std::endl;

        // bufferevent已在回调函数中释放，此处无需再操作
        std::cout << "程序执行完毕。" << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "[致命错误] " << e.what() << std::endl;
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

6. 编译、运行与实战调试

代码写完了，接下来让它跑起来。编译命令会根据你的系统环境略有不同。

Linux/Unix系统下的编译：

# 使用pkg-config自动获取编译和链接标志（推荐）
g++ -std=c++17 -O2 -g https_async_client.cpp -o https_client \
    $(pkg-config --cflags --libs libevent libevent_openssl openssl) \
    -pthread

macOS系统下的编译（使用Homebrew安装的库）：

# 假设OpenSSL和Libevent通过Homebrew安装
OPENSSL_PREFIX=$(brew --prefix openssl@3)  # 或 openssl@1.1
LIBEVENT_PREFIX=$(brew --prefix libevent)

g++ -std=c++17 -O2 -g https_async_client.cpp -o https_client \
    -I${OPENSSL_PREFIX}/include -I${LIBEVENT_PREFIX}/include \
    -L${OPENSSL_PREFIX}/lib -L${LIBEVENT_PREFIX}/lib \
    -levent -levent_openssl -lssl -lcrypto -pthread

运行与测试：

# 测试1：访问默认示例网站
./https_client

# 测试2：访问指定网站和路径
./https_client "api.github.com" "/users/octocat"

# 测试3：访问需要SNI的站点（如很多云服务）
./https_client "httpbin.org" "/get"

运行后，你会在终端看到详细的连接过程、发送的HTTP请求、服务器返回的原始响应（包括HTTP头）。如果遇到证书验证失败，请检查系统的CA证书存储，或按照第3节所述，指定自定义的CA证书包路径。

7. 超越基础：构建健壮的生产级客户端

一个能跑通的示例只是起点。要将其用于实际项目，尤其是像网络爬虫这样的场景，我们还需要考虑更多。下面是一些关键的增强方向：

7.1 实现完整的HTTP响应解析

目前的read_callback只是打印原始数据。一个实用的客户端需要解析HTTP状态码、头部字段，并正确处理分块传输编码（Transfer-Encoding: chunked）和内容编码（如gzip压缩）。你可以设计一个简单的状态机，或者集成一个轻量级的HTTP解析器。

7.2 连接池与并发管理

单线程异步IO虽然高效，但单个连接的速度受限于RTT（往返时间）。要提升整体吞吐量，需要管理多个并发连接。这意味着：

  • 维护一个std::vector<bufferevent*>或类似结构来管理所有活跃连接。
  • 实现一个连接池，复用已建立的HTTPS连接（如果服务器支持Keep-Alive），避免为每个请求都进行昂贵的TLS握手。
  • 在event_callback中，不再轻易调用event_base_loopexit，而是只清理当前连接，并可能从池中移除它。

7.3 超时与重试机制

网络是不稳定的。必须为连接、读写设置超时。

// 设置连接超时和读写超时（单位：秒）
struct timeval connect_timeout = {10, 0}; // 10秒连接超时
struct timeval read_timeout = {30, 0};    // 30秒读超时
struct timeval write_timeout = {10, 0};   // 10秒写超时

bufferevent_set_timeouts(bev, &connect_timeout, &read_timeout, &write_timeout);

当event_callback收到BEV_EVENT_TIMEOUT事件时，根据策略决定是重试当前请求，还是标记为失败。

7.4 更精细的错误分类与日志

将错误分为网络错误（连接拒绝、超时）、TLS错误（证书无效、握手失败）、HTTP错误（4xx, 5xx）和业务逻辑错误。为每一类错误设计不同的重试或处理策略。使用日志库（如spdlog）替代std::cout/cerr，以便输出到文件并支持日志级别。

7.5 资源限制与礼貌爬取

无节制的并发请求会拖垮目标服务器或导致你的IP被封锁。需要实现：

  • 速率限制：控制每秒发起的请求数。
  • 域名并发限制：限制对同一域名同时发起的连接数。
  • 尊重robots.txt：在爬取前先获取并解析目标网站的robots.txt文件。

把这些点都考虑到并实现，你的HTTPS客户端就从一个小工具，进化成了一个真正可用于生产环境的数据采集引擎。这其中的每一步，都需要大量的测试和调试，但带来的性能和可控性的提升，绝对是值得的。

Logo
乐奇 Rokid 开放社区

更多推荐

cover

从源码拆解一个 AIUI 每日一词智能体：页面、离线索引与硬件交互

avatar 乐奇 Rokid 开放社区
cover

一句话打造「丢哪里」垃圾分类AIUI智能体

avatar 乐奇 Rokid 开放社区
cover

“什么值得买”兴趣消费服务接入乐奇AI眼镜，开启“看见即搜索”新体验

avatar 乐奇 Rokid 开放社区