Files
aevolution/include/evo/client/auth.hpp
T
dingoandClaude Opus 5.5 2a5c0d0e22
Foundation / checks (ecs) (push) Successful in 2m21s
Foundation / checks (deploy) (push) Successful in 4m1s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (tsan) (push) Canceled after 7m21s
Foundation / checks (network) (push) Canceled after 9m43s
Foundation / checks (checks) (push) Canceled after 9m49s
Foundation / checks (postgres) (push) Canceled after 9m43s
Foundation / checks (client) (push) Canceled after 9m48s
ADR-0131: Keycloak sign-in in the Windows engineering client
Sign In / Register opens the system browser (PKCE S256, loopback 127.0.0.1:47600)
and keeps the refresh token in Windows Credential Manager. The client then fetches
a 10-minute grant from grants.aeternalisgames.com and connects to the cellular DEV
region. It renews the grant about a minute before expiry through SessionRefresh,
and again after a lost connection. Sign Out closes the session and revokes the
login at the broker and at Keycloak. Grant replies are cross-checked against the
grant record before use. The manual grant-bundle path stays for developers.

The bounded JSON reader moves to evo_json (evo::serialization), shared by the
broker and the client. Adds the client-auth tests. Completes work started in
another session: main.cpp wiring, refresh expiry tracking, no requests for a
superseded session, and clang-tidy and Windows header-order fixes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 15:31:33 -04:00

110 lines
3.9 KiB
C++

#pragma once
#include "evo/client/launcher.hpp"
#include <chrono>
#include <cstdint>
#include <expected>
#include <memory>
#include <optional>
#include <span>
#include <stop_token>
#include <string>
#include <string_view>
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<AuthorizationCode, AuthError>
authorize(std::stop_token stop) = 0;
[[nodiscard]] virtual std::expected<AuthHttpReply, AuthError> post(AuthEndpoint endpoint,
std::string_view body,
std::string_view bearer,
std::stop_token stop) = 0;
[[nodiscard]] virtual std::expected<std::string, AuthError> load_refresh() = 0;
[[nodiscard]] virtual bool save_refresh(std::string_view token) = 0;
[[nodiscard]] virtual bool erase_refresh() = 0;
};
[[nodiscard]] std::unique_ptr<AuthPlatform> native_auth_platform(); // Windows; null elsewhere.
[[nodiscard]] std::string auth_form_escape(std::string_view value);
[[nodiscard]] std::string auth_base64url(std::span<const std::uint8_t> 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<std::string, AuthError> auth_callback(std::string_view target,
std::string_view state);
[[nodiscard]] std::expected<AuthTokens, AuthError> auth_tokens(const AuthHttpReply& reply);
[[nodiscard]] std::expected<AuthGrant, AuthError> 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<AuthError> 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<AuthPlatform> 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<AuthGrant> take_grant();
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
} // namespace evo::client