// M10.2a msquic integration smoke test (ADR-0090): loopback TLS 1.3 handshake with the // dev CA pinned through the OpenSSL provider, one unreliable DATAGRAM and one reliable // stream message delivered, and refusal of an untrusted CA and of a wrong server name. // msquic calls back on its own threads; events are recorded under one mutex. #include "evo/network/dev_credentials.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace { void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("quic smoke line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) const QUIC_API_TABLE* api = nullptr; constexpr std::string_view server_name = "dev-region.evolution.test"; std::array alpn_bytes{'e', 'v', 'o', '-', 'm', '1', '0'}; const QUIC_BUFFER alpn{static_cast(alpn_bytes.size()), alpn_bytes.data()}; struct Shared { std::mutex mutex; std::condition_variable changed; bool client_connected{}, datagrams_enabled{}, client_closed{}, server_connected{}; QUIC_STATUS client_failure{QUIC_STATUS_SUCCESS}; std::string datagram, stream; bool stream_finished{}; HQUIC server_config{}; void update(const std::function& change) { { const std::scoped_lock lock{mutex}; change(*this); } changed.notify_all(); } bool wait(const std::function& done) { std::unique_lock lock{mutex}; return changed.wait_for(lock, std::chrono::seconds{10}, [&] { return done(*this); }); } }; QUIC_STATUS QUIC_API server_stream(HQUIC stream, void* context, QUIC_STREAM_EVENT* event) { auto& shared = *static_cast(context); switch (event->Type) { case QUIC_STREAM_EVENT_RECEIVE: shared.update([&](Shared& s) { for (std::uint32_t i = 0; i < event->RECEIVE.BufferCount; ++i) s.stream.append(reinterpret_cast(event->RECEIVE.Buffers[i].Buffer), event->RECEIVE.Buffers[i].Length); }); break; case QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN: shared.update([](Shared& s) { s.stream_finished = true; }); break; case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE: api->StreamClose(stream); break; default: break; } return QUIC_STATUS_SUCCESS; } QUIC_STATUS QUIC_API server_connection(HQUIC connection, void* context, QUIC_CONNECTION_EVENT* event) { auto& shared = *static_cast(context); switch (event->Type) { case QUIC_CONNECTION_EVENT_CONNECTED: shared.update([](Shared& s) { s.server_connected = true; }); break; case QUIC_CONNECTION_EVENT_DATAGRAM_RECEIVED: { const auto* buffer = event->DATAGRAM_RECEIVED.Buffer; shared.update([&](Shared& s) { s.datagram.assign(reinterpret_cast(buffer->Buffer), buffer->Length); }); break; } case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED: api->SetCallbackHandler(event->PEER_STREAM_STARTED.Stream, reinterpret_cast(server_stream), context); break; case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE: api->ConnectionClose(connection); break; default: break; } return QUIC_STATUS_SUCCESS; } QUIC_STATUS QUIC_API listener_callback(HQUIC /*listener*/, void* context, QUIC_LISTENER_EVENT* event) { if (event->Type != QUIC_LISTENER_EVENT_NEW_CONNECTION) return QUIC_STATUS_SUCCESS; auto& shared = *static_cast(context); api->SetCallbackHandler(event->NEW_CONNECTION.Connection, reinterpret_cast(server_connection), context); return api->ConnectionSetConfiguration(event->NEW_CONNECTION.Connection, shared.server_config); } QUIC_STATUS QUIC_API client_stream(HQUIC stream, void* /*context*/, QUIC_STREAM_EVENT* event) { if (event->Type == QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE) api->StreamClose(stream); return QUIC_STATUS_SUCCESS; } QUIC_STATUS QUIC_API client_connection(HQUIC connection, void* context, QUIC_CONNECTION_EVENT* event) { auto& shared = *static_cast(context); switch (event->Type) { case QUIC_CONNECTION_EVENT_CONNECTED: shared.update([](Shared& s) { s.client_connected = true; }); break; case QUIC_CONNECTION_EVENT_DATAGRAM_STATE_CHANGED: shared.update([&](Shared& s) { s.datagrams_enabled = event->DATAGRAM_STATE_CHANGED.SendEnabled != 0; }); break; case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_TRANSPORT: shared.update( [&](Shared& s) { s.client_failure = event->SHUTDOWN_INITIATED_BY_TRANSPORT.Status; }); break; case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE: shared.update([](Shared& s) { s.client_closed = true; }); api->ConnectionClose(connection); break; default: break; } return QUIC_STATUS_SUCCESS; } QUIC_SETTINGS settings() { QUIC_SETTINGS s{}; s.IdleTimeoutMs = 5000; s.IsSet.IdleTimeoutMs = TRUE; s.HandshakeIdleTimeoutMs = 5000; s.IsSet.HandshakeIdleTimeoutMs = TRUE; s.KeepAliveIntervalMs = 1000; s.IsSet.KeepAliveIntervalMs = TRUE; s.DatagramReceiveEnabled = TRUE; s.IsSet.DatagramReceiveEnabled = TRUE; s.PeerBidiStreamCount = 4; s.IsSet.PeerBidiStreamCount = TRUE; return s; } void write_file(const std::filesystem::path& path, const std::string& text) { std::ofstream out{path, std::ios::binary | std::ios::trunc}; out << text; CHECK(out.good()); } struct Outcome { bool connected{}, closed{}; QUIC_STATUS failure{QUIC_STATUS_SUCCESS}; }; // One client attempt against the listener; on success also sends a datagram and a stream. Outcome attempt(HQUIC registration, Shared& shared, std::uint16_t port, const std::filesystem::path& ca, std::string_view name, bool exchange) { auto s = settings(); HQUIC config = nullptr; CHECK(QUIC_SUCCEEDED( api->ConfigurationOpen(registration, &alpn, 1, &s, sizeof(s), nullptr, &config))); const auto ca_text = ca.string(); QUIC_CREDENTIAL_CONFIG credential{}; credential.Type = QUIC_CREDENTIAL_TYPE_NONE; // msquic flag sets are enums whose valid values are bit combinations (the API's // own operator| casts the same way). // OpenSSL's own verifier on every platform (msquic forces it on Linux; on Windows the // default platform verifier ignores CaCertificateFile). It also trusts OpenSSL's // default verify paths; exact pinning is ADR-0090 / 10.2b work. constexpr auto flags = static_cast(QUIC_CREDENTIAL_FLAG_CLIENT) | static_cast(QUIC_CREDENTIAL_FLAG_SET_CA_CERTIFICATE_FILE) | static_cast(QUIC_CREDENTIAL_FLAG_USE_TLS_BUILTIN_CERTIFICATE_VALIDATION); credential.Flags = static_cast( flags); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) credential.CaCertificateFile = ca_text.c_str(); CHECK(QUIC_SUCCEEDED(api->ConfigurationLoadCredential(config, &credential))); shared.update([](Shared& x) { x.client_connected = x.datagrams_enabled = x.client_closed = x.server_connected = x.stream_finished = false; x.client_failure = QUIC_STATUS_SUCCESS; x.datagram.clear(); x.stream.clear(); }); HQUIC connection = nullptr; CHECK( QUIC_SUCCEEDED(api->ConnectionOpen(registration, client_connection, &shared, &connection))); QUIC_ADDR remote{}; CHECK(QuicAddrFromString("127.0.0.1", port, &remote)); CHECK(QUIC_SUCCEEDED( api->SetParam(connection, QUIC_PARAM_CONN_REMOTE_ADDRESS, sizeof(remote), &remote))); const std::string target{name}; CHECK(QUIC_SUCCEEDED( api->ConnectionStart(connection, config, QUIC_ADDRESS_FAMILY_INET, target.c_str(), port))); Outcome out; // Connected, or refused and closed: whichever comes first decides. out.connected = shared.wait([](const Shared& x) { return x.client_connected || x.client_closed; }) && [&] { const std::scoped_lock lock{shared.mutex}; return shared.client_connected; }(); static std::array datagram{'e', 'v', 'o', '-', 'd', 'g', 'r', 'a', 'm'}; static std::array stream_bytes{'e', 'v', 'o', '-', 's', 't', 'r', 'e', 'a', 'm'}; static QUIC_BUFFER datagram_buffer{static_cast(datagram.size()), datagram.data()}; static QUIC_BUFFER stream_buffer{static_cast(stream_bytes.size()), stream_bytes.data()}; if (out.connected && exchange) { CHECK(shared.wait([](const Shared& x) { return x.datagrams_enabled; })); CHECK(QUIC_SUCCEEDED( api->DatagramSend(connection, &datagram_buffer, 1, QUIC_SEND_FLAG_NONE, nullptr))); HQUIC stream = nullptr; CHECK(QUIC_SUCCEEDED(api->StreamOpen(connection, QUIC_STREAM_OPEN_FLAG_NONE, client_stream, &shared, &stream))); CHECK(QUIC_SUCCEEDED(api->StreamStart(stream, QUIC_STREAM_START_FLAG_NONE))); CHECK(QUIC_SUCCEEDED( api->StreamSend(stream, &stream_buffer, 1, QUIC_SEND_FLAG_FIN, nullptr))); CHECK(shared.wait( [](const Shared& x) { return x.stream_finished && x.datagram == "evo-dgram"; })); CHECK(shared.wait( [](const Shared& x) { return x.stream == "evo-stream" && x.server_connected; })); } if (out.connected) api->ConnectionShutdown(connection, QUIC_CONNECTION_SHUTDOWN_FLAG_NONE, 0); // Graceful close. out.closed = shared.wait([](const Shared& x) { return x.client_closed; }); { const std::scoped_lock lock{shared.mutex}; out.failure = shared.client_failure; } api->ConfigurationClose(config); return out; } void smoke() { const auto now = std::chrono::system_clock::now(); const auto good = evo::network::generate_dev_credentials( evo::network::DeploymentEnvironment::dev, server_name, 1, now); const auto other = evo::network::generate_dev_credentials( evo::network::DeploymentEnvironment::dev, server_name, 1, now); CHECK(good && other); const auto dir = std::filesystem::temp_directory_path() / "evo-quic-smoke"; std::filesystem::remove_all(dir); std::filesystem::create_directories(dir); write_file(dir / "ca.pem", good->authority_pem); write_file(dir / "other-ca.pem", other->authority_pem); write_file(dir / "server.pem", good->server_certificate_pem); write_file(dir / "server.key", good->server_key_pem); CHECK(QUIC_SUCCEEDED(MsQuicOpen2(&api))); const QUIC_REGISTRATION_CONFIG registration_config{"evo-quic-smoke", QUIC_EXECUTION_PROFILE_LOW_LATENCY}; HQUIC registration = nullptr; CHECK(QUIC_SUCCEEDED(api->RegistrationOpen(®istration_config, ®istration))); Shared shared; auto s = settings(); CHECK(QUIC_SUCCEEDED(api->ConfigurationOpen(registration, &alpn, 1, &s, sizeof(s), nullptr, &shared.server_config))); const auto key = (dir / "server.key").string(); const auto certificate = (dir / "server.pem").string(); QUIC_CERTIFICATE_FILE file{key.c_str(), certificate.c_str()}; QUIC_CREDENTIAL_CONFIG server_credential{}; server_credential.Type = QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE; server_credential.CertificateFile = &file; CHECK( QUIC_SUCCEEDED(api->ConfigurationLoadCredential(shared.server_config, &server_credential))); HQUIC listener = nullptr; CHECK(QUIC_SUCCEEDED(api->ListenerOpen(registration, listener_callback, &shared, &listener))); QUIC_ADDR local{}; CHECK(QuicAddrFromString("127.0.0.1", 0, &local)); CHECK(QUIC_SUCCEEDED(api->ListenerStart(listener, &alpn, 1, &local))); std::uint32_t size = sizeof(local); CHECK( QUIC_SUCCEEDED(api->GetParam(listener, QUIC_PARAM_LISTENER_LOCAL_ADDRESS, &size, &local))); const std::uint16_t port = QuicAddrGetPort(&local); CHECK(port != 0); const auto ok = attempt(registration, shared, port, dir / "ca.pem", server_name, true); if (!ok.connected || !ok.closed) std::fprintf(stderr, "quic: trusted attempt connected=%d closed=%d status=0x%lx\n", ok.connected ? 1 : 0, ok.closed ? 1 : 0, static_cast(ok.failure)); CHECK(ok.connected && ok.closed); std::printf("quic: handshake, datagram and stream delivered with the pinned dev CA\n"); const auto untrusted = attempt(registration, shared, port, dir / "other-ca.pem", server_name, false); CHECK(!untrusted.connected && untrusted.closed && QUIC_FAILED(untrusted.failure)); std::printf("quic: untrusted CA refused (status 0x%lx)\n", static_cast(untrusted.failure)); const auto wrong_name = attempt(registration, shared, port, dir / "ca.pem", "wrong.evolution.test", false); CHECK(!wrong_name.connected && wrong_name.closed && QUIC_FAILED(wrong_name.failure)); std::printf("quic: wrong server name refused (status 0x%lx)\n", static_cast(wrong_name.failure)); api->ListenerClose(listener); api->ConfigurationClose(shared.server_config); api->RegistrationClose(registration); // Waits for every connection and stream to close. MsQuicClose(api); std::filesystem::remove_all(dir); } } // namespace int main() try { smoke(); std::puts("quic smoke tests passed"); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; }