diff --git a/CMakeLists.txt b/CMakeLists.txt index eef81f0..006bebb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -46,6 +46,12 @@ set(EVO_SANITIZER "none" CACHE STRING "none, address (ASan/UBSan), or thread") set_property(CACHE EVO_SANITIZER PROPERTY STRINGS none address thread) include(cmake/ProjectOptions.cmake) +if(EVO_BUILD_CLIENT OR EVO_BUILD_POSTGRES) + add_library(evo_json STATIC src/serialization/json.cpp) + target_include_directories(evo_json PUBLIC "${PROJECT_SOURCE_DIR}/include") + evo_owned_target(evo_json) +endif() + set(evo_simulation_sources src/simulation/world.cpp src/simulation/snapshot.cpp src/simulation/scheduler.cpp src/simulation/spatial.cpp) add_library(evo_simulation STATIC ${evo_simulation_sources}) add_library(evo::simulation ALIAS evo_simulation) @@ -277,9 +283,9 @@ if(EVO_BUILD_POSTGRES) target_link_libraries(evo_control_ledger_postgres PUBLIC evo::postgres evo_network_protocol) evo_owned_target(evo_control_ledger_postgres) # ADR-0131 Keycloak grant broker (schema v39). - add_library(evo_grant_broker STATIC src/server/broker/json.cpp + add_library(evo_grant_broker STATIC src/server/broker/access_token.cpp src/server/broker/grant_broker.cpp) - target_link_libraries(evo_grant_broker PUBLIC evo::region_host evo_network_tls + target_link_libraries(evo_grant_broker PUBLIC evo_json evo::region_host evo_network_tls PRIVATE OpenSSL::Crypto) evo_owned_target(evo_grant_broker) add_executable(evo-grant-broker apps/evo-grant-broker/main.cpp) diff --git a/CMakePresets.json b/CMakePresets.json index a638ebd..15377c9 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -21,12 +21,12 @@ {"name": "analysis", "configurePreset": "analysis"}, {"name": "asan", "configurePreset": "asan"}, {"name": "tsan", "configurePreset": "tsan"}, - {"name": "client", "configurePreset": "client", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests"]}, + {"name": "client", "configurePreset": "client", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-client-auth-tests"]}, {"name": "client-probe", "configurePreset": "client-probe", "targets": ["evo-client-probe"]}, {"name": "network", "configurePreset": "network", "targets": ["evo-client-state-tests", "evo-network-tests", "evo-cellular-intent-protocol-tests", "evo-cellular-intent-admission-tests", "evo-session-fuzz-smoke", "evo-dev-session"]}, {"name": "quic", "configurePreset": "quic", "targets": ["evo-quic-smoke-tests", "evo-quic-transport-tests", "evo-quic-session-tests", "evo-quic-hol-measure", "evo-session-probe", "evo-load", "evo-network-tests", "evo-cellular-intent-protocol-tests", "evo-cellular-intent-admission-tests", "evo-session-fuzz-smoke"]}, - {"name": "client-network", "configurePreset": "client-network", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-cellular-intent-protocol-tests", "evo-cellular-intent-admission-tests", "evo-session-fuzz-smoke", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-motion-trace", "evo-session-probe"]}, - {"name": "client-package", "configurePreset": "client-package", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-cellular-intent-protocol-tests", "evo-cellular-intent-admission-tests", "evo-session-fuzz-smoke", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-motion-trace"]} + {"name": "client-network", "configurePreset": "client-network", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-client-auth-tests", "evo-network-tests", "evo-cellular-intent-protocol-tests", "evo-cellular-intent-admission-tests", "evo-session-fuzz-smoke", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-motion-trace", "evo-session-probe"]}, + {"name": "client-package", "configurePreset": "client-package", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-client-auth-tests", "evo-network-tests", "evo-cellular-intent-protocol-tests", "evo-cellular-intent-admission-tests", "evo-session-fuzz-smoke", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-motion-trace"]} ], "testPresets": [ {"name": "debug", "configurePreset": "debug", "output": {"outputOnFailure": true}}, diff --git a/apps/evo-client/main.cpp b/apps/evo-client/main.cpp index 62e8dbf..555ee98 100644 --- a/apps/evo-client/main.cpp +++ b/apps/evo-client/main.cpp @@ -1,6 +1,7 @@ #include "cellular_scene.hpp" #include "controls_flow.hpp" #include "evo/client/application.hpp" +#include "evo/client/auth.hpp" #include "evo/client/launcher.hpp" #include "evo/client/selection.hpp" #include "evo/client/session_host.hpp" @@ -19,6 +20,7 @@ #include #include #include +#include #include #include #include @@ -229,6 +231,12 @@ std::uint64_t milliseconds(std::chrono::steady_clock::time_point t) { return static_cast( std::chrono::duration_cast(t.time_since_epoch()).count()); } +// Wall-clock seconds: grant expiry is UTC (the session compares the server's welcome). +std::uint64_t utc_seconds() { + return static_cast(std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count()); +} } // namespace int main(int argc, char** argv) try { @@ -351,6 +359,36 @@ int main(int argc, char** argv) try { return host.connect(std::move(opened)); } }; + // ADR-0131: a broker grant names its region route; only the region CA comes from the + // form. The grant stays in memory and the session asks for the next one itself. + const auto grant_material = [&](const evo::client::AuthGrant& grant) { + auto f = buffers.form(); + f.endpoint = grant.endpoint; + f.server_name = grant.server_name; + return evo::client::load_connect(f, std::span{&grant.bytes, 1}); + }; + const auto connect_signed_in = [&](const evo::client::AuthGrant& grant) { + form_error.reset(); + if constexpr (!evo::client_app::remote_available) { + form_error = evo::client::LaunchError::no_session; + return false; + } else { + const auto material = grant_material(grant); + if (!material) { + form_error = material.error(); + return false; + } + cellular_trial = true; // The DEV broker world is the cellular trial (ADR-0131). + auto opened = evo::client_app::RemoteSession::open(*material, cellular_trial); + if (!opened) { + form_error = evo::client::LaunchError::endpoint; + return false; + } + opened->manage_grants(); + cellular_framed = false; + return host.connect(std::move(opened)); + } + }; const auto enter_fixture = [&] { if (!authority) { authority = make_authority(); @@ -419,6 +457,10 @@ int main(int argc, char** argv) try { return &remote->organisms(); return nullptr; }; + // ADR-0131 browser sign-in (Windows); elsewhere the panel offers manual grants only. + evo::client::AuthClient auth{evo::client::native_auth_platform()}; + bool auth_connect = false; // Connect when the requested grant arrives. + auto grant_requested = std::chrono::steady_clock::time_point{}; int drawn_organisms = -1; evo::client_app::PanelActions actions; (*app)->set_overlay([&] { @@ -428,6 +470,7 @@ int main(int argc, char** argv) try { view.form_error = form_error; view.remote_available = evo::client_app::remote_available; view.cellular_trial = cellular_trial; + view.auth = auth.status(); view.environment = shown_environment(); view.organisms = shown_organisms(); view.selection = &selection; @@ -512,6 +555,48 @@ int main(int argc, char** argv) try { remote->set_cellular_feed_target(cellular_trial ? cellular_feed_target : std::nullopt); remote->set_cellular_controls(buffers.cellular_controls); } + // ADR-0131 sign-in. One request at a time; grants arrive on a later frame. + if (actions.sign_in && auth.sign_in()) { + auth_connect = true; + grant_requested = now; + } + if (actions.auth_connect && auth.request_grant()) { + auth_connect = true; + grant_requested = now; + } + if (actions.cancel_sign_in) { + auth.cancel(); + auth_connect = false; + } + if (actions.sign_out) { + host.cancel(); // Logout revokes every grant; do not keep a session behind it. + cellular_feed_target.reset(); + selection.clear(); + auth_connect = false; + static_cast(auth.sign_out()); + } + if (auto grant = auth.take_grant()) { + if (auth_connect) { + auth_connect = false; + if (connect_signed_in(*grant)) + selection.clear(); + } else if (auto* remote = host.session()) { + // Refresh or reconnect material for the live session (same account). + if (const auto material = grant_material(*grant)) + static_cast(remote->supply_grant(*material)); + } + grant->bytes.fill(0); + } + if (const auto status = auth.status(); !status.busy && auth_connect && !status.signed_in) + auth_connect = false; // Sign-in failed or was cancelled; the panel shows why. + // About a minute before expiry, or after a lost connection; never for a session the + // launcher has given up on (superseded by another client, cancelled). + const bool live = launcher.phase() == evo::client::LaunchPhase::connecting || + launcher.phase() == evo::client::LaunchPhase::connected; + if (const auto* remote = host.session(); + live && remote && remote->needs_grant(utc_seconds()) && + now - grant_requested >= std::chrono::seconds{5} && auth.request_grant()) + grant_requested = now; controls.step(actions, **app, ui); actions = {}; // The launcher and modal dialogs own input: no world movement or selection. diff --git a/apps/evo-client/panels.cpp b/apps/evo-client/panels.cpp index 271516f..4f9fd30 100644 --- a/apps/evo-client/panels.cpp +++ b/apps/evo-client/panels.cpp @@ -121,18 +121,48 @@ void launcher(const PanelView& v, FormBuffers& form, PanelActions& a) { "server, not an ecosystem, not authoritative."); ImGui::Separator(); ImGui::TextUnformatted("Connect to a dev region"); - ImGui::BeginDisabled(!v.remote_available || phase == LaunchPhase::connecting); - ImGui::InputText("Endpoint (host:port)", form.endpoint.data(), form.endpoint.size()); - ImGui::InputText("Server name", form.server_name.data(), form.server_name.size()); - ImGui::InputText("Dev CA file", form.authority.data(), form.authority.size()); - ImGui::InputText("Grant bundle file", form.grants.data(), form.grants.size()); - bool cellular_trial = v.cellular_trial; - if (ImGui::Checkbox("Cellular play (v10)", &cellular_trial)) - a.cellular_trial = cellular_trial; - const bool start = phase == LaunchPhase::choosing && ImGui::Button("Connect", {px(160), 0}); + ImGui::InputText("Region CA file", form.authority.data(), form.authority.size()); + ImGui::BeginDisabled(!v.remote_available || !v.auth.supported || v.auth.busy || + phase == LaunchPhase::connecting); + if (ImGui::Button(v.auth.signed_in ? "Play in DEV" : "Sign in / Register", {-1, px(34)})) { + a.sign_in = !v.auth.signed_in; + a.auth_connect = v.auth.signed_in; + } ImGui::EndDisabled(); - if (start) - a.connect = true; + if (v.auth.busy) { + ImGui::TextWrapped( + "%s", + v.auth.phase == client::AuthPhase::signing_out ? "Signing out..." + : v.auth.phase == client::AuthPhase::renewing + ? "Renewing your connection..." + : "Complete sign-in in your browser, then return here. Connecting is automatic."); + if (v.auth.phase == client::AuthPhase::signing_in && ImGui::Button("Cancel sign-in")) + a.cancel_sign_in = true; + } else if (v.auth.signed_in && ImGui::SmallButton("Sign out")) + a.sign_out = true; + if (v.auth.error) { + ImGui::PushStyleColor(ImGuiCol_Text, amber); + const auto text = client::auth_error_text(*v.auth.error); + ImGui::PushTextWrapPos(0.0F); + ImGui::TextUnformatted(text.data(), text.data() + text.size()); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + } + ImGui::TextWrapped( + "Your password stays in the system browser. Windows Credential Manager stores your login."); + if (ImGui::CollapsingHeader("Manual connection (developer grants)")) { + ImGui::BeginDisabled(!v.remote_available || phase == LaunchPhase::connecting); + ImGui::InputText("Endpoint (host:port)", form.endpoint.data(), form.endpoint.size()); + ImGui::InputText("Server name", form.server_name.data(), form.server_name.size()); + ImGui::InputText("Grant bundle file", form.grants.data(), form.grants.size()); + bool cellular_trial = v.cellular_trial; + if (ImGui::Checkbox("Cellular play (v10)", &cellular_trial)) + a.cellular_trial = cellular_trial; + const bool start = phase == LaunchPhase::choosing && ImGui::Button("Connect", {px(160), 0}); + ImGui::EndDisabled(); + if (start) + a.connect = true; + } if (!v.remote_available) ImGui::TextColored(amber, "Remote mode needs a build with EVO_BUILD_NETWORK."); if (v.form_error) @@ -150,7 +180,8 @@ void launcher(const PanelView& v, FormBuffers& form, PanelActions& a) { if (ImGui::Button("Cancel", {px(120), 0})) a.cancel = true; } - ImGui::TextDisabled("Files are read when you connect; nothing is saved."); + ImGui::TextWrapped("The region CA is still required to verify the game server. Manual grant " + "files are only read when connecting."); ImGui::End(); } @@ -168,6 +199,13 @@ void banner(const PanelView& v, PanelActions& a) { ImGui::SameLine(); if (ImGui::SmallButton("Controls")) a.open_controls = true; + if (v.auth.signed_in) { + ImGui::SameLine(); + ImGui::BeginDisabled(v.auth.busy); + if (ImGui::SmallButton("Sign out")) + a.sign_out = true; + ImGui::EndDisabled(); + } } else { ImGui::TextColored(v.remote && v.remote->phase == "connected" ? green : amber, "DEV REGION - %s%s", v.remote ? v.remote->phase.c_str() : "?", diff --git a/apps/evo-client/panels.hpp b/apps/evo-client/panels.hpp index 6d2ec9d..25fe774 100644 --- a/apps/evo-client/panels.hpp +++ b/apps/evo-client/panels.hpp @@ -2,6 +2,7 @@ // M9.8c engineering panels (ADR-0084). Drawn inside Application's overlay callback; // they read presentation copies and report what the user asked for. Only this file // pair and the platform adapter use the toolkit. +#include "evo/client/auth.hpp" #include "evo/client/bindings.hpp" #include "evo/client/environment_view.hpp" #include "evo/client/launcher.hpp" @@ -41,6 +42,7 @@ struct PanelView { std::optional form_error; bool remote_available{}; bool cellular_trial{}; + client::AuthStatus auth; const client::EnvironmentLayer* environment{}; const client::OrganismLayer* organisms{}; const client::Selection* selection{}; @@ -59,6 +61,7 @@ struct PanelView { }; struct PanelActions { bool fixture{}, connect{}, cancel{}, retry{}, back{}, ask_disconnect{}; + bool sign_in{}, sign_out{}, auth_connect{}, cancel_sign_in{}; std::optional dismiss_notice, confirm_dialog, cancel_dialog; bool open_controls{}, apply_controls{}, reset_controls{}, close_controls{}, cancel_capture{}; std::optional capture_key; diff --git a/apps/evo-client/remote_session.hpp b/apps/evo-client/remote_session.hpp index 30ccf5c..d59495c 100644 --- a/apps/evo-client/remote_session.hpp +++ b/apps/evo-client/remote_session.hpp @@ -174,6 +174,8 @@ class RemoteSession { session.transport_.authority_pem = m.authority_pem; session.transport_.authority_pem_file = m.authority_path; session.grants_ = m.grants; + std::copy_n(m.grants.front().begin() + 32, session.account_.size(), + session.account_.begin()); session.cellular_trial_ = cellular_trial; session.cellular_play_.initialize(static_cast( std::chrono::system_clock::now().time_since_epoch().count())); @@ -187,6 +189,47 @@ class RemoteSession { RemoteSession& operator=(RemoteSession&&) noexcept = default; RemoteSession(const RemoteSession&) = delete; RemoteSession& operator=(const RemoteSession&) = delete; + void manage_grants() { + managed_grants_ = true; + } + [[nodiscard]] bool needs_grant(std::uint64_t utc_now) const { + if (!managed_grants_) + return false; + if (!client_) + return exhausted_ || std::ranges::all_of(used_, [](bool used) { return used; }); + const auto& welcome = client_->welcome(); + return client_->state() == client::RegionSessionState::established && welcome && + std::max(welcome->expires_at, refreshed_until_) <= utc_now + 60 && !refresh_waiting_; + } + // Grants are supplied by the authenticated broker, never written to a bundle. + [[nodiscard]] bool supply_grant(const client::ConnectMaterial& material) { + if (!managed_grants_ || material.grants.size() != 1 || + material.authority_pem != transport_.authority_pem) + return false; + const auto& grant = material.grants.front(); + const auto serial = grant_serial(grant); + if (serial < newest_serial_ || serial == UINT64_MAX || + !std::equal(account_.begin(), account_.end(), grant.begin() + 32)) + return false; + const auto region = grant_region(grant); + if (client_ && client_->state() == client::RegionSessionState::established) { + if (region != region_ || !client_->refresh(grant)) + return false; + newest_serial_ = serial + 1; + refresh_waiting_ = true; + refresh_sent_at_ = Clock::now(); + return true; + } + if (!learn_route({region, + material.endpoint.host + ":" + std::to_string(material.endpoint.port), + material.server_name})) + return false; + grants_.assign(1, grant); + used_.assign(1, false); + target_region_ = region; + exhausted_ = false; + return true; + } ~RemoteSession() { if (client_) client_->close(); // Close{client_closed}; unresolved intentions stay unknown. @@ -350,6 +393,13 @@ class RemoteSession { return; auto& c = *client_; c.poll(now); + if (const auto refreshed = c.take_refresh_result()) { + refresh_waiting_ = false; + if (refreshed->status == 0) // Accepted: the session now runs to the new expiry. + refreshed_until_ = std::max(refreshed_until_, refreshed->expires_at); + } else if (refresh_waiting_ && now - refresh_sent_at_ >= std::chrono::seconds{5}) { + refresh_waiting_ = false; + } if (c.state() == client::RegionSessionState::closed) { end(now, ui, launcher); return; @@ -472,9 +522,12 @@ class RemoteSession { if (pick == grants_.size()) { if (!exhausted_) { exhausted_ = true; - launcher.observe(client::ConnectSignal::exhausted); - std::printf("session grants for region %llu exhausted; issue a new bundle\n", - static_cast(target_region_)); + if (!managed_grants_) { + launcher.observe(client::ConnectSignal::exhausted); + std::printf( + "session grants for region %llu exhausted; issue a new bundle\n", + static_cast(target_region_)); + } } return false; } @@ -491,6 +544,8 @@ class RemoteSession { } client_ = std::move(*made); established_ = false; + refreshed_until_ = 0; // A new session starts from its own welcome. + refresh_waiting_ = false; return true; } void pause(Clock::time_point now) { @@ -860,6 +915,10 @@ class RemoteSession { network::quic::ClientConfig transport_; std::vector grants_; std::vector used_; + std::array account_{}; + bool managed_grants_{}, refresh_waiting_{}; + std::uint64_t refreshed_until_{}; // Expiry from the last accepted SessionRefresh. + Clock::time_point refresh_sent_at_{}; std::map routes_; // Region -> how to dial it. std::uint64_t target_region_{}, region_{}, handoffs_{}, newest_serial_{}; std::optional ticket_; // A handoff ticket for the next connection. @@ -903,6 +962,13 @@ class RemoteSession { inline constexpr bool remote_available = false; class RemoteSession { public: + void manage_grants() {} + [[nodiscard]] bool needs_grant(std::uint64_t) const { + return false; + } + [[nodiscard]] bool supply_grant(const client::ConnectMaterial&) { + return false; + } static std::optional open(const client::ConnectMaterial&, bool = false) { return std::nullopt; } diff --git a/cmake/ClientProbe.cmake b/cmake/ClientProbe.cmake index ee54274..fce7f89 100644 --- a/cmake/ClientProbe.cmake +++ b/cmake/ClientProbe.cmake @@ -69,6 +69,16 @@ if(EVO_BUILD_CLIENT) add_executable(evo-client apps/evo-client/main.cpp apps/evo-client/panels.cpp) target_link_libraries(evo-client PRIVATE evo_client_platform evo_client_ui evo_imgui) target_compile_definitions(evo-client PRIVATE EVO_BUILD_IDENTITY="${EVO_BUILD_IDENTITY}") + find_package(Threads REQUIRED) + add_library(evo_client_auth STATIC src/client/auth/protocol.cpp src/client/auth/client.cpp) + target_link_libraries(evo_client_auth PUBLIC evo_client_ui PRIVATE evo_json Threads::Threads) + if(WIN32) + target_sources(evo_client_auth PRIVATE src/client/auth/windows.cpp) + target_compile_definitions(evo_client_auth PRIVATE WIN32_LEAN_AND_MEAN NOMINMAX) + target_link_libraries(evo_client_auth PRIVATE winhttp bcrypt advapi32 shell32 ws2_32) + endif() + evo_owned_target(evo_client_auth) + target_link_libraries(evo-client PRIVATE evo_client_auth) if(EVO_BUILD_QUIC) # M10.5c remote dev session mode over M10 QUIC sessions (ADR-0093); replaces the M9.7 # TCP session (ADR-0083), whose dev route is gone (ADR-0087). @@ -133,8 +143,15 @@ if(EVO_BUILD_CLIENT) add_executable(evo-client-panel-tests tests/client_panels.cpp apps/evo-client/panels.cpp) target_include_directories(evo-client-panel-tests PRIVATE "${PROJECT_SOURCE_DIR}/apps/evo-client") target_link_libraries(evo-client-panel-tests PRIVATE evo_client_platform evo_client_ui SDL3::SDL3 evo_imgui) + target_link_libraries(evo-client-panel-tests PRIVATE evo_client_auth) evo_owned_target(evo-client-panel-tests) evo_client_runtime(evo-client-panel-tests) + # ADR-0131 sign-in: callback, token and grant replies, worker against a scripted platform. + add_executable(evo-client-auth-tests tests/client_auth.cpp) + target_link_libraries(evo-client-auth-tests PRIVATE evo_client_auth) + evo_owned_target(evo-client-auth-tests) + add_test(NAME client-auth COMMAND evo-client-auth-tests) + set_tests_properties(client-auth PROPERTIES TIMEOUT 60 LABELS "client") add_test(NAME client-panels COMMAND evo-client-panel-tests) add_test(NAME client-lifecycle COMMAND evo-client-lifecycle-tests) add_test(NAME client-smoke COMMAND evo-client --renderer software --frames 3) diff --git a/deploy/docker/Dockerfile b/deploy/docker/Dockerfile index d69aceb..f39e51f 100644 --- a/deploy/docker/Dockerfile +++ b/deploy/docker/Dockerfile @@ -43,13 +43,13 @@ RUN cmake -P tools/prepare-sdl3.cmake \ && cmake -P tools/prepare-imgui.cmake \ && cmake --preset client-probe -DCMAKE_CXX_COMPILER=clang++-19 -DCMAKE_C_COMPILER=clang-19 \ -DEVO_BUILD_CLIENT=ON -DEVO_BUILD_UI_PROBE=ON -DEVO_ENABLE_TIDY=ON -DSDL_X11=ON -DSDL_WAYLAND=OFF \ - && cmake --build build/client-probe --target evo-client-state-tests evo-ui-probe evo-client-probe evo-client evo-client-lifecycle-tests evo-client-environment-tests evo-client-organism-tests evo-client-ui-model-tests evo-client-panel-tests evo-client-bindings-tests --parallel 2 \ + && cmake --build build/client-probe --target evo-client-state-tests evo-ui-probe evo-client-probe evo-client evo-client-lifecycle-tests evo-client-environment-tests evo-client-organism-tests evo-client-ui-model-tests evo-client-panel-tests evo-client-bindings-tests evo-client-auth-tests --parallel 2 \ && ctest --preset client-probe --no-tests=error \ && xvfb-run -a env SDL_VIDEO_DRIVER=x11 ./build/client-probe/evo-client-probe --renderer software \ && for cycle in 1 2 3; do xvfb-run -a env SDL_VIDEO_DRIVER=x11 ./build/client-probe/evo-ui-probe --renderer software --cycles 1; done \ && xvfb-run -a env SDL_VIDEO_DRIVER=x11 ./build/client-probe/evo-client-lifecycle-tests \ && cmake --preset client-probe -DEVO_BUILD_CLIENT=ON -DEVO_SANITIZER=address -DEVO_ENABLE_TIDY=OFF \ - && cmake --build build/client-probe --target evo-client-state-tests evo-ui-probe evo-client evo-client-lifecycle-tests evo-client-environment-tests evo-client-organism-tests evo-client-ui-model-tests evo-client-panel-tests evo-client-bindings-tests --parallel 2 \ + && cmake --build build/client-probe --target evo-client-state-tests evo-ui-probe evo-client evo-client-lifecycle-tests evo-client-environment-tests evo-client-organism-tests evo-client-ui-model-tests evo-client-panel-tests evo-client-bindings-tests evo-client-auth-tests --parallel 2 \ && ctest --preset client-probe --no-tests=error \ && for cycle in 1 2 3; do xvfb-run -a env SDL_VIDEO_DRIVER=x11 ./build/client-probe/evo-ui-probe --renderer software --cycles 1; done \ && xvfb-run -a env SDL_VIDEO_DRIVER=x11 ./build/client-probe/evo-client-lifecycle-tests diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index cc47dd4..e9af436 100644 --- a/deploy/kubernetes/region/dev-session-route/listener.yaml +++ b/deploy/kubernetes/region/dev-session-route/listener.yaml @@ -12,7 +12,7 @@ spec: env: - {name: REGION_SESSION, value: "dev"} - {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"} - - {name: REGION_SESSION_WINDOW, value: "dev-20261015T181504-60231:1792098904"} + - {name: REGION_SESSION_WINDOW, value: "dev-20261015T193133-96611:1792103493"} - {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"} ports: # QUIC (ADR-0090): UDP only; nothing listens on TCP 7400. diff --git a/docs/adr/0131-keycloak-login-and-grant-broker.md b/docs/adr/0131-keycloak-login-and-grant-broker.md index 05de1e5..dfb338f 100644 --- a/docs/adr/0131-keycloak-login-and-grant-broker.md +++ b/docs/adr/0131-keycloak-login-and-grant-broker.md @@ -73,6 +73,30 @@ never be minted on a client. 4. On logout: `POST /logout`, then revoke the refresh token at Keycloak's revocation endpoint. +### Client implementation (Windows engineering client) + +- `evo_client_auth`: the protocol parsers (`protocol.cpp`), one worker thread + (`AuthClient`, `client.cpp`) and the Windows platform (`windows.cpp`). On other + systems sign-in is unavailable, and the manual grant-bundle path remains. +- Sign-in opens the system browser with PKCE S256 and a random state. A loopback + listener on `127.0.0.1:47600` accepts exactly one `/callback` with that state and an + `iss` of the realm, if present. The password never reaches the client. +- The refresh token is stored only in Windows Credential Manager + (`AeternalisEvolution/DEV/refresh-token/v1`). Rotation removes the stored token + before it is sent, so a lost reply ends the login instead of replaying a consumed + token. Access tokens and grants stay in memory and are zeroed when dropped. +- A grant reply is accepted only if its JSON agrees with the grant record: marker, + version, dev environment, account, region, expiry (at most 15 minutes ahead) and a + nonzero serial. The region still verifies the signature. +- The region CA file is still required from the launcher. Endpoint and TLS name come + from the broker's route. +- The session asks for a new grant about 60 s before its expiry, extended by each + accepted `SessionRefresh`, and after a lost connection. It never asks for a session + that was superseded or cancelled. Requests are at least 5 s apart. +- Sign-out closes the session, then calls `/logout` (broker revocation) and Keycloak + revocation, and clears the stored token. If revocation cannot be confirmed, the + client says so: issued grants may live until they expire. + ### Deployment (DEV) - `deploy/kubernetes/grant-broker-dev`, a component of `region/dev` so it runs the diff --git a/docs/engineering/CLIENT.md b/docs/engineering/CLIENT.md index b5f5b45..d9ef3fb 100644 --- a/docs/engineering/CLIENT.md +++ b/docs/engineering/CLIENT.md @@ -27,6 +27,14 @@ watermark, grants left, the snapshot, interest and snapshot bytes, and the last intentions with their outcome (sent, admitted, rejected, simulated, unknown; M10.5c). That list is the record; short notifications expire and can be dismissed. +**Sign in / Register** (Windows, ADR-0131) opens the system browser for Keycloak. +After sign-in the client fetches a 10-minute grant from `grants.aeternalisgames.com` +and connects to the cellular DEV region. It renews the grant before expiry and after a +lost connection. **Play in DEV** reconnects while signed in. **Sign out** closes the +session and revokes the login. Only the region CA file is still read from the form. +The manual endpoint and grant-bundle fields stay under "Manual connection +(developer grants)". + ## Build and run ### Cellular v10 diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 60b48f5..390c898 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -7610,3 +7610,43 @@ nursery stall is reproduced locally, not confirmed as this player's precise live refusal. This gate changes neither nursery resources nor simulation/replay rules. No deployment or World0 operation ran. Authentication is a following gate under ADR-0131. The unrelated deployment edit and untracked files were preserved. + +## 2026-10-15 — ADR-0131 client sign-in (CI pending) + +The Windows engineering client signs in with Keycloak in the system browser (PKCE S256, +loopback `127.0.0.1:47600`), keeps the refresh token in Windows Credential Manager, +fetches 10-minute grants from the broker and connects to the DEV region. It renews +grants about 60 s before expiry through `SessionRefresh`, and again after a lost +connection. Sign-out revokes at the broker and at Keycloak. The bounded JSON reader +moved to `evo_json` (`evo::serialization`), which the broker and the client share. + +This completes the in-progress client work from another session. The fixes: +- `main.cpp` wiring (sign in, connect on the first grant, renew, sign out); +- the session now records the expiry from accepted refreshes, so it no longer asks + for a grant every 5 s; +- no grant requests for a superseded or cancelled session; +- clang-tidy findings (enum sizes, `stop_token` by reference, an unterminated + `string_view` in the panel); +- the Windows SDK header order, pinned against clang-format reordering. + +New `client-auth` tests (`tests/client_auth.cpp`): +- callback path, state, `iss`, duplicate and control-character refusals; +- token replies and their error mapping; +- grant replies cross-checked against the record: region, expiry, account, + environment, serial, padding and lifetime bound; +- the worker on a scripted platform: first login with PKCE fields, saved-login + rotation, fallback to the browser after a revoked refresh token, account change + refused, logout order, unconfirmed revocation, unverified email, credential-store + failure, and cancel and destruction while the browser is open. + +Executed locally: +- WSL clang-19 `client-probe` with clang-tidy as CI runs it: 14/14 CTests, plus the + Xvfb X11 lifecycle check; +- ASan/UBSan `client-auth` three times, plus `client-panels`; +- MSVC `tools/windows-check.ps1 -Preset client-package`: 18/18, including + `client-auth` and the QUIC session tests; +- the PostgreSQL broker build on the moved parser; +- clang-format 19. + +Limits: no live sign-in against `auth.aeternalisgames.com` yet. That needs the broker +pod running (the issuer key name) and the `grants.aeternalisgames.com` Ingress. diff --git a/include/evo/client/auth.hpp b/include/evo/client/auth.hpp new file mode 100644 index 0000000..e22e7c5 --- /dev/null +++ b/include/evo/client/auth.hpp @@ -0,0 +1,109 @@ +#pragma once +#include "evo/client/launcher.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace evo::client { +inline constexpr std::string_view auth_redirect = "http://127.0.0.1:47600/callback"; +inline constexpr std::string_view auth_client_id = "aevolution-game"; +enum class AuthError : std::uint8_t { + unavailable, + cancelled, + listener, + timeout, + browser, + transport, + invalid_response, + denied, + token_expired, + email_unverified, + throttled, + service_unavailable, + credential_store, + logout_incomplete +}; +[[nodiscard]] std::string_view auth_error_text(AuthError error); +struct AuthGrant { + GrantRecord bytes{}; + std::string account, endpoint, server_name; + std::uint64_t region{}, expires_at{}; +}; +struct AuthTokens { + std::string access, refresh; + std::uint64_t lifetime{}; +}; +struct AuthorizationCode { + std::string code, verifier; +}; +struct AuthHttpReply { + unsigned status{}; + std::string body; +}; +enum class AuthEndpoint : std::uint8_t { token, grant, logout, revoke }; +// Opaque tokens stay inside the worker/platform boundary. No UI, logs or plaintext files. +class AuthPlatform { + public: + virtual ~AuthPlatform() = default; + [[nodiscard]] virtual std::expected + authorize(std::stop_token stop) = 0; + [[nodiscard]] virtual std::expected post(AuthEndpoint endpoint, + std::string_view body, + std::string_view bearer, + std::stop_token stop) = 0; + [[nodiscard]] virtual std::expected load_refresh() = 0; + [[nodiscard]] virtual bool save_refresh(std::string_view token) = 0; + [[nodiscard]] virtual bool erase_refresh() = 0; +}; +[[nodiscard]] std::unique_ptr native_auth_platform(); // Windows; null elsewhere. + +[[nodiscard]] std::string auth_form_escape(std::string_view value); +[[nodiscard]] std::string auth_base64url(std::span bytes); +[[nodiscard]] std::string auth_authorization_url(std::string_view state, + std::string_view challenge); +// Only the exact loopback path, one matching state, and one code (or denial) are accepted. +[[nodiscard]] std::expected auth_callback(std::string_view target, + std::string_view state); +[[nodiscard]] std::expected auth_tokens(const AuthHttpReply& reply); +[[nodiscard]] std::expected auth_grant(const AuthHttpReply& reply, + std::uint64_t now_seconds); + +enum class AuthPhase : std::uint8_t { + signed_out, + signing_in, + ready, + renewing, + signing_out, + failed +}; +struct AuthStatus { + AuthPhase phase{AuthPhase::signed_out}; + bool supported{}, busy{}, signed_in{}; + std::optional error; +}; +// One joined worker, serialized refresh-token rotation; main-thread caller only. +// Destruction cancels browser waiting and joins bounded network work. +class AuthClient { + public: + explicit AuthClient(std::unique_ptr platform); + ~AuthClient(); + AuthClient(const AuthClient&) = delete; + AuthClient& operator=(const AuthClient&) = delete; + [[nodiscard]] bool sign_in(); + [[nodiscard]] bool request_grant(); + [[nodiscard]] bool sign_out(); + void cancel(); + [[nodiscard]] AuthStatus status() const; + [[nodiscard]] std::optional take_grant(); + + private: + struct Impl; + std::unique_ptr impl_; +}; +} // namespace evo::client diff --git a/include/evo/client/launcher.hpp b/include/evo/client/launcher.hpp index 370b9fe..0f4713c 100644 --- a/include/evo/client/launcher.hpp +++ b/include/evo/client/launcher.hpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -54,6 +55,9 @@ struct ConnectMaterial { // "host:port", "[ipv6]:port" or "a.b.c.d:port"; plain DNS host names only. [[nodiscard]] std::expected parse_endpoint(std::string_view text); [[nodiscard]] std::expected load_connect(const ConnectForm& form); +// Broker grants stay in memory; the existing pinned region CA is still required. +[[nodiscard]] std::expected +load_connect(const ConnectForm& form, std::span grants); // What the session reports while connecting, reduced to what the launcher decides on. enum class ConnectSignal : std::uint8_t { diff --git a/include/evo/serialization/json.hpp b/include/evo/serialization/json.hpp new file mode 100644 index 0000000..4250110 --- /dev/null +++ b/include/evo/serialization/json.hpp @@ -0,0 +1,44 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +// ADR-0131: a small, bounded JSON reader for access-token claims and the realm's JWKS. +// It accepts RFC 8259 JSON within the bounds below and nothing else (no comments, no +// trailing commas, no duplicate-key resolution beyond "first wins"). +namespace evo::serialization { +inline constexpr std::size_t max_json_bytes = std::size_t{16} * 1024; +inline constexpr std::size_t max_json_depth = 16; + +class JsonValue { + public: + enum class Kind : std::uint8_t { null, boolean, number, string, array, object }; + [[nodiscard]] Kind kind() const noexcept { + return kind_; + } + // Typed views; nullopt or nullptr when the value has another kind. + [[nodiscard]] std::optional boolean() const; + [[nodiscard]] std::optional string() const; + // Integers only (no fraction or exponent), within 0..2^63-1. + [[nodiscard]] std::optional integer() const; + [[nodiscard]] const JsonValue* member(std::string_view name) const; + [[nodiscard]] const std::vector* array() const; + + // Whole-document parse; nullopt for anything malformed or out of bounds. + [[nodiscard]] static std::optional parse(std::string_view text); + + private: + friend class JsonParser; + Kind kind_{Kind::null}; + bool boolean_{}; + std::string text_; // String value, or the number's literal. + std::vector items_; + std::vector> members_; +}; +} // namespace evo::serialization diff --git a/include/evo/server/broker/json.hpp b/include/evo/server/broker/json.hpp index ce837ae..a9c17eb 100644 --- a/include/evo/server/broker/json.hpp +++ b/include/evo/server/broker/json.hpp @@ -1,44 +1,8 @@ #pragma once - -#include -#include -#include -#include -#include -#include -#include -#include - -// ADR-0131: a small, bounded JSON reader for access-token claims and the realm's JWKS. -// It accepts RFC 8259 JSON within the bounds below and nothing else (no comments, no -// trailing commas, no duplicate-key resolution beyond "first wins"). +#include "evo/serialization/json.hpp" +// Compatibility names for the broker; the parser has no server or persistence dependency. namespace evo::server::broker { -inline constexpr std::size_t max_json_bytes = std::size_t{16} * 1024; -inline constexpr std::size_t max_json_depth = 16; - -class JsonValue { - public: - enum class Kind : std::uint8_t { null, boolean, number, string, array, object }; - [[nodiscard]] Kind kind() const noexcept { - return kind_; - } - // Typed views; nullopt or nullptr when the value has another kind. - [[nodiscard]] std::optional boolean() const; - [[nodiscard]] std::optional string() const; - // Integers only (no fraction or exponent), within 0..2^63-1. - [[nodiscard]] std::optional integer() const; - [[nodiscard]] const JsonValue* member(std::string_view name) const; - [[nodiscard]] const std::vector* array() const; - - // Whole-document parse; nullopt for anything malformed or out of bounds. - [[nodiscard]] static std::optional parse(std::string_view text); - - private: - friend class JsonParser; - Kind kind_{Kind::null}; - bool boolean_{}; - std::string text_; // String value, or the number's literal. - std::vector items_; - std::vector> members_; -}; +using serialization::JsonValue; +using serialization::max_json_bytes; +using serialization::max_json_depth; } // namespace evo::server::broker diff --git a/src/client/auth/client.cpp b/src/client/auth/client.cpp new file mode 100644 index 0000000..eea78ee --- /dev/null +++ b/src/client/auth/client.cpp @@ -0,0 +1,227 @@ +#include "evo/client/auth.hpp" +#include +#include +#include + +namespace evo::client { +namespace { +void erase(std::string& value) { + for (auto& ch : value) + *static_cast(&ch) = 0; + value.clear(); +} +std::uint64_t utc_seconds() { + return static_cast(std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count()); +} +} // namespace +struct AuthClient::Impl { + explicit Impl(std::unique_ptr adapter) : platform{std::move(adapter)} { + state.supported = platform != nullptr; + } + ~Impl() { + worker.request_stop(); + if (worker.joinable()) + worker.join(); + erase(tokens.access); + erase(tokens.refresh); + if (grant) + grant->bytes.fill(0); + } + enum class Job : std::uint8_t { login, grant, logout }; + std::unique_ptr platform; + mutable std::mutex mutex; + AuthStatus state; + std::optional grant; + AuthTokens tokens; + std::chrono::steady_clock::time_point access_until{}; + std::string account; + std::jthread worker; + + std::expected exchange(std::string body, const std::stop_token& stop) { + // Rotation is single-use. Remove the old saved token before sending so a + // crash or lost reply cannot replay an ambiguously consumed refresh token. + if (!platform->erase_refresh()) { + erase(body); + return std::unexpected{AuthError::credential_store}; + } + auto response = platform->post(AuthEndpoint::token, body, {}, stop); + erase(body); + erase(tokens.access); + erase(tokens.refresh); + if (!response) + return std::unexpected{response.error()}; + auto next = auth_tokens(*response); + erase(response->body); + if (!next) + return std::unexpected{next.error()}; + if (!platform->save_refresh(next->refresh)) { + erase(next->access); + erase(next->refresh); + return std::unexpected{AuthError::credential_store}; + } + access_until = std::chrono::steady_clock::now() + std::chrono::seconds{next->lifetime}; + tokens = std::move(*next); + return {}; + } + std::expected renew(const std::stop_token& stop) { + if (tokens.refresh.empty()) + return std::unexpected{AuthError::token_expired}; + return exchange("grant_type=refresh_token&client_id=" + std::string{auth_client_id} + + "&refresh_token=" + auth_form_escape(tokens.refresh), + stop); + } + std::expected login(const std::stop_token& stop) { + auto saved = platform->load_refresh(); + if (!saved) + return std::unexpected{saved.error()}; + if (!saved->empty()) { + tokens.refresh = std::move(*saved); + if (const auto refreshed = renew(stop); refreshed) + return {}; + if (stop.stop_requested()) + return std::unexpected{AuthError::cancelled}; + } + auto authorization = platform->authorize(stop); + if (!authorization) + return std::unexpected{authorization.error()}; + auto body = "grant_type=authorization_code&client_id=" + std::string{auth_client_id} + + "&redirect_uri=" + auth_form_escape(auth_redirect) + + "&code=" + auth_form_escape(authorization->code) + + "&code_verifier=" + auth_form_escape(authorization->verifier); + erase(authorization->code); + erase(authorization->verifier); + return exchange(std::move(body), stop); + } + std::expected fetch_grant(const std::stop_token& stop) { + if (std::chrono::steady_clock::now() + std::chrono::seconds{60} >= access_until) { + const auto refreshed = renew(stop); + if (!refreshed) + return refreshed; + } + auto response = platform->post(AuthEndpoint::grant, {}, tokens.access, stop); + if (!response) + return std::unexpected{response.error()}; + auto received = auth_grant(*response, utc_seconds()); + erase(response->body); + if (!received) + return std::unexpected{received.error()}; + if (!account.empty() && account != received->account) + return std::unexpected{AuthError::invalid_response}; + if (stop.stop_requested()) { + received->bytes.fill(0); + return std::unexpected{AuthError::cancelled}; + } + account = received->account; + std::lock_guard lock{mutex}; + grant = std::move(*received); + return {}; + } + std::expected logout(const std::stop_token& stop) { + bool complete = true; + if (tokens.refresh.empty()) { + auto saved = platform->load_refresh(); + if (saved) + tokens.refresh = std::move(*saved); + else + complete = false; + } + if (std::chrono::steady_clock::now() >= access_until && !tokens.refresh.empty()) + if (!renew(stop)) + complete = false; + if (!tokens.access.empty()) { + const auto response = platform->post(AuthEndpoint::logout, {}, tokens.access, stop); + complete = response && response->status >= 200 && response->status < 300 && complete; + } else + complete = false; + if (!tokens.refresh.empty()) { + auto body = "client_id=" + std::string{auth_client_id} + + "&token_type_hint=refresh_token&token=" + auth_form_escape(tokens.refresh); + const auto response = platform->post(AuthEndpoint::revoke, body, {}, stop); + erase(body); + complete = response && response->status >= 200 && response->status < 300 && complete; + } + const bool cleared = platform->erase_refresh(); + erase(tokens.access); + erase(tokens.refresh); + account.clear(); + if (!cleared) + return std::unexpected{AuthError::credential_store}; + return complete ? std::expected{} + : std::unexpected{AuthError::logout_incomplete}; + } + bool start(Job job) { + { + std::lock_guard lock{mutex}; + if (!platform || state.busy || (job == Job::grant && !state.signed_in)) + return false; + state.busy = true; + state.error.reset(); + state.phase = job == Job::login ? AuthPhase::signing_in + : job == Job::logout ? AuthPhase::signing_out + : AuthPhase::renewing; + if (grant) + grant->bytes.fill(0); + grant.reset(); + } + if (worker.joinable()) + worker.join(); + worker = std::jthread{[this, job](const std::stop_token& stop) { + auto result = std::expected{}; + if (job == Job::logout) + result = logout(stop); + else { + if (job == Job::login) { + account.clear(); + result = login(stop); + } + if (result && !stop.stop_requested()) + result = fetch_grant(stop); + } + std::lock_guard lock{mutex}; + if (stop.stop_requested()) { + if (grant) + grant->bytes.fill(0); + grant.reset(); + result = std::unexpected{AuthError::cancelled}; + } + state.busy = false; + state.signed_in = !tokens.refresh.empty(); + state.phase = result ? (state.signed_in ? AuthPhase::ready : AuthPhase::signed_out) + : AuthPhase::failed; + if (!result) + state.error = result.error(); + }}; + return true; + } +}; +AuthClient::AuthClient(std::unique_ptr platform) + : impl_{std::make_unique(std::move(platform))} {} +AuthClient::~AuthClient() = default; +bool AuthClient::sign_in() { + return impl_->start(Impl::Job::login); +} +bool AuthClient::request_grant() { + return impl_->start(Impl::Job::grant); +} +bool AuthClient::sign_out() { + return impl_->start(Impl::Job::logout); +} +void AuthClient::cancel() { + impl_->worker.request_stop(); +} +AuthStatus AuthClient::status() const { + std::lock_guard lock{impl_->mutex}; + return impl_->state; +} +std::optional AuthClient::take_grant() { + std::lock_guard lock{impl_->mutex}; + return std::exchange(impl_->grant, {}); +} +#ifndef _WIN32 +std::unique_ptr native_auth_platform() { + return {}; +} +#endif +} // namespace evo::client diff --git a/src/client/auth/protocol.cpp b/src/client/auth/protocol.cpp new file mode 100644 index 0000000..22e3b2d --- /dev/null +++ b/src/client/auth/protocol.cpp @@ -0,0 +1,256 @@ +#include "evo/client/auth.hpp" +#include "evo/serialization/json.hpp" +#include +#include +#include + +namespace evo::client { +namespace { +using serialization::JsonValue; +constexpr std::string_view issuer = "https://auth.aeternalisgames.com/realms/aeternalis"; +std::optional string_member(const JsonValue& value, std::string_view name) { + const auto* member = value.member(name); + return member ? member->string() : std::nullopt; +} +std::optional number_member(const JsonValue& value, std::string_view name) { + const auto* member = value.member(name); + return member ? member->integer() : std::nullopt; +} +AuthError reply_error(const AuthHttpReply& reply) { + if (reply.status == 429) + return AuthError::throttled; + if (reply.status >= 500) + return AuthError::service_unavailable; + const auto json = JsonValue::parse(reply.body); + if (json) { + const auto error = string_member(*json, "error").value_or(""); + if (error == "email_not_verified") + return AuthError::email_unverified; + if (error == "invalid_grant" || error == "token_expired" || reply.status == 401) + return AuthError::token_expired; + } + return AuthError::denied; +} +int hex(char ch) { + if (ch >= '0' && ch <= '9') + return ch - '0'; + if (ch >= 'a' && ch <= 'f') + return ch - 'a' + 10; + if (ch >= 'A' && ch <= 'F') + return ch - 'A' + 10; + return -1; +} +std::optional unescape(std::string_view text) { + std::string out; + for (std::size_t i = 0; i < text.size(); ++i) { + unsigned char ch = static_cast(text[i]); + if (ch == '%') { + if (i + 2 >= text.size() || hex(text[i + 1]) < 0 || hex(text[i + 2]) < 0) + return {}; + ch = static_cast(hex(text[i + 1]) * 16 + hex(text[i + 2])); + i += 2; + } else if (ch == '+') + ch = ' '; + if (ch < 0x20 || ch == 0x7f) + return {}; + out.push_back(static_cast(ch)); + } + return out; +} +std::uint64_t grant_field(const GrantRecord& bytes, std::size_t offset) { + std::uint64_t value = 0; + for (std::size_t i = 0; i < 8; ++i) + value |= static_cast(bytes[offset + i]) << (i * 8); + return value; +} +bool token_text(std::string_view text) { + return !text.empty() && text.size() <= 4096 && + std::ranges::all_of(text, [](unsigned char ch) { return ch > 0x20 && ch < 0x7f; }); +} +} // namespace +std::string_view auth_error_text(AuthError error) { + switch (error) { + case AuthError::unavailable: + return "Browser sign-in is available in the Windows network client."; + case AuthError::cancelled: + return "Sign-in cancelled."; + case AuthError::listener: + return "The sign-in return port (47600) is in use. Close the other sign-in attempt and " + "retry."; + case AuthError::timeout: + return "Sign-in timed out. Please try again."; + case AuthError::browser: + return "The system browser could not be opened."; + case AuthError::transport: + return "The secure login service could not be reached. Please retry."; + case AuthError::invalid_response: + return "The login service returned an invalid response."; + case AuthError::denied: + return "Sign-in was refused. Check your account and try again."; + case AuthError::token_expired: + return "Your login expired or could not be renewed. Sign in again."; + case AuthError::email_unverified: + return "Verify your email in Keycloak, then try again."; + case AuthError::throttled: + return "Please wait a few seconds before requesting another connection."; + case AuthError::service_unavailable: + return "The grant service is temporarily unavailable."; + case AuthError::credential_store: + return "Windows Credential Manager could not save or clear your login."; + case AuthError::logout_incomplete: + return "Signed out locally. Server revocation could not be confirmed; issued grants may " + "remain valid until expiry."; + } + return "Sign-in failed."; +} +std::string auth_form_escape(std::string_view value) { + constexpr std::string_view digits = "0123456789ABCDEF"; + std::string out; + for (const char raw : value) { + const auto ch = static_cast(raw); + if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || + ch == '-' || ch == '_' || ch == '.' || ch == '~') + out.push_back(static_cast(ch)); + else { + out.push_back('%'); + out.push_back(digits[ch >> 4U]); + out.push_back(digits[ch & 15U]); + } + } + return out; +} +std::string auth_base64url(std::span bytes) { + constexpr std::string_view alphabet = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; + std::string out; + std::uint32_t value = 0; + unsigned bits = 0; + for (const auto byte : bytes) { + value = (value << 8U) | byte; + bits += 8; + while (bits >= 6) { + bits -= 6; + out.push_back(alphabet[(value >> bits) & 63U]); + } + } + if (bits != 0) + out.push_back(alphabet[(value << (6U - bits)) & 63U]); + return out; +} +std::string auth_authorization_url(std::string_view state, std::string_view challenge) { + return std::string{issuer} + + "/protocol/openid-connect/auth?client_id=" + std::string{auth_client_id} + + "&response_type=code&scope=openid%20email%20profile" + + "&redirect_uri=" + auth_form_escape(auth_redirect) + "&code_challenge_method=S256" + + "&code_challenge=" + auth_form_escape(challenge) + "&state=" + auth_form_escape(state) + + "&prompt=select_account"; +} +std::expected auth_callback(std::string_view target, + std::string_view state) { + if (!target.starts_with("/callback?") || target.size() > 8192 || state.empty()) + return std::unexpected{AuthError::invalid_response}; + target.remove_prefix(10); + std::vector> fields; + while (!target.empty()) { + const auto end = target.find('&'); + const auto field = target.substr(0, end); + const auto equal = field.find('='); + if (equal == std::string_view::npos || fields.size() >= 8) + return std::unexpected{AuthError::invalid_response}; + auto key = unescape(field.substr(0, equal)), value = unescape(field.substr(equal + 1)); + if (!key || !value || + std::ranges::any_of(fields, [&](const auto& old) { return old.first == *key; })) + return std::unexpected{AuthError::invalid_response}; + fields.emplace_back(std::move(*key), std::move(*value)); + if (end == std::string_view::npos) + break; + target.remove_prefix(end + 1); + } + const auto get = [&](std::string_view name) -> std::string_view { + for (const auto& field : fields) + if (field.first == name) + return field.second; + return {}; + }; + if (get("state") != state || (!get("iss").empty() && get("iss") != issuer)) + return std::unexpected{AuthError::invalid_response}; + if (!get("error").empty()) + return std::unexpected{AuthError::denied}; + if (!token_text(get("code"))) + return std::unexpected{AuthError::invalid_response}; + return std::string{get("code")}; +} +std::expected auth_tokens(const AuthHttpReply& reply) { + if (reply.status != 200) + return std::unexpected{reply_error(reply)}; + const auto json = JsonValue::parse(reply.body); + if (!json) + return std::unexpected{AuthError::invalid_response}; + const auto access = string_member(*json, "access_token").value_or(""); + const auto refresh = string_member(*json, "refresh_token").value_or(""); + const auto type = string_member(*json, "token_type").value_or(""); + const auto lifetime = number_member(*json, "expires_in").value_or(0); + if (!token_text(access) || !token_text(refresh) || (type != "Bearer" && type != "bearer") || + lifetime < 1 || lifetime > 3600) + return std::unexpected{AuthError::invalid_response}; + return AuthTokens{std::string{access}, std::string{refresh}, lifetime}; +} +std::expected auth_grant(const AuthHttpReply& reply, + std::uint64_t now_seconds) { + if (reply.status != 200) + return std::unexpected{reply_error(reply)}; + const auto json = JsonValue::parse(reply.body); + if (!json) + return std::unexpected{AuthError::invalid_response}; + AuthGrant result; + result.account = string_member(*json, "account").value_or(""); + result.endpoint = string_member(*json, "endpoint").value_or(""); + result.server_name = string_member(*json, "server_name").value_or(""); + result.region = number_member(*json, "region").value_or(0); + result.expires_at = number_member(*json, "expires_at").value_or(0); + const auto encoded = string_member(*json, "grant").value_or(""); + if (encoded.size() != 216 || !encoded.ends_with("==") || !parse_endpoint(result.endpoint) || + result.server_name.empty() || !parse_endpoint(result.server_name + ":1") || + result.server_name.find_first_of(":[]") != std::string::npos || result.region == 0 || + result.expires_at <= now_seconds || result.expires_at - now_seconds > 900 || + result.account.size() != 36) + return std::unexpected{AuthError::invalid_response}; + constexpr std::string_view alphabet = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + std::uint32_t value = 0; + unsigned bits = 0; + std::size_t at = 0; + for (const auto ch : encoded.substr(0, 214)) { + const auto digit = alphabet.find(ch); + if (digit == std::string_view::npos) + return std::unexpected{AuthError::invalid_response}; + value = (value << 6U) | static_cast(digit); + bits += 6; + if (bits >= 8) { + bits -= 8; + result.bytes.at(at++) = static_cast(value >> bits); + } + } + if (at != 160 || (value & 15U) != 0) + return std::unexpected{AuthError::invalid_response}; + constexpr std::array marker{'E', 'V', 'O', '-', 'G', 'R', 'A', 'N', 'T'}; + if (!std::equal(marker.begin(), marker.end(), result.bytes.begin()) || result.bytes[16] != 1 || + result.bytes[17] != 0 || result.bytes[18] != 1 || result.bytes[19] != 0 || + grant_field(result.bytes, 72) != result.region || + grant_field(result.bytes, 88) != result.expires_at || grant_field(result.bytes, 48) == 0) + return std::unexpected{AuthError::invalid_response}; + at = 32; + for (std::size_t i = 0; i < result.account.size();) { + if (i == 8 || i == 13 || i == 18 || i == 23) { + if (result.account[i++] != '-') + return std::unexpected{AuthError::invalid_response}; + continue; + } + if (hex(result.account[i]) < 0 || hex(result.account[i + 1]) < 0 || + result.bytes[at++] != hex(result.account[i]) * 16 + hex(result.account[i + 1])) + return std::unexpected{AuthError::invalid_response}; + i += 2; + } + return result; // The region verifies signature/scope; JSON cannot override grant claims. +} +} // namespace evo::client diff --git a/src/client/auth/windows.cpp b/src/client/auth/windows.cpp new file mode 100644 index 0000000..892f422 --- /dev/null +++ b/src/client/auth/windows.cpp @@ -0,0 +1,264 @@ +#include "evo/client/auth.hpp" + +// Order matters: winsock2.h before windows.h, and windows.h before the other SDK headers. +#include + +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace evo::client { +namespace { +constexpr wchar_t credential_name[] = L"AeternalisEvolution/DEV/refresh-token/v1"; +struct InternetHandle { + HINTERNET value{}; + ~InternetHandle() { + if (value) + WinHttpCloseHandle(value); + } +}; +struct Socket { + SOCKET value{INVALID_SOCKET}; + ~Socket() { + if (value != INVALID_SOCKET) + closesocket(value); + } +}; +struct Winsock { + bool ready{}; + Winsock() { + WSADATA data{}; + ready = WSAStartup(MAKEWORD(2, 2), &data) == 0; + } + ~Winsock() { + if (ready) + WSACleanup(); + } +}; +struct Algorithm { + BCRYPT_ALG_HANDLE value{}; + ~Algorithm() { + if (value) + BCryptCloseAlgorithmProvider(value, 0); + } +}; +std::wstring wide(std::string_view value) { + return {value.begin(), value.end()}; +} +bool readable(SOCKET socket, long microseconds) { + fd_set read{}; + FD_ZERO(&read); + FD_SET(socket, &read); + timeval timeout{0, microseconds}; + return select(0, &read, nullptr, nullptr, &timeout) > 0; +} +class WindowsAuth final : public AuthPlatform { + public: + std::expected authorize(std::stop_token stop) override { + Winsock winsock; + if (!winsock.ready) + return std::unexpected{AuthError::listener}; + Socket listener{socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)}; + if (listener.value == INVALID_SOCKET) + return std::unexpected{AuthError::listener}; + const BOOL exclusive = TRUE; + sockaddr_in address{}; + address.sin_family = AF_INET; + address.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + address.sin_port = htons(47600); + if (setsockopt(listener.value, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, + reinterpret_cast(&exclusive), sizeof(exclusive)) != 0 || + bind(listener.value, reinterpret_cast(&address), sizeof(address)) != 0 || + listen(listener.value, 4) != 0) + return std::unexpected{AuthError::listener}; + std::array secret{}; + std::array random_state{}, digest{}; + if (BCryptGenRandom(nullptr, secret.data(), static_cast(secret.size()), + BCRYPT_USE_SYSTEM_PREFERRED_RNG) < 0 || + BCryptGenRandom(nullptr, random_state.data(), static_cast(random_state.size()), + BCRYPT_USE_SYSTEM_PREFERRED_RNG) < 0) + return std::unexpected{AuthError::unavailable}; + auto verifier = auth_base64url(secret); + SecureZeroMemory(secret.data(), secret.size()); + const auto state = auth_base64url(random_state); + Algorithm sha; + if (BCryptOpenAlgorithmProvider(&sha.value, BCRYPT_SHA256_ALGORITHM, nullptr, 0) < 0 || + BCryptHash(sha.value, nullptr, 0, reinterpret_cast(verifier.data()), + static_cast(verifier.size()), digest.data(), + static_cast(digest.size())) < 0) + return std::unexpected{AuthError::unavailable}; + const auto url = wide(auth_authorization_url(state, auth_base64url(digest))); + if (reinterpret_cast(ShellExecuteW(nullptr, L"open", url.c_str(), nullptr, nullptr, + SW_SHOWNORMAL)) <= 32) + return std::unexpected{AuthError::browser}; + const auto deadline = std::chrono::steady_clock::now() + std::chrono::minutes{5}; + while (!stop.stop_requested() && std::chrono::steady_clock::now() < deadline) { + if (!readable(listener.value, 100000)) + continue; + Socket connection{accept(listener.value, nullptr, nullptr)}; + if (connection.value == INVALID_SOCKET) + continue; + const DWORD timeout = 1000; + static_cast(setsockopt(connection.value, SOL_SOCKET, SO_SNDTIMEO, + reinterpret_cast(&timeout), sizeof(timeout))); + std::string request; + const auto read_until = std::chrono::steady_clock::now() + std::chrono::seconds{2}; + while (!stop.stop_requested() && request.size() < 8192 && + std::chrono::steady_clock::now() < read_until && + request.find("\r\n\r\n") == std::string::npos) { + if (!readable(connection.value, 100000)) + continue; + std::array buffer{}; + const auto count = + recv(connection.value, buffer.data(), static_cast(buffer.size()), 0); + if (count <= 0) + break; + request.append(buffer.data(), static_cast(count)); + } + const auto line_end = request.find("\r\n"); + const auto end = request.find(" HTTP/1.1\r\n"); + auto headers = line_end == std::string::npos ? std::string{} : request.substr(line_end); + std::ranges::transform(headers, headers.begin(), [](unsigned char ch) { + return static_cast(std::tolower(ch)); + }); + auto code = + std::expected{std::unexpected{AuthError::invalid_response}}; + if (request.size() <= 8192 && request.find("\r\n\r\n") != std::string::npos && + request.starts_with("GET ") && end != std::string::npos && + headers.find("\r\nhost: 127.0.0.1:47600\r\n") != std::string::npos) + code = auth_callback(std::string_view{request}.substr(4, end - 4), state); + const bool finished = code || code.error() == AuthError::denied; + const std::string response = + std::string{finished ? "HTTP/1.1 200 OK\r\n" : "HTTP/1.1 400 Bad Request\r\n"} + + "Content-Type: text/plain; charset=utf-8\r\nCache-Control: no-store\r\n" + "Content-Security-Policy: default-src 'none'; frame-ancestors 'none'\r\n" + "Referrer-Policy: no-referrer\r\nConnection: close\r\n\r\n" + + (code ? "Login response received. Return to Aeternalis Evolution to continue." + : "Login response not accepted. Return to Aeternalis Evolution."); + static_cast( + send(connection.value, response.data(), static_cast(response.size()), 0)); + SecureZeroMemory(request.data(), request.size()); + if (code) + return AuthorizationCode{std::move(*code), std::move(verifier)}; + if (finished) + return std::unexpected{AuthError::denied}; + } + return std::unexpected{stop.stop_requested() ? AuthError::cancelled : AuthError::timeout}; + } + std::expected post(AuthEndpoint endpoint, std::string_view body, + std::string_view bearer, + std::stop_token stop) override { + if (stop.stop_requested()) + return std::unexpected{AuthError::cancelled}; + if (body.size() > 16384 || bearer.size() > 4096 || + bearer.find_first_of("\r\n") != std::string_view::npos) + return std::unexpected{AuthError::invalid_response}; + const bool broker = endpoint == AuthEndpoint::grant || endpoint == AuthEndpoint::logout; + const wchar_t* host = broker ? L"grants.aeternalisgames.com" : L"auth.aeternalisgames.com"; + const wchar_t* path = endpoint == AuthEndpoint::grant ? L"/grant" + : endpoint == AuthEndpoint::logout ? L"/logout" + : endpoint == AuthEndpoint::token + ? L"/realms/aeternalis/protocol/openid-connect/token" + : L"/realms/aeternalis/protocol/openid-connect/revoke"; + InternetHandle session{WinHttpOpen(L"AeternalisEvolution/1", + WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, + WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0)}; + if (!session.value || !WinHttpSetTimeouts(session.value, 5000, 5000, 5000, 5000)) + return std::unexpected{AuthError::transport}; + InternetHandle connection{ + WinHttpConnect(session.value, host, INTERNET_DEFAULT_HTTPS_PORT, 0)}; + if (!connection.value) + return std::unexpected{AuthError::transport}; + InternetHandle request{WinHttpOpenRequest(connection.value, L"POST", path, nullptr, + WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, + WINHTTP_FLAG_SECURE)}; + if (!request.value) + return std::unexpected{AuthError::transport}; + DWORD disable = WINHTTP_DISABLE_REDIRECTS | WINHTTP_DISABLE_COOKIES; + DWORD logon = WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH; + if (!WinHttpSetOption(request.value, WINHTTP_OPTION_DISABLE_FEATURE, &disable, + sizeof(disable)) || + !WinHttpSetOption(request.value, WINHTTP_OPTION_AUTOLOGON_POLICY, &logon, + sizeof(logon))) + return std::unexpected{AuthError::transport}; + auto headers = std::wstring{ + L"Content-Type: application/x-www-form-urlencoded\r\nAccept: application/json\r\n"}; + if (!bearer.empty()) + headers += L"Authorization: Bearer " + wide(bearer) + L"\r\n"; + const bool sent = + WinHttpSendRequest( + request.value, headers.c_str(), static_cast(headers.size()), + body.empty() ? WINHTTP_NO_REQUEST_DATA : const_cast(body.data()), + static_cast(body.size()), static_cast(body.size()), 0) != 0; + SecureZeroMemory(headers.data(), headers.size() * sizeof(wchar_t)); + if (!sent || stop.stop_requested() || !WinHttpReceiveResponse(request.value, nullptr)) + return std::unexpected{stop.stop_requested() ? AuthError::cancelled + : AuthError::transport}; + DWORD status = 0, size = sizeof(status); + if (!WinHttpQueryHeaders( + request.value, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + WINHTTP_HEADER_NAME_BY_INDEX, &status, &size, WINHTTP_NO_HEADER_INDEX)) + return std::unexpected{AuthError::invalid_response}; + AuthHttpReply reply{status, {}}; + while (!stop.stop_requested()) { + std::array buffer{}; + DWORD count = 0; + if (!WinHttpReadData(request.value, buffer.data(), static_cast(buffer.size()), + &count)) + return std::unexpected{AuthError::transport}; + if (count == 0) + return reply; + if (reply.body.size() + count > 16384) + return std::unexpected{AuthError::invalid_response}; + reply.body.append(buffer.data(), count); + } + return std::unexpected{AuthError::cancelled}; + } + std::expected load_refresh() override { + PCREDENTIALW credential = nullptr; + if (!CredReadW(credential_name, CRED_TYPE_GENERIC, 0, &credential)) { + if (GetLastError() == ERROR_NOT_FOUND) + return std::string{}; + return std::unexpected{AuthError::credential_store}; + } + std::string token; + if (credential->CredentialBlobSize <= 4096 && credential->CredentialBlob) + token.assign(reinterpret_cast(credential->CredentialBlob), + credential->CredentialBlobSize); + SecureZeroMemory(credential->CredentialBlob, credential->CredentialBlobSize); + CredFree(credential); + if (token.empty() || + !std::ranges::all_of(token, [](unsigned char ch) { return ch > 0x20 && ch < 0x7f; })) + return std::unexpected{AuthError::credential_store}; + return token; + } + bool save_refresh(std::string_view token) override { + if (token.empty() || token.size() > CRED_MAX_CREDENTIAL_BLOB_SIZE) + return false; + CREDENTIALW credential{}; + credential.Type = CRED_TYPE_GENERIC; + credential.TargetName = const_cast(credential_name); + credential.UserName = const_cast(L"aevolution-game"); + credential.CredentialBlobSize = static_cast(token.size()); + credential.CredentialBlob = reinterpret_cast(const_cast(token.data())); + credential.Persist = CRED_PERSIST_LOCAL_MACHINE; + return CredWriteW(&credential, 0) != 0; + } + bool erase_refresh() override { + return CredDeleteW(credential_name, CRED_TYPE_GENERIC, 0) != 0 || + GetLastError() == ERROR_NOT_FOUND; + } +}; +} // namespace +std::unique_ptr native_auth_platform() { + return std::make_unique(); +} +} // namespace evo::client diff --git a/src/client/ui/launcher.cpp b/src/client/ui/launcher.cpp index 87b8f3b..a563abf 100644 --- a/src/client/ui/launcher.cpp +++ b/src/client/ui/launcher.cpp @@ -91,7 +91,8 @@ std::expected parse_endpoint(std::string_view text) { return Endpoint{host, static_cast(port)}; } -std::expected load_connect(const ConnectForm& form) { +std::expected load_connect(const ConnectForm& form, + std::span grants) { const auto endpoint = parse_endpoint(form.endpoint); if (!endpoint) return std::unexpected(endpoint.error()); @@ -99,8 +100,6 @@ std::expected load_connect(const ConnectForm& form return std::unexpected(LaunchError::server_name); if (!plain_text(form.authority_path)) return std::unexpected(LaunchError::authority_path); - if (!plain_text(form.grants_path)) - return std::unexpected(LaunchError::grants_path); const auto authority = read_bounded(form.authority_path, max_authority_bytes, LaunchError::authority_unreadable, LaunchError::authority_invalid); @@ -110,17 +109,33 @@ std::expected load_connect(const ConnectForm& form if (pem.find("-----BEGIN CERTIFICATE-----") == std::string::npos || pem.find('\0') != std::string::npos) return std::unexpected(LaunchError::authority_invalid); + if (grants.empty() || grants.size() > max_grant_records) + return std::unexpected(LaunchError::grants_invalid); + return ConnectMaterial{*endpoint, + form.server_name, + std::move(pem), + form.authority_path, + {grants.begin(), grants.end()}}; +} +std::expected load_connect(const ConnectForm& form) { + // Validate the endpoint/CA first, preserving the manual launcher's error order. + const std::array placeholder{}; + auto material = load_connect(form, placeholder); + if (!material) + return material; + if (!plain_text(form.grants_path)) + return std::unexpected(LaunchError::grants_path); const auto bundle = read_bounded(form.grants_path, grant_record_bytes * max_grant_records, LaunchError::grants_unreadable, LaunchError::grants_invalid); if (!bundle) return std::unexpected(bundle.error()); if (bundle->size() % grant_record_bytes != 0) return std::unexpected(LaunchError::grants_invalid); - ConnectMaterial material{*endpoint, form.server_name, std::move(pem), form.authority_path, {}}; + material->grants.clear(); for (std::size_t at = 0; at < bundle->size(); at += grant_record_bytes) { GrantRecord grant{}; std::copy_n(bundle->begin() + static_cast(at), grant.size(), grant.begin()); - material.grants.push_back(grant); + material->grants.push_back(grant); } return material; } diff --git a/src/server/broker/json.cpp b/src/serialization/json.cpp similarity index 98% rename from src/server/broker/json.cpp rename to src/serialization/json.cpp index dfb2420..af8cbd9 100644 --- a/src/server/broker/json.cpp +++ b/src/serialization/json.cpp @@ -1,9 +1,9 @@ -#include "evo/server/broker/json.hpp" +#include "evo/serialization/json.hpp" #include #include -namespace evo::server::broker { +namespace evo::serialization { namespace { void append_utf8(std::string& out, std::uint32_t code) { if (code < 0x80) { @@ -298,4 +298,4 @@ const JsonValue* JsonValue::member(std::string_view name) const { const std::vector* JsonValue::array() const { return kind_ == Kind::array ? &items_ : nullptr; } -} // namespace evo::server::broker +} // namespace evo::serialization diff --git a/tests/client_auth.cpp b/tests/client_auth.cpp new file mode 100644 index 0000000..9b0d8ff --- /dev/null +++ b/tests/client_auth.cpp @@ -0,0 +1,380 @@ +// ADR-0131 client sign-in: the loopback callback, token and grant replies, and the +// AuthClient worker against a scripted platform (no browser, network or credential store). +#include "evo/client/auth.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +using namespace evo::client; +using namespace std::chrono_literals; +void check(bool ok, std::source_location at = std::source_location::current()) { + if (!ok) + throw std::runtime_error("client auth line " + std::to_string(at.line())); +} +#define CHECK(...) check(static_cast(__VA_ARGS__)) + +constexpr std::uint64_t now_s = 1'800'000'000; +constexpr std::string_view account_text = "11111111-2222-3333-4444-555555555555"; + +std::string base64(std::span bytes) { + constexpr std::string_view alphabet = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + std::string out; + std::size_t i = 0; + for (; i + 3 <= bytes.size(); i += 3) { + const auto v = + (std::uint32_t{bytes[i]} << 16U) | (std::uint32_t{bytes[i + 1]} << 8U) | bytes[i + 2]; + for (int s = 18; s >= 0; s -= 6) + out.push_back(alphabet[(v >> static_cast(s)) & 63U]); + } + if (bytes.size() - i == 1) { + const auto v = std::uint32_t{bytes[i]} << 16U; + out += {alphabet[(v >> 18U) & 63U], alphabet[(v >> 12U) & 63U], '=', '='}; + } else if (bytes.size() - i == 2) { + const auto v = (std::uint32_t{bytes[i]} << 16U) | (std::uint32_t{bytes[i + 1]} << 8U); + out += {alphabet[(v >> 18U) & 63U], alphabet[(v >> 12U) & 63U], alphabet[(v >> 6U) & 63U], + '='}; + } + return out; +} +void put(GrantRecord& g, std::size_t at, std::uint64_t value) { + for (std::size_t i = 0; i < 8; ++i) + g[at + i] = static_cast(value >> (8 * i)); +} +// The grant layout of schemas/network/session-grant-v1.md; the signature is not checked +// by the client (the region verifies it). +GrantRecord grant_bytes(std::uint64_t serial, std::uint64_t region, std::uint64_t expires) { + GrantRecord g{}; + const std::string_view marker = "EVO-GRANT"; + std::copy(marker.begin(), marker.end(), g.begin()); + g[16] = 1; // Version 1, little-endian. + g[18] = 1; // Dev. + g[20] = 1; // Key id 1. + put(g, 24, 0xABCDEF); // Grant id. + const std::array account{0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, + 0x44, 0x44, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55}; + std::copy(account.begin(), account.end(), g.begin() + 32); + put(g, 48, serial); + put(g, 56, 100); + put(g, 64, 9); + put(g, 72, region); + put(g, 80, now_s); + put(g, 88, expires); + return g; +} +std::string grant_json(const GrantRecord& g, std::uint64_t region, std::uint64_t expires, + std::string_view account = account_text) { + return R"({"grant":")" + base64(g) + R"(","account":")" + std::string(account) + + R"(","region":)" + std::to_string(region) + + R"(,"endpoint":"void.example.test:7400","server_name":"void.example.test","expires_at":)" + + std::to_string(expires) + "}\n"; +} +std::string token_json(std::string_view access, std::string_view refresh, + std::uint64_t lifetime = 300) { + return R"({"access_token":")" + std::string(access) + R"(","expires_in":)" + + std::to_string(lifetime) + R"(,"refresh_expires_in":1800,"refresh_token":")" + + std::string(refresh) + R"(","token_type":"Bearer","scope":"openid email profile"})"; +} + +void protocol_tests() { + CHECK(auth_form_escape("a b/~-_.Z9") == "a%20b%2F~-_.Z9"); + CHECK(auth_base64url(std::array{0xFB, 0xFF}) == "-_8"); + CHECK(auth_base64url(std::array{1, 2, 3}) == "AQID"); + const auto url = auth_authorization_url("st", "ch"); + CHECK(url.starts_with( + "https://auth.aeternalisgames.com/realms/aeternalis/protocol/openid-connect/auth?")); + for (const std::string_view part : + {"client_id=aevolution-game", "response_type=code", "code_challenge_method=S256", + "code_challenge=ch", "state=st", + "redirect_uri=http%3A%2F%2F127.0.0.1%3A47600%2Fcallback"}) + CHECK(url.find(part) != std::string::npos); + + // Callback: exact path, the one state, one code; denial and anything else refused. + CHECK(auth_callback("/callback?state=st&code=abc.DEF-1&session_state=x", "st") == "abc.DEF-1"); + CHECK(auth_callback("/callback?code=c&state=st&iss=https%3A%2F%2Fauth.aeternalisgames.com%2F" + "realms%2Faeternalis", + "st") == "c"); + const auto refused = [](std::string_view target, AuthError expected) { + const auto code = auth_callback(target, "st"); + return !code && code.error() == expected; + }; + CHECK(refused("/callback?state=st&error=access_denied", AuthError::denied)); + CHECK(refused("/callback?state=other&code=c", AuthError::invalid_response)); + CHECK(refused("/callback?state=st&state=st&code=c", AuthError::invalid_response)); + CHECK(refused("/callback?state=st&code=c&iss=https%3A%2F%2Fevil.example", + AuthError::invalid_response)); + CHECK(refused("/other?state=st&code=c", AuthError::invalid_response)); + CHECK(refused("/callback?state=st&code=a%0Ab", AuthError::invalid_response)); + CHECK(refused("/callback?state=st&code=a%2", AuthError::invalid_response)); + CHECK(refused("/callback?state=st", AuthError::invalid_response)); + CHECK(!auth_callback("/callback?state=&code=c", "")); + + // Token replies. + const auto tokens = auth_tokens({200, token_json("acc", "ref")}); + CHECK(tokens && tokens->access == "acc" && tokens->refresh == "ref" && tokens->lifetime == 300); + const auto token_error = [](const AuthHttpReply& reply, AuthError expected) { + const auto result = auth_tokens(reply); + return !result && result.error() == expected; + }; + CHECK(token_error({400, R"({"error":"invalid_grant"})"}, AuthError::token_expired)); + CHECK(token_error({429, ""}, AuthError::throttled)); + CHECK(token_error({503, ""}, AuthError::service_unavailable)); + CHECK(token_error({400, R"({"error":"unauthorized_client"})"}, AuthError::denied)); + CHECK(token_error({200, token_json("acc", "")}, AuthError::invalid_response)); + CHECK(token_error({200, token_json("a c", "ref")}, AuthError::invalid_response)); + CHECK(token_error({200, token_json("acc", "ref", 0)}, AuthError::invalid_response)); + CHECK(token_error({200, "not json"}, AuthError::invalid_response)); + + // Grant replies: the JSON must agree with the grant's own claims. + const auto g = grant_bytes(7, 4, now_s + 600); + const auto grant = auth_grant({200, grant_json(g, 4, now_s + 600)}, now_s); + CHECK(grant && grant->bytes == g && grant->region == 4 && grant->expires_at == now_s + 600 && + grant->account == account_text && grant->endpoint == "void.example.test:7400" && + grant->server_name == "void.example.test"); + const auto grant_error = [](const AuthHttpReply& reply, AuthError expected) { + const auto result = auth_grant(reply, now_s); + return !result && result.error() == expected; + }; + CHECK(grant_error({200, grant_json(g, 5, now_s + 600)}, AuthError::invalid_response)); + CHECK(grant_error({200, grant_json(g, 4, now_s + 601)}, AuthError::invalid_response)); + CHECK(grant_error({200, grant_json(g, 4, now_s + 600, "11111111-2222-3333-4444-555555555556")}, + AuthError::invalid_response)); + const auto expired = grant_bytes(7, 4, now_s); + CHECK(grant_error({200, grant_json(expired, 4, now_s)}, AuthError::invalid_response)); + const auto too_long = grant_bytes(7, 4, now_s + 901); + CHECK(grant_error({200, grant_json(too_long, 4, now_s + 901)}, AuthError::invalid_response)); + auto stage = g; + stage[18] = 2; + CHECK(grant_error({200, grant_json(stage, 4, now_s + 600)}, AuthError::invalid_response)); + auto unserialed = grant_bytes(0, 4, now_s + 600); + CHECK(grant_error({200, grant_json(unserialed, 4, now_s + 600)}, AuthError::invalid_response)); + auto truncated = grant_json(g, 4, now_s + 600); + truncated.erase(truncated.find("==\""), 2); + CHECK(grant_error({200, truncated}, AuthError::invalid_response)); + CHECK(grant_error({401, R"({"error":"email_not_verified"})"}, AuthError::email_unverified)); + CHECK(grant_error({401, R"({"error":"token_expired"})"}, AuthError::token_expired)); + CHECK(grant_error({429, R"({"error":"too_many_requests"})"}, AuthError::throttled)); + CHECK(grant_error({503, R"({"error":"unavailable"})"}, AuthError::service_unavailable)); + for (int e = 0; e <= static_cast(AuthError::logout_incomplete); ++e) + CHECK(!auth_error_text(static_cast(e)).empty()); +} + +// A scripted platform: replies are queued per endpoint and every request is recorded. +struct Script { + std::mutex mutex; + std::map> replies; + std::vector> sent; // Body or bearer. + std::string stored; + bool save_fails{}, block_authorize{}; + int authorizations{}; +}; +class FakePlatform final : public AuthPlatform { + public: + explicit FakePlatform(Script& script) : s_{script} {} + std::expected authorize(std::stop_token stop) override { + { + std::lock_guard lock{s_.mutex}; + ++s_.authorizations; + } + while (s_.block_authorize && !stop.stop_requested()) + std::this_thread::sleep_for(5ms); + if (stop.stop_requested()) + return std::unexpected{AuthError::cancelled}; + return AuthorizationCode{"the-code", "the-verifier"}; + } + std::expected post(AuthEndpoint endpoint, std::string_view body, + std::string_view bearer, + std::stop_token) override { + std::lock_guard lock{s_.mutex}; + s_.sent.emplace_back(endpoint, bearer.empty() ? std::string(body) : std::string(bearer)); + auto& queue = s_.replies[endpoint]; + if (queue.empty()) + return std::unexpected{AuthError::transport}; + auto reply = queue.front(); + queue.pop_front(); + return reply; + } + std::expected load_refresh() override { + std::lock_guard lock{s_.mutex}; + return s_.stored; + } + bool save_refresh(std::string_view token) override { + std::lock_guard lock{s_.mutex}; + if (s_.save_fails) + return false; + s_.stored = token; + return true; + } + bool erase_refresh() override { + std::lock_guard lock{s_.mutex}; + s_.stored.clear(); + return true; + } + + private: + Script& s_; +}; +AuthStatus settle(const AuthClient& client) { + for (int i = 0; i < 1000; ++i) { + const auto status = client.status(); + if (!status.busy) + return status; + std::this_thread::sleep_for(5ms); + } + throw std::runtime_error("client auth worker did not settle"); +} +std::uint64_t utc_now() { + return static_cast(std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count()); +} +AuthHttpReply live_grant(std::uint64_t serial) { + const auto expires = utc_now() + 600; + return {200, grant_json(grant_bytes(serial, 4, expires), 4, expires)}; +} + +void client_tests() { + { + AuthClient unsupported{nullptr}; + CHECK(!unsupported.status().supported && !unsupported.sign_in()); + } + { + // First login: browser code with PKCE, tokens saved, then a grant. + Script s; + s.replies[AuthEndpoint::token].push_back({200, token_json("access-1", "refresh-1")}); + s.replies[AuthEndpoint::grant].push_back(live_grant(1)); + AuthClient client{std::make_unique(s)}; + CHECK(client.status().supported && !client.request_grant()); // Not signed in. + CHECK(client.sign_in()); + CHECK(!client.sign_in()); // One job at a time. + auto status = settle(client); + CHECK(status.phase == AuthPhase::ready && status.signed_in && !status.error); + CHECK(s.authorizations == 1 && s.stored == "refresh-1"); + CHECK(s.sent.size() == 2 && s.sent[0].first == AuthEndpoint::token && + s.sent[0].second.find("grant_type=authorization_code") != std::string::npos && + s.sent[0].second.find("code=the-code") != std::string::npos && + s.sent[0].second.find("code_verifier=the-verifier") != std::string::npos); + CHECK(s.sent[1] == std::pair{AuthEndpoint::grant, std::string{"access-1"}}); + const auto grant = client.take_grant(); + CHECK(grant && grant->account == account_text && !client.take_grant()); + + // Next grant reuses the access token; a different account is refused. + s.replies[AuthEndpoint::grant].push_back(live_grant(2)); + CHECK(client.request_grant()); + CHECK(settle(client).phase == AuthPhase::ready && client.take_grant()); + auto other = live_grant(3); + other.body.replace(other.body.find(account_text), account_text.size(), + "99999999-2222-3333-4444-555555555555"); + s.replies[AuthEndpoint::grant].push_back(other); + CHECK(client.request_grant()); + status = settle(client); + CHECK(status.phase == AuthPhase::failed && status.error == AuthError::invalid_response && + !client.take_grant()); + + // Logout: broker revocation with the access token, then the refresh token revoked. + s.replies[AuthEndpoint::logout].push_back({200, R"({"revoked":true})"}); + s.replies[AuthEndpoint::revoke].push_back({200, ""}); + CHECK(client.sign_out()); + status = settle(client); + CHECK(status.phase == AuthPhase::signed_out && !status.signed_in && !status.error); + CHECK(s.stored.empty()); + CHECK(s.sent[s.sent.size() - 2] == + std::pair{AuthEndpoint::logout, std::string{"access-1"}}); + CHECK(s.sent.back().first == AuthEndpoint::revoke && + s.sent.back().second.find("token=refresh-1") != std::string::npos); + } + { + // A saved login rotates its refresh token without the browser. + Script s; + s.stored = "saved"; + s.replies[AuthEndpoint::token].push_back({200, token_json("access-2", "rotated")}); + s.replies[AuthEndpoint::grant].push_back(live_grant(1)); + AuthClient client{std::make_unique(s)}; + CHECK(client.sign_in()); + CHECK(settle(client).signed_in && s.authorizations == 0 && s.stored == "rotated"); + CHECK(s.sent[0].second.find("grant_type=refresh_token") != std::string::npos && + s.sent[0].second.find("refresh_token=saved") != std::string::npos); + } + { + // A revoked saved login falls back to the browser. + Script s; + s.stored = "revoked"; + s.replies[AuthEndpoint::token].push_back({400, R"({"error":"invalid_grant"})"}); + s.replies[AuthEndpoint::token].push_back({200, token_json("access-3", "fresh")}); + s.replies[AuthEndpoint::grant].push_back(live_grant(1)); + AuthClient client{std::make_unique(s)}; + CHECK(client.sign_in()); + CHECK(settle(client).signed_in && s.authorizations == 1 && s.stored == "fresh"); + } + { + // Logout that the broker cannot confirm still signs out locally, and says so. + Script s; + s.replies[AuthEndpoint::token].push_back({200, token_json("a", "r")}); + s.replies[AuthEndpoint::grant].push_back(live_grant(1)); + AuthClient client{std::make_unique(s)}; + CHECK(client.sign_in() && settle(client).signed_in); + s.replies[AuthEndpoint::revoke].push_back({200, ""}); // No logout reply: transport. + CHECK(client.sign_out()); + const auto status = settle(client); + CHECK(!status.signed_in && status.error == AuthError::logout_incomplete && + s.stored.empty()); + } + { + // Unverified email: signed in, but no grant. + Script s; + s.replies[AuthEndpoint::token].push_back({200, token_json("a", "r")}); + s.replies[AuthEndpoint::grant].push_back({401, R"({"error":"email_not_verified"})"}); + AuthClient client{std::make_unique(s)}; + CHECK(client.sign_in()); + const auto status = settle(client); + CHECK(status.phase == AuthPhase::failed && status.error == AuthError::email_unverified && + status.signed_in && !client.take_grant()); + } + { + // The credential store refusing the new refresh token fails the sign-in. + Script s; + s.save_fails = true; + s.replies[AuthEndpoint::token].push_back({200, token_json("a", "r")}); + AuthClient client{std::make_unique(s)}; + CHECK(client.sign_in()); + const auto status = settle(client); + CHECK(status.error == AuthError::credential_store && !status.signed_in); + } + { + // Cancel while the browser is open; destruction while waiting also joins. + Script s; + s.block_authorize = true; + AuthClient client{std::make_unique(s)}; + CHECK(client.sign_in()); + std::this_thread::sleep_for(20ms); + CHECK(client.status().busy && client.status().phase == AuthPhase::signing_in); + client.cancel(); + const auto status = settle(client); + CHECK(status.phase == AuthPhase::failed && status.error == AuthError::cancelled && + !status.signed_in); + AuthClient abandoned{std::make_unique(s)}; + CHECK(abandoned.sign_in()); + } +} +} // namespace + +int main() { + try { + protocol_tests(); + client_tests(); + std::puts("client auth passed"); + return 0; + } catch (const std::exception& e) { + std::fprintf(stderr, "%s\n", e.what()); + return 1; + } +}