boost::asio::ssl::context无法发送客户端证书问题求助

我正在将Java客户端库移植到C静态库，用于对接基于Netty的Java服务器，技术栈为Boost 1.87 + C23。使用boost::asio::ssl::context的API加载客户端证书和私钥时，SSL握手失败，Java服务器日志显示未收到证书链；但通过SSL原生句柄调用OpenSSL API加载则能正常完成握手。尝试设置SSL选项与双向认证模式均无效，需定位问题原因并找到正确解决方式。

代码示例 #

#pragma once

#include "Config.hpp"
#include "util/concurrent/ThreadPool.hpp"
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <filesystem>
#include <memory>
#include <string>

using namespace boost::asio;
namespace fs = std::filesystem;

namespace sdk {

class HttpClient {
  public:
    explicit HttpClient(std::shared_ptr<ThreadPool> threadPool)
        : m_threadPool(std::move(threadPool)),
          m_ioContext(m_threadPool->getIoContext()),
          m_sslContext(ssl::context::tlsv12_client),
          m_sslSocket(m_ioContext, m_sslContext),
          m_host(Config::getData()->host),
          m_port(Config::getData()->port)
    {
        auto configData = Config::getData();

        // so dumb. why can't I just use the context directly?
        // i have to use the native handle to load the certificate and key
        // because boost::asio is not sending the client certificate
        SSL *sslHandle = m_sslSocket.native_handle();
        if (!sslHandle) {
            throw std::runtime_error("Failed to retrieve SSL handle!");
        }

        if (SSL_use_certificate_file(sslHandle, configData->keystore.path.c_str(), SSL_FILETYPE_PEM) <= 0) {
            // m_sslContext.use_certificate_chain_file(Config::getData()->keystore.path); // <== does not work
            throw std::runtime_error("Failed to load client certificate from: " + configData->keystore.path);
        }
        else if (SSL_use_PrivateKey_file(sslHandle, configData->key.path.c_str(), SSL_FILETYPE_PEM) <= 0) {
            // m_sslContext.use_private_key_file(Config::getData()->key.path, ssl::context::pem); // <== does not work
            throw std::runtime_error("Failed to load client private key from: " + configData->key.path);
        }
    }

    void connect()
    {
        ip::tcp::resolver resolver(m_ioContext);
        auto              endpoints = resolver.resolve(m_host, std::to_string(m_port));

        LOG(info) << "Resolving and connecting to: " << m_host << ":" << m_port;

        auto handshake_worker = [this](const boost::system::error_code &ec) {
            if (!ec) {
                LOG(info) << "SSL handshake successful!";
            }
            else {
                LOG(error) << "SSL handshake failed: " << ec.message();
                stop();
            }
        };

        auto connect_worker = [this, handshake_worker](const boost::system::error_code &ec,
                                                       const ip::tcp::endpoint         &endpoint) {
            if (!ec) {
                LOG(info) << "Connected to: " << endpoint;
                m_sslSocket.async_handshake(ssl::stream_base::client, handshake_worker);
            }
            else {
                LOG(error) << "Connection failed: " << ec.message();
                stop();
            }
        };

        async_connect(m_sslSocket.lowest_layer(), endpoints, connect_worker);
    }

    void stop()
    {
        if (m_sslSocket.lowest_layer().is_open()) {
            boost::system::error_code ec;
            m_sslSocket.lowest_layer().shutdown(ip::tcp::socket::shutdown_both, ec);
            m_sslSocket.lowest_layer().close();
        }
        m_threadPool->stop();
    }

    virtual ~HttpClient() { stop(); }

  private:
    std::shared_ptr<ThreadPool>  m_threadPool;
    io_context                  &m_ioContext;
    ssl::context                 m_sslContext;
    ssl::stream<ip::tcp::socket> m_sslSocket;
    std::string                  m_host;
    int                          m_port;
};

} // namespace sdk

服务器日志 #

javax.net.ssl|DEBUG|11|nioEventLoopGroup-2-2|2025-01-30 22:52:33.911 UTC|CertificateMessage.java:372|Consuming client Certificate handshake message (
"Certificates": <empty list>
)
javax.net.ssl|ERROR|11|nioEventLoopGroup-2-2|2025-01-30 22:52:33.913 UTC|TransportContext.java:358|Fatal (BAD_CERTIFICATE): Empty client certificate chain (
"throwable" : {

尝试过的无效配置 #

// Configure SSL settings
m_sslContext.set_options(
    ssl::context::default_workarounds | 
    ssl::context::no_sslv2 | 
    ssl::context::no_sslv3 | 
    ssl::context::single_dh_use
);

// Enforce mutual TLS authentication
m_sslContext.set_verify_mode(
    ssl::verify_peer | 
    ssl::verify_fail_if_no_peer_cert);

问题原因分析 #

核心问题在于配置时机错误：

1. ssl::stream<ip::tcp::socket>在构造时，会从关联的ssl::context复制当前的SSL配置（包括证书、密钥、选项等）。
2. 现有代码先创建m_sslSocket，再修改m_sslContext的证书配置，此时已创建的ssl::stream实例不会同步后续的context变更，导致握手时客户端没有携带证书。
3. 通过原生SSL*句柄加载证书是直接修改ssl::stream关联的底层SSL对象，因此配置能立即生效。

正确解决方式 #

1. 调整配置顺序：先完成context配置，再创建ssl::stream #

将证书、密钥加载以及SSL选项配置放在m_sslSocket构造之前，确保stream初始化时就能获取到完整的SSL配置。

2. 验证证书与私钥的匹配性 #

加载私钥后调用check_private_key()验证，避免因密钥不匹配导致的隐性问题。

3. 完整的双向认证配置（若需要） #

如果服务器使用自定义CA签名的证书，还需要加载CA证书到context，确保客户端能验证服务器证书。

修正后的构造函数示例 #

explicit HttpClient(std::shared_ptr<ThreadPool> threadPool)
    : m_threadPool(std::move(threadPool)),
      m_ioContext(m_threadPool->getIoContext()),
      m_sslContext(ssl::context::tlsv12_client),
      m_host(Config::getData()->host),
      m_port(Config::getData()->port)
{
    auto configData = Config::getData();

    // 先配置SSL上下文的所有参数
    // 设置SSL选项
    m_sslContext.set_options(
        ssl::context::default_workarounds | 
        ssl::context::no_sslv2 | 
        ssl::context::no_sslv3 | 
        ssl::context::single_dh_use
    );

    // 设置双向认证模式（客户端验证服务器，服务器要求客户端提供证书）
    m_sslContext.set_verify_mode(ssl::verify_peer);

    // 加载客户端证书链
    boost::system::error_code ec;
    m_sslContext.use_certificate_chain_file(configData->keystore.path, ec);
    if (ec) {
        throw std::runtime_error("Failed to load client certificate chain: " + ec.message());
    }

    // 加载客户端私钥
    m_sslContext.use_private_key_file(configData->key.path, ssl::context::pem, ec);
    if (ec) {
        throw std::runtime_error("Failed to load client private key: " + ec.message());
    }

    // 验证私钥与证书链匹配
    if (!m_sslContext.check_private_key(ec)) {
        throw std::runtime_error("Client private key does not match certificate chain: " + ec.message());
    }

    // 最后创建ssl::stream，此时已获取完整配置
    m_sslSocket = ssl::stream<ip::tcp::socket>(m_ioContext, m_sslContext);
}

额外注意事项 #

• 如果服务器的证书是自定义CA签发的，需要调用m_sslContext.load_verify_file()或m_sslContext.add_verify_path()加载CA证书，否则客户端会因无法验证服务器证书而握手失败。
• 确保证书文件格式正确：use_certificate_chain_file接受PEM格式的完整证书链（从客户端证书到根CA），use_private_key_file接受对应PEM格式的私钥。

内容的提问来源于stack exchange，提问作者tdemay