TLS (std/tls/) #

#include <std/tls/tls.h>

#include <std/tls/tls.h>
#include <std/http/http.h>       // http_resolve_host
#include <std/sched/io_nb.h>     // tcp_connect_timeout
#include <std/str.h>
#include <std/io.h>

int main() {
    unsigned int addr = 0U;
    if (!std::http_resolve_host("example.com", &addr)) return 1;
    int fd = std::tcp_connect_timeout(addr, 443, 5000);
    if (fd < 0) return 1;
    std::sock_set_io_timeout(fd, 10000);              // 핸드셰이크와 모든 읽기의 제한

    struct TlsConfig cfg = std::TlsConfig::new();     // 시스템 루트, 호스트 이름 검사
    cfg.set_alpn("http/1.1");
    struct Result<TlsStream, TlsError> r = std::TlsStream::connect(fd, "example.com", &cfg);
    cfg.free();
    match (r.get_err()) {
        case some(e): { std::println(e.message); r.drop(); return 1; }   // fd는 여전히 호출자가 닫습니다
        case null: { }
    }
    struct TlsStream t = r.unwrap();                  // r을 소비합니다
    std::print(t.backend_name()); std::print(" "); std::println(t.cipher());

    const &char req = "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
    unsafe { t.write(((const unsigned char*)req)[0..std::str_len(req)]); }
    unsigned char buf[4096];
    long long n = t.read(buf[0..4096UL]);            // 읽은 수, 서버가 닫으면 0, 오류면 -1
    t.close();                                        // close_notify 후 소켓을 닫습니다
    return n > 0LL ? 0 : 1;
}

struct TlsServerConfig sc = std::TlsServerConfig::new();
sc.load_files("cert.pem", "key.pem");     // 체인(리프 먼저)과 키: PKCS#8, RSA, EC PEM
sc.set_alpn("h2,http/1.1");               // 서버의 선호 순서
struct Result<TlsAcceptor, TlsError> ar = std::TlsAcceptor::new(&sc);
sc.free();                                // acceptor는 필요한 것을 보관합니다
struct TlsAcceptor acc = ar.unwrap();     // (먼저 ar.ok()를 확인하세요: 오류이면 unwrap()은 패닉합니다)

int fd = std::tcp_accept_nb(listen_fd);   // 여기서부터 블로킹: fd_set_blocking(fd)
struct Result<TlsStream, TlsError> r = acc.accept(fd);   // 핸드셰이크
if (r.ok()) {
    struct TlsStream t = r.unwrap();
    // t.read / t.write ..., t.alpn(), t.peer_certificate(&cert) ...
    t.close();
} else {
    r.drop();                             // TlsError를 해제합니다
}
acc.free();                               // 시작한 스트림들의 핸드셰이크가 끝난 뒤에

struct TlsConfig {
    int           verify_peer;       // 1: 체인과 날짜 검사(기본값)
    int           verify_hostname;   // 1: 이름 검사(기본값)
    int           use_system_roots;  // 1: OS의 루트를 신뢰(기본값)
    struct String ca_pem;            // 추가로 신뢰할 루트, PEM
    struct String ca_file;           // 추가로 신뢰할 루트의 PEM 번들 파일
    struct String server_name;       // SNI + 검증할 이름; 비어 있으면 connect()의 host
    struct String alpn;              // 제안할 프로토콜, 쉼표로 구분("h2,http/1.1")
    int           min_version;       // TLS_VERSION_1_2(기본값) 또는 TLS_VERSION_1_3
    int           max_version;       // TLS_VERSION_1_3(기본값)
    int           backend;           // TLS_BACKEND_AUTO(기본값)
    struct String cert_pem;          // 서버가 요청할 때 보낼 클라이언트 인증서 체인
    struct String key_pem;           // 그 개인 키

    static struct TlsConfig new();
    void set_ca_pem(const &char pem);
    void set_ca_file(const &char path);
    void set_server_name(const &char name);
    void set_alpn(const &char protocols);
    void set_client_cert(const &char cert_pem, const &char key_pem);
    void insecure_skip_verify();     // 검증 끔: 자체 서명 테스트 서버에만
    struct TlsConfig clone() const;
    void free() consume;
};

struct TlsServerConfig {
    struct String cert_pem;          // 리프 먼저, 그다음 중간 인증서
    struct String key_pem;           // PKCS#8, RSA, EC PEM
    struct String alpn;              // 서버가 말하는 프로토콜, 선호 순
    int           min_version;       // TLS_VERSION_1_2(기본값)
    int           max_version;       // TLS_VERSION_1_3(기본값)
    int           backend;           // TLS_BACKEND_AUTO(기본값)
    int           verify_client;     // 0 없음(기본값), 1 인증서 요청, 2 인증서 필수
    struct String client_ca_pem;     // 클라이언트 인증서의 루트

    static struct TlsServerConfig new();
    int  load_files(const &char cert_path, const &char key_path);   // 하나라도 못 읽으면 0
    void set_alpn(const &char protocols);
    void free() consume;
};

struct TlsStream {
    // 클라이언트, 블로킹: 핸드셰이크 전체. 실패해도 fd는 열린 채로 남습니다.
    static struct Result<TlsStream, TlsError> connect(int fd, const &char host, const ?&TlsConfig cfg);
    // 클라이언트, 논블로킹: 준비만 하고 handshake()로 진행합니다.
    static struct Result<TlsStream, TlsError> client(int fd, const &char host, const ?&TlsConfig cfg);

    int       handshake();     // 0 완료, TLS_WANT_READ / TLS_WANT_WRITE, -1 실패
    long long read([]unsigned char buf);         // 읽은 수, 0 = 상대가 닫음, -1, TLS_WANT_*
    long long write([]const unsigned char buf);  // 쓴 수, -1, TLS_WANT_*
    int       shutdown();      // close_notify 보내기(한 번)
    int       close() consume; // shutdown, 해제, 소켓 닫기
    void      release() consume;       // TLS 상태만 해제하고 fd는 열어 둠

    int  is_open() const;
    int  version() const;               // TLS_VERSION_1_2 / TLS_VERSION_1_3
    const &char cipher() const;         // IANA 이름: "TLS_AES_128_GCM_SHA256"
    const &char alpn() const;           // 합의된 프로토콜, 없으면 ""
    const &char backend_name() const;   // "openssl", "schannel", "securetransport", "safec"
    int  peer_certificate(&X509Cert out) const;   // 상대 리프 인증서 요약
    const &TlsError last_error() const;
};

struct TlsAcceptor {
    static struct Result<TlsAcceptor, TlsError> new(const &TlsServerConfig cfg);
    struct Result<TlsStream, TlsError> accept(int fd);   // 블로킹 핸드셰이크
    struct Result<TlsStream, TlsError> start(int fd);    // 논블로킹: handshake()로 진행
    void free() consume;
};