asio 使用 openssl 示例

#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#define OPENSSL_NO_DEPRECATED
#include <openssl/ssl.h>
#include <wincrypt.h>
#pragma comment(lib, "Crypt32.lib")

#include <iostream>
#include <fstream>
#include <string_view>

void fail(const char* what, const boost::system::error_code& ec) {
    std::cout << what << ": " << ec.message() << std::endl;
}

namespace asio = boost::asio;
using tcp = asio::ip::tcp;

int add_ca(asio::ssl::context& ssl_ctx, boost::system::error_code& ec)
{
    BIO* bio = BIO_new_fp(stdout, BIO_NOCLOSE);
    if (!bio) {
        return -1;
    }

    auto cert_store = CertOpenSystemStore(NULL, L"ROOT");
    if (!cert_store) {
        return -1;
    }

    const unsigned char* encoded_cert = nullptr;
    int i = 0;
    for (PCCERT_CONTEXT cert = nullptr; cert = CertEnumCertificatesInStore(cert_store, cert);) {
        X509* x = d2i_X509(NULL, (const unsigned char**)&cert->pbCertEncoded, cert->cbCertEncoded);
        if (x) {
            BIO* bio_mem = BIO_new(BIO_s_mem());
            PEM_write_bio_X509(bio_mem, x);
            const char* data = nullptr;
            auto len = BIO_get_mem_data(bio_mem, &data);

            ssl_ctx.add_certificate_authority(asio::buffer(data, len), ec);

            BIO_free(bio_mem);

            if (ec) {
                return -1;
            }
        }
        ++i;
    }

    BIO_printf(bio, "cert sum: %d\n", i);

    CertCloseStore(cert_store, CERT_CLOSE_STORE_FORCE_FLAG);

    return 0;
}

int main()
{
    boost::system::error_code ec;

    asio::io_context io_ctx;

    tcp::resolver resolver(io_ctx);
    auto results = resolver.resolve("www.baidu.com", "https", ec);
    if (ec) {
        fail("resolver.resolve", ec);
        return -1;
    }

    asio::ssl::context ssl_ctx(asio::ssl::context::method::sslv23_client);
    add_ca(ssl_ctx, ec);
    if (ec) {
        fail("add_ca", ec);
        return -1;
    }

    asio::ssl::stream<tcp::socket> s(io_ctx, ssl_ctx);
    s.set_verify_mode(asio::ssl::verify_peer | asio::ssl::verify_client_once);
    asio::connect(s.lowest_layer(), results, ec);
    if (ec) {
        fail("asio::connect", ec);
        return -1;
    }

    s.handshake(s.client, ec);
    if (ec) {
        fail("s.handshake", ec);
        return -1;
    }

    const char* req = "GET / HTTP/1.1\r\nHost: www.baidu.com\r\nAccept: text/html\r\n\r\n";
    asio::write(s, asio::buffer(req, std::strlen(req)), ec);
    if (ec) {
        fail("asio::write", ec);
        return -1;
    }

    // Header
    asio::streambuf streambuf;
    std::size_t content_length = 0;
    constexpr std::string_view delimiter = "\r\n";
    constexpr std::string_view header_name = "Content-Length";
    while (true) {
        std::size_t len = asio::read_until(s, streambuf, delimiter, ec);
        if (ec) {
            fail("asio::read_until", ec);
            return -1;
        }

        std::string_view header(asio::buffer_cast<const char*>(streambuf.data()), len - delimiter.size());

        std::cout << header << std::endl;

        if (!header.empty()) {
            if (boost::algorithm::istarts_with(header, header_name)) {
                bool has_optional_space = header[header_name.size() + 1] == ' ';
                std::string_view header_value(header.cbegin() + header_name.size() + 1 + has_optional_space, header.cend());
                content_length = boost::lexical_cast<std::size_t>(header_value);
            }
        }

        streambuf.consume(len);

        if (header.empty()) {
            break;
        }
    }

    // Body
    std::cout << "content_length: " << content_length << std::endl;
    
    std::size_t len = asio::read(s, streambuf.prepare(content_length - streambuf.size()), ec);
    if (ec) {
        fail("asio::read", ec);
        return -1;
    }
    streambuf.commit(len);

    std::string_view body(asio::buffer_cast<const char*>(streambuf.data()), streambuf.size());

    std::system("chcp 65001");
    std::cout << body;

    streambuf.consume(streambuf.size());

    s.shutdown(ec);
    if (ec) {
        fail("s.shutdown", ec);
        return -1;
    }

    s.lowest_layer().shutdown(tcp::socket::shutdown_both, ec);
    if (ec) {
        fail("s.lowest_layer().shutdown", ec);
        return -1;
    }

    return 0;
}