#pragma once #include "evo/network/session_grant.hpp" #include #include #include #include #include #include #include #include // M10.3 backend identity adapter (ADR-0091). An identity provider authenticates an // external credential to a provider subject; the account directory maps subjects to // provider-independent AccountIds and orders their grants; the issuer signs short-lived // region-scoped session grants. Library only: no service, no Steam. Production // providers plug in behind IdentityProvider later. Credentials are never stored or // logged here. namespace evo::identity { using network::AccountId; using network::DeploymentEnvironment; enum class ProviderKind : std::uint8_t { dev_test = 1 }; struct ProviderSubject { ProviderKind provider{}; std::string subject; // Provider-scoped, 1..128 bytes; never an account id. auto operator<=>(const ProviderSubject&) const = default; }; enum class IdentityError : std::uint8_t { not_dev_environment, wrong_environment, unauthenticated, invalid_request, directory_full, serial_exhausted, signing }; class IdentityProvider { public: IdentityProvider() = default; IdentityProvider(const IdentityProvider&) = delete; IdentityProvider& operator=(const IdentityProvider&) = delete; virtual ~IdentityProvider() = default; [[nodiscard]] virtual DeploymentEnvironment environment() const noexcept = 0; [[nodiscard]] virtual std::expected authenticate(std::span credential) = 0; protected: IdentityProvider(IdentityProvider&&) = default; IdentityProvider& operator=(IdentityProvider&&) = default; }; // Dev-only test identities: the credential "dev-test:" (name 1..32 of [a-z0-9-]) // authenticates as that name without any secret. It cannot be created outside dev. class DevTestProvider final : public IdentityProvider { public: [[nodiscard]] static std::expected create(DeploymentEnvironment environment); [[nodiscard]] DeploymentEnvironment environment() const noexcept override { return DeploymentEnvironment::dev; } [[nodiscard]] std::expected authenticate(std::span credential) override; private: DevTestProvider() = default; }; // Serial and issue time of the next grant for an account: both non-decreasing, serial // strictly increasing (regions rely on this to bound how long serials are remembered). struct GrantSequence { std::uint64_t serial{}, issued_at{}; }; class AccountDirectory { public: AccountDirectory() = default; AccountDirectory(const AccountDirectory&) = delete; AccountDirectory& operator=(const AccountDirectory&) = delete; virtual ~AccountDirectory() = default; // The subject's account, created with a fresh random id on first sight. [[nodiscard]] virtual std::expected resolve(const ProviderSubject& subject) = 0; [[nodiscard]] virtual std::expected next_grant(const AccountId& account, std::uint64_t now_seconds) = 0; protected: AccountDirectory(AccountDirectory&&) = default; AccountDirectory& operator=(AccountDirectory&&) = default; }; // Bounded in-memory directory for tests and local tools; not durable. class MemoryAccountDirectory final : public AccountDirectory { public: explicit MemoryAccountDirectory(std::size_t max_accounts) : max_accounts_{max_accounts} {} [[nodiscard]] std::expected resolve(const ProviderSubject& subject) override; [[nodiscard]] std::expected next_grant(const AccountId& account, std::uint64_t now_seconds) override; private: std::size_t max_accounts_; std::map subjects_; std::map sequences_; }; class GrantIssuer { public: // The provider and signing key must belong to the same environment. Lifetime is // 1..14400 s; regions refuse lifetimes above their own maximum (300 s by default). [[nodiscard]] static std::expected create(network::GrantSigningKey key, IdentityProvider& provider, AccountDirectory& directory, std::uint64_t lifetime_seconds); [[nodiscard]] std::expected issue(std::span credential, world::WorldIdentity world, std::uint64_t region, std::uint64_t now_seconds); private: GrantIssuer(network::GrantSigningKey key, IdentityProvider& provider, AccountDirectory& directory, std::uint64_t lifetime) : key_{std::move(key)}, provider_{&provider}, directory_{&directory}, lifetime_{lifetime} {} network::GrantSigningKey key_; IdentityProvider* provider_; AccountDirectory* directory_; std::uint64_t lifetime_; }; } // namespace evo::identity