diff --git a/CLAUDE.md b/CLAUDE.md index a20a6c3d..d8f5f6bf 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -195,7 +195,7 @@ spec for each is `docs/requirements/Component-.md`, and `README.md` carrie - Authentication: direct LDAP bind (username/password), no Kerberos/NTLM. LDAPS/StartTLS required. - Two session models: the **UI** uses an HttpOnly/Secure cookie carrying a data-protected claims ticket (no embedded JWT; shared Data Protection keys; 30-minute idle timeout, DB-only role re-map every 15 min); the **CLI/API** exchanges credentials once per invocation at `POST /auth/token` for a 15-minute HS256 **bearer** JWT (`JwtSigningKey`, >= 32 bytes, shared by both centrals; `management_bearer: true` capability flag; Basic stays as fallback). Bearer roles are authoritative until expiry (revocation lag <= `JwtExpiryMinutes`; rotating the key kills every token). Cookies are the correct transport for Blazor Server (SignalR circuits). Spec: `Component-Security.md`. - LDAP failure: new logins fail; active sessions continue with current roles. -- **No role, no login (ScadaBridge#144, 2026-11-17).** `/auth/login` and `/auth/token` refuse a bind whose groups map to zero roles (or whose role mapping throws) with the exact bad-password response + a throttle failure; the reason is logged server-side only. A cookie session whose refresh maps to zero roles is ended (`CookieSessionValidator` → Reject). HTTP Basic on the management surfaces is not covered yet (follow-up). Spec: `Component-Security.md` *No role, no login*. +- **No role, no login (ScadaBridge#144/#145, 2026-11-17).** `/auth/login` and `/auth/token` refuse a bind whose groups map to zero roles (or whose role mapping throws) with the exact bad-password response + a throttle failure; the reason is logged server-side only. A cookie session whose refresh maps to zero roles is ended (`CookieSessionValidator` → Reject). The management/CLI surfaces (`/management`, `/api/audit/*`, `/hubs/debug-stream`) refuse the same way in `ManagementAuthenticator` (ScadaBridge#145): a zero-role or mapper-fault Basic bind gets the bad-password 401 + a throttle failure, and a bearer token with no role claim gets the invalid-token 401. Spec: `Component-Security.md` *No role, no login*. - Load balancer in front of central UI; cookie-embedded JWT + shared Data Protection keys for failover transparency. - Two-person MxGateway secured writes (M7): two new global roles — `Operator` (initiates) + `Verifier` (approves) — added alongside the canonical `Administrator`/`Designer`/`Deployer`/`Viewer`, with `RequireOperator`/`RequireVerifier` policies. An Operator submits a secured write from the Central UI Secured Writes page (`/operations/secured-writes`); it stays a `Pending` `PendingSecuredWrite` row until a *distinct* Verifier approves it (no-self-approval enforced server-side in the ManagementActor, plus a compare-and-swap race guard). Approval relays a `WriteTagRequest` to the site MxGateway; MxGateway-protocol connections only; each lifecycle event (submit/approve/reject/execute) emits a best-effort `AuditChannel.SecuredWrite` / `AuditKind.SecuredWrite*` central-direct-write row sharing the row id as `CorrelationId`. (SecuredWrite audit rows stamp `SourceNode` via `ICentralAuditWriter`/`INodeIdentityProvider`.) Pending secured writes expire server-side after a configurable TTL (`ManagementServiceOptions.SecuredWritePendingTtl`, default 24 h): an overdue `Pending` row is CAS'd to `Expired` (never relayed) — enforced at approve/reject and swept opportunistically on list (arch-review S2, `AuditKind.SecuredWriteExpire`). - **Inbound API key store — per node by default, shared on central pairs (2026-09-02, register row 108).** The shared `ZB.MOM.WW.Auth.ApiKeys` library stores inbound keys in **SQLite per node** unless `ScadaBridge:InboundApi:ApiKeyStore:Provider=SqlServer`, which points both central nodes at the same `zbauth` schema in the configuration database (library `ZB.MOM.WW.Auth.ApiKeys.SqlServer` 0.3.0) — under `SqlServer`, create/revoke/rotate/scope changes are cluster-wide immediately; a node's existing SQLite file is imported once at boot (insert-where-absent, safe on both nodes of a pair) and renamed `*.imported`. Central pairs **MUST** run `Provider=SqlServer` — a clustered Central left on `Sqlite` boots fine but `StartupValidator` logs a Warning, because a failover otherwise 401s every inbound client until keys are re-issued on the survivor. Both docker rigs (`docker/`, `docker-env2/`) run `SqlServer`; QA (`vq03`/`vq04`) runs `SqlServer` for both inbound keys and secrets since 2026-10-22 (deployment record `2026-10-22-wonder-app-vq03-vq04-3808b49f.md`); DEV (`vd03`, single node — not production) is not switched. The boot import's `*.imported` rename needs the importer's pooled SQLite handle released first — Windows refuses to rename an open file (fixed `6ed6800b`; pre-fix Windows builds need the manual rename in the runbook). Design: `docs/plans/2026-09-02-inbound-api-key-shared-store-design.md`; runbook: `docs/operations/inbound-api-key-reissue.md` → *Central pairs*. diff --git a/docs/requirements/Component-CLI.md b/docs/requirements/Component-CLI.md index 1b6008fd..0a07e74f 100644 --- a/docs/requirements/Component-CLI.md +++ b/docs/requirements/Component-CLI.md @@ -547,7 +547,7 @@ file/stdin forms for any value that carries a key or password. - **Connection failure**: If the CLI cannot connect to the management URL (e.g., DNS failure, connection refused), it exits with code 1 and a descriptive error message. - **Command timeout**: Ordinary CLI commands use a 30-second client deadline. All instance/artifact/site deployment aliases defer the overall deadline to the server, retaining a bounded socket-connect timeout. Server Ask expiry returns HTTP 504; a client deadline is reported locally. Bundle and Flow Debugger commands retain their explicit timeout policies. -- **Authentication failure**: If the server returns HTTP 401 (LDAP bind failed at `/auth/token` or on a Basic call, or a bearer token that a fresh exchange could not replace), the CLI exits with code 1. +- **Authentication failure**: If the server returns HTTP 401 (LDAP bind failed at `/auth/token` or on a Basic call, or a bearer token that a fresh exchange could not replace), the CLI exits with code 1. A user whose directory groups map to no ScadaBridge role gets the same `401` "Invalid username or password." as a wrong password, from `/auth/token` and on a Basic call alike — the server does not reveal which it was (ScadaBridge#144/#145; `Component-Security.md` *No role, no login*). Check the user's group mappings when valid credentials are refused. - **Authorization failure**: If the server returns HTTP 403, the CLI exits with code 2. ## Dependencies diff --git a/docs/requirements/Component-ManagementService.md b/docs/requirements/Component-ManagementService.md index fe486a42..7fb8a9d4 100644 --- a/docs/requirements/Component-ManagementService.md +++ b/docs/requirements/Component-ManagementService.md @@ -65,7 +65,7 @@ Content-Type: application/json - `ManagementSuccess` → HTTP 200 with JSON body - `ManagementError` → HTTP 400 with `{ "error": "...", "code": "..." }` - `ManagementUnauthorized` → HTTP 403 with `{ "error": "...", "code": "UNAUTHORIZED" }` -- Authentication failure → HTTP 401 +- Authentication failure → HTTP 401 (including a caller whose groups map to no role, or a bearer token with no role claim — `Component-Security.md` *No role, no login*) - Actor timeout → HTTP 504 - Large request while another is in flight → HTTP 409 with `{ "error": "...", "code": "IMPORT_IN_PROGRESS" }` (see below) diff --git a/docs/requirements/Component-Security.md b/docs/requirements/Component-Security.md index b4513096..7e9270a6 100644 --- a/docs/requirements/Component-Security.md +++ b/docs/requirements/Component-Security.md @@ -32,7 +32,7 @@ Central cluster. Sites do not have user-facing interfaces and do not perform ind Set in a local or docker-dev environment via the environment variable `ScadaBridge__Security__Auth__DisableLogin=true`. Note that `ScadaBridge:Security:Auth` is a child sub-section nested inside `ScadaBridge:Security`. -## No role, no login (ScadaBridge#144) +## No role, no login (ScadaBridge#144, #145) A successful LDAP bind is **not** enough to sign in: the user's groups must map to **at least one** ScadaBridge role. This is the family standard (scadaproj NAM AD cutover plan §3.2), and it matters once the LDAP search base is domain-wide — without it, any directory user could sign in role-less and read the bare-`[Authorize]` pages (`/` and `/monitoring/health`). @@ -40,7 +40,10 @@ A successful LDAP bind is **not** enough to sign in: the user's groups must map - **Indistinguishable from a bad password.** The client gets exactly the bad-credentials response — `/auth/login` redirects to `/login?error=Invalid username or password.` with no session cookie; `/auth/token` answers `401` `{ error: "Invalid username or password.", code: "AUTH_FAILED" }` with no token. The refusal also **counts as a login-throttle failure**, so the throttle cannot be used to tell "right password, no role" from "wrong password". - **Logged server-side only.** Each refusal is logged at Warning (category `ZB.MOM.WW.ScadaBridge.CentralUI.Auth.AuthEndpoints`) with the endpoint, the username and the reason (no mapped role, with the group count; or the mapping exception). There is no login audit event in the Audit Log — sign-in success and failure are not audited today — so the log line is the record. - **Sessions end the same way.** A cookie session whose groups map to zero roles on a refresh is ended (see *Cookie session lifecycle*). -- **HTTP Basic is not covered yet.** `ManagementAuthenticator`'s Basic branch (`POST /management`, the audit REST endpoints, the debug-stream hub) still authenticates a zero-role bind. Role-gated commands deny it, but the read-only management queries that `ManagementActor.GetRequiredRoles` opens to *any authenticated user* answer it. Closing that is a follow-up to ScadaBridge#144. +- **The management/CLI surfaces refuse too (ScadaBridge#145).** `ManagementAuthenticator` is the only source of the caller's identity for `POST /management`, the audit REST endpoints (`/api/audit/*`) and the debug-stream hub (`/hubs/debug-stream`), so the rule is enforced once there and covers all three — including the read-only commands `ManagementActor.GetRequiredRoles` opens to *any authenticated user*, which a zero-role caller would otherwise reach. + - **HTTP Basic:** a bind whose groups map to zero roles, or whose role mapping throws, answers exactly what a bad password answers on that surface — `401` `{ error: "Invalid username or password.", code: "AUTH_FAILED" }` (the hub aborts the connection) — and counts as a login-throttle failure; a refusal no longer clears earlier failures the way a successful bind does. + - **Bearer:** a token with no role claim is refused with the invalid-token response, `401` `{ error: "Invalid or expired bearer token.", code: "AUTH_FAILED" }`. `/auth/token` no longer mints such a token, but one minted before the rule shipped stays signed and unexpired for up to `JwtExpiryMinutes`. Like every bearer failure it involves no LDAP bind, so it does not feed the login throttle. A bearer request performs no role mapping, so a mapper fault does not affect it. + - Each refusal is logged at Warning (category `ZB.MOM.WW.ScadaBridge.ManagementService.ManagementAuthenticator`) with the endpoint (request path), the username and the reason. - Under the dev/test `DisableLogin` flag none of this runs: the auto-login identity holds every role. ## Session Management @@ -55,7 +58,7 @@ A successful LDAP bind is **not** enough to sign in: the user's groups must map - `POST /auth/token` (form `username`/`password`) performs the LDAP bind (login-throttled), maps the groups to roles and site scope (zero roles, or a mapping fault, is refused as a bad password — *No role, no login* above), and returns a short-lived **HS256 JWT** signed with `SecurityOptions.JwtSigningKey`, shared by both central nodes: `{ access_token, token_type: "Bearer", expires_in, management_bearer: true, username, display_name, roles }`. - **JWT claims**: display name, username, roles, and for a site-scoped Deployer the permitted site IDs (no site claims = system-wide, the same normalisation the Basic path uses). Issuer and audience are both fixed to `scadabridge-central`. Lifetime is `JwtExpiryMinutes` (default **15**). - `ManagementAuthenticator` accepts `Authorization: Bearer ` alongside HTTP Basic on every CLI-facing surface: `POST /management`, the audit REST endpoints, and the debug-stream hub (`/hubs/debug-stream`, token in the `Authorization` header of the negotiate request and WebSocket upgrade). Validation checks the HS256 signature, issuer, audience and lifetime (30 s clock skew for node-to-node drift; `nbf` is back-dated by the same skew so a peer whose clock lags the issuer accepts a fresh token after failover); unsigned (`alg=none`) or other-algorithm tokens are rejected, and a failure is a plain `401 AUTH_FAILED` (no LDAP bind, so it does not feed the login throttle). The token is never logged. -- **Roles and scope inside a valid token are authoritative for its lifetime**: a bearer request performs no LDAP bind and no role re-map. A role revocation therefore reaches a bearer caller when its token expires (≤ `JwtExpiryMinutes`); rotating `JwtSigningKey` invalidates every outstanding token immediately. +- **Roles and scope inside a valid token are authoritative for its lifetime**: a bearer request performs no LDAP bind and no role re-map. A token that carries no role claim is refused (*No role, no login* above). A role revocation therefore reaches a bearer caller when its token expires (≤ `JwtExpiryMinutes`); rotating `JwtSigningKey` invalidates every outstanding token immediately. - The CLI exchanges credentials once per process, keeps the token in memory only, re-exchanges once on a `401`, and falls back to HTTP Basic when the server has no bearer support — see `Component-CLI.md`. HTTP Basic stays supported on every surface. - Under the dev/test `DisableLogin` flag `/auth/token` answers `404`: the management surfaces already authenticate every request as the dev user, and no credential-free token is minted that another deployment sharing the key might honour. - **Signing key**: `StartupValidator` refuses to boot a Central node whose `JwtSigningKey` is missing or shorter than **32 UTF-8 bytes** (256 bits, the HMAC-SHA256 floor). `JwtTokenService` repeats the length check at construction as defence in depth. diff --git a/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementAuthenticator.cs b/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementAuthenticator.cs index 56375a67..504f2a98 100644 --- a/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementAuthenticator.cs +++ b/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementAuthenticator.cs @@ -1,6 +1,8 @@ using System.Text; using Microsoft.AspNetCore.Http; using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Options; using ZB.MOM.WW.Auth.Abstractions.Ldap; using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management; @@ -42,9 +44,24 @@ namespace ZB.MOM.WW.ScadaBridge.ManagementService; /// ). The startup AUTH DISABLED warning /// (emitted by AddSecurity) already announces this posture. Dev/test ONLY. /// +/// +/// No role, no login (ScadaBridge#145, the management-surface half of #144; scadaproj NAM +/// cutover plan §3.2): a Basic bind whose groups map to zero roles, or whose role mapping throws, +/// is refused exactly like a bad password — the same 401 AUTH_FAILED body and a +/// failure — and a bearer token that carries no role claim is refused +/// like any other invalid token. Every refusal is logged at Warning under +/// with the endpoint, the username and the reason. Because the three +/// callers (, , the debug-stream hub) +/// take their only from here, none of them can admit a role-less +/// principal — including the commands ManagementActor.GetRequiredRoles opens to any +/// authenticated user. +/// /// public static class ManagementAuthenticator { + /// The logger category for the sign-in refusals logged by this authenticator. + public const string LoggerCategory = "ZB.MOM.WW.ScadaBridge.ManagementService.ManagementAuthenticator"; + /// Outcome of : exactly one of the two fields is set. /// The authenticated principal on success; otherwise . /// The 401 to return on failure; otherwise . @@ -143,11 +160,19 @@ public static class ManagementAuthenticator new { error = LdapAuthFailureMessages.ToMessage(authResult.Failure), code = "AUTH_FAILED" }, statusCode: 401)); } - throttle.RecordSuccess(username, remoteIp!); + // 3. Role resolution. No role, no login (ScadaBridge#145, mirrors #144's /auth/login and + // /auth/token): a successful bind whose groups map to zero roles — or whose mapping + // throws — is refused exactly like a bad password: same 401 body, a throttle failure. + // The reason is logged server-side only. + var mappingResult = await ResolveBasicRolesAsync(context, authResult, username); + if (mappingResult is null) + { + throttle.RecordFailure(username, remoteIp!); + return new AuthOutcome(null, Results.Json( + new { error = LdapAuthFailureMessages.InvalidCredentials, code = "AUTH_FAILED" }, statusCode: 401)); + } - // 3. Role resolution - var roleMapper = context.RequestServices.GetRequiredService(); - var mappingResult = await roleMapper.MapGroupsToRolesAsync(authResult.Groups, context.RequestAborted); + throttle.RecordSuccess(username, remoteIp!); var permittedSiteIds = mappingResult.IsSystemWideDeployment ? Array.Empty() @@ -162,10 +187,67 @@ public static class ManagementAuthenticator return new AuthOutcome(resolvedUser, null); } + /// + /// Maps a successful Basic bind's groups to roles, enforcing no role, no login + /// (ScadaBridge#145). Returns — the caller then answers exactly as for a + /// bad password — when the groups map to zero roles or the mapper throws; the refusal is logged + /// at Warning with the endpoint, the username and the reason. Cancellation of the request is not + /// a refusal and propagates. + /// + /// The current HTTP context (services, request path, request-aborted token). + /// The successful LDAP bind result. + /// The username as sent, used when the bind returned no canonical name. + /// The role mapping, or when the request must be refused. + private static async Task ResolveBasicRolesAsync( + HttpContext context, LdapAuthResult authResult, string username) + { + var logger = Logger(context); + var endpoint = EndpointName(context); + var who = string.IsNullOrEmpty(authResult.Username) ? username : authResult.Username; + + RoleMappingResult mappingResult; + try + { + var roleMapper = context.RequestServices.GetRequiredService(); + mappingResult = await roleMapper.MapGroupsToRolesAsync(authResult.Groups, context.RequestAborted); + } + catch (OperationCanceledException) when (context.RequestAborted.IsCancellationRequested) + { + throw; + } + catch (Exception ex) + { + logger.LogWarning(ex, + "Sign-in refused at {Endpoint} for {Username}: the LDAP bind succeeded but role mapping failed. " + + "The client sees the bad-credentials response.", + endpoint, who); + return null; + } + + if (mappingResult.Roles is not { Count: > 0 }) + { + logger.LogWarning( + "Sign-in refused at {Endpoint} for {Username}: the LDAP bind succeeded but none of the user's {GroupCount} " + + "group(s) maps to a ScadaBridge role. The client sees the bad-credentials response.", + endpoint, who, authResult.Groups.Count); + return null; + } + + return mappingResult; + } + + private static ILogger Logger(HttpContext context) => + context.RequestServices.GetService()?.CreateLogger(LoggerCategory) ?? NullLogger.Instance; + + private static string EndpointName(HttpContext context) => + context.Request.Path.HasValue ? context.Request.Path.Value! : "management"; + /// /// Validates a bearer JWT and projects its claims onto an . /// The token's roles and site scope are taken as-is (authoritative until expiry); an - /// empty site-id set is the same system-wide signal the Basic path produces. + /// empty site-id set is the same system-wide signal the Basic path produces. A token with + /// no role claim is refused like an invalid token (ScadaBridge#145): /auth/token no + /// longer mints one, but a token minted before that rule shipped stays valid until it expires. /// private static AuthOutcome AuthenticateBearer(HttpContext context, string token) { @@ -181,8 +263,21 @@ public static class ManagementAuthenticator var displayName = principal.FindFirst(JwtTokenService.DisplayNameClaimType)?.Value; var roles = principal.FindAll(JwtTokenService.RoleClaimType) .Select(c => c.Value) + .Where(r => !string.IsNullOrWhiteSpace(r)) .Distinct(StringComparer.OrdinalIgnoreCase) .ToArray(); + + // No role, no login (ScadaBridge#145): the same 401 as an invalid token. Like any other + // bearer failure it performs no LDAP bind, so it does not feed the login throttle. + if (roles.Length == 0) + { + Logger(context).LogWarning( + "Sign-in refused at {Endpoint} for {Username}: the bearer token carries no ScadaBridge role. " + + "The client sees the invalid-token response.", + EndpointName(context), username); + return new AuthOutcome(null, Results.Json( + new { error = "Invalid or expired bearer token.", code = "AUTH_FAILED" }, statusCode: 401)); + } var permittedSiteIds = principal.FindAll(JwtTokenService.SiteIdClaimType) .Select(c => c.Value) .Distinct(StringComparer.Ordinal) diff --git a/tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/CapturingLoggerProvider.cs b/tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/CapturingLoggerProvider.cs new file mode 100644 index 00000000..0ae9183c --- /dev/null +++ b/tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/CapturingLoggerProvider.cs @@ -0,0 +1,37 @@ +using System.Collections.Concurrent; +using Microsoft.Extensions.Logging; + +namespace ZB.MOM.WW.ScadaBridge.ManagementService.Tests; + +/// An in-memory logger provider that records every formatted log line with its category and level. +internal sealed class CapturingLoggerProvider : ILoggerProvider +{ + /// One captured log entry. + /// The logger category. + /// The log level. + /// The formatted message. + /// The logged exception, if any. + public sealed record Entry(string Category, LogLevel Level, string Message, Exception? Exception); + + /// Every entry logged through this provider, in order. + public ConcurrentQueue Entries { get; } = new(); + + /// + public ILogger CreateLogger(string categoryName) => new Logger(categoryName, Entries); + + /// + public void Dispose() + { + } + + private sealed class Logger(string category, ConcurrentQueue sink) : ILogger + { + public IDisposable? BeginScope(TState state) where TState : notnull => null; + + public bool IsEnabled(LogLevel logLevel) => true; + + public void Log(LogLevel logLevel, EventId eventId, TState state, Exception? exception, + Func formatter) => + sink.Enqueue(new Entry(category, logLevel, formatter(state, exception), exception)); + } +} diff --git a/tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/ManagementZeroRoleRefusalTests.cs b/tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/ManagementZeroRoleRefusalTests.cs new file mode 100644 index 00000000..531036f4 --- /dev/null +++ b/tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/ManagementZeroRoleRefusalTests.cs @@ -0,0 +1,531 @@ +using System.Net; +using System.Runtime.CompilerServices; +using System.Text; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Http.Connections.Features; +using Microsoft.AspNetCore.Http.Features; +using Microsoft.AspNetCore.SignalR; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Options; +using NSubstitute; +using NSubstitute.ExceptionExtensions; +using ZB.MOM.WW.Audit; +using ZB.MOM.WW.Auth.Abstractions.Ldap; +using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Audit; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management; +using ZB.MOM.WW.ScadaBridge.Communication; +using ZB.MOM.WW.ScadaBridge.Communication.Grpc; +using ZB.MOM.WW.ScadaBridge.Security; +using ZB.MOM.WW.ScadaBridge.Security.Auth; + +namespace ZB.MOM.WW.ScadaBridge.ManagementService.Tests; + +/// +/// ScadaBridge#145 — the management/CLI surfaces (POST /management, the audit REST endpoints and +/// the debug-stream hub) refuse a principal with no ScadaBridge role, mirroring #144's rule for +/// /auth/login and /auth/token. Over HTTP Basic, a bind whose groups map to zero roles, or +/// whose role mapping throws, is refused exactly like a bad password (same 401 body, a login-throttle +/// failure); over Bearer, a token with no role claim is refused like an invalid token. Each refusal is +/// logged at Warning with the endpoint, the username and the reason. +/// +public class ManagementZeroRoleRefusalTests +{ + private const string Category = ManagementAuthenticator.LoggerCategory; + private const string Key = "this-is-a-test-signing-key-for-hmac-sha256-must-be-long-enough"; + private const string Ip = "10.0.0.7"; + + /// The role outcome the substituted produces. + public enum Mapping + { + /// The groups map to no role. + ZeroRoles, + + /// The mapper throws (e.g. the configuration database is unreachable). + Throws, + + /// The groups map to exactly one role (the one the surface needs). + OneRole, + } + + private sealed class Rig : IDisposable + { + public required ServiceProvider Provider { get; init; } + public required LoginThrottle Throttle { get; init; } + public required CapturingLoggerProvider Logs { get; init; } + public required RoleMapper RoleMapper { get; init; } + + public void Dispose() => Provider.Dispose(); + } + + /// + /// LDAP accepts alice/password (groups ["Domain Users"]) and rejects alice/wrong; the role mapper + /// answers per , with as the single role. + /// + private static Rig BuildRig(Mapping mapping, string oneRole, int maxFailures = 5) + { + var logs = new CapturingLoggerProvider(); + var services = new ServiceCollection(); + services.AddLogging(b => b.AddProvider(logs)); + services.AddSingleton>( + Options.Create(new AuthDisableLoginOptions { DisableLogin = false })); + services.AddSingleton>(Options.Create(new SecurityOptions + { + JwtSigningKey = Key, + JwtExpiryMinutes = 15, + MaxLoginFailuresPerWindow = maxFailures, + PerIpMaxFailures = 25, + })); + services.AddSingleton(TimeProvider.System); + services.AddSingleton(); + services.AddScoped(); + + var ldap = Substitute.For(); + ldap.AuthenticateAsync("alice", "password", Arg.Any()) + .Returns(LdapAuthResult.Success("alice", "Alice", ["Domain Users"])); + ldap.AuthenticateAsync("alice", "wrong", Arg.Any()) + .Returns(LdapAuthResult.Fail(LdapAuthFailure.BadCredentials)); + services.AddSingleton(ldap); + + var roleMapper = Substitute.For(Substitute.For()); + var call = roleMapper.MapGroupsToRolesAsync(Arg.Any>(), Arg.Any()); + switch (mapping) + { + case Mapping.Throws: + call.ThrowsAsync(new InvalidOperationException("configuration database unreachable")); + break; + case Mapping.ZeroRoles: + call.Returns(new RoleMappingResult([], [], IsSystemWideDeployment: false)); + break; + default: + call.Returns(new RoleMappingResult([oneRole], [], IsSystemWideDeployment: true)); + break; + } + services.AddSingleton(roleMapper); + + // /management: no actor → a request that passes authentication and parsing answers 503. + services.AddSingleton(new ManagementActorHolder()); + + var repo = Substitute.For(); + repo.QueryAsync(Arg.Any(), Arg.Any(), Arg.Any()) + .Returns(Task.FromResult>(Array.Empty())); + services.AddSingleton(repo); + + var provider = services.BuildServiceProvider(); + return new Rig + { + Provider = provider, + Throttle = provider.GetRequiredService(), + Logs = logs, + RoleMapper = roleMapper, + }; + } + + private static string Basic(string password) => + "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"alice:{password}")); + + private static string Bearer(params string[] roles) + { + var jwt = new JwtTokenService( + Options.Create(new SecurityOptions { JwtSigningKey = Key, JwtExpiryMinutes = 15 }), + NullLogger.Instance); + return "Bearer " + jwt.GenerateToken("Alice", "alice", roles, null); + } + + private static DefaultHttpContext Request(Rig rig, string path, string authorization) + { + var context = new DefaultHttpContext { RequestServices = rig.Provider }; + context.Request.Path = path; + context.Request.Headers.Authorization = authorization; + context.Connection.RemoteIpAddress = IPAddress.Parse(Ip); + context.Response.Body = new MemoryStream(); + return context; + } + + private static async Task<(int Status, string Body)> Execute(HttpContext context, IResult result) + { + await result.ExecuteAsync(context); + context.Response.Body.Position = 0; + using var reader = new StreamReader(context.Response.Body); + return (context.Response.StatusCode, await reader.ReadToEndAsync()); + } + + private static async Task<(int Status, string Body)> PostManagement(Rig rig, string authorization, string command = "ListSites") + { + var context = Request(rig, "/management", authorization); + context.Request.Method = "POST"; + var body = Encoding.UTF8.GetBytes("{\"command\":\"" + command + "\",\"payload\":{}}"); + context.Request.Body = new MemoryStream(body); + context.Request.ContentLength = body.Length; + return await Execute(context, await ManagementEndpoints.HandleRequest(context)); + } + + private static async Task<(int Status, string Body)> GetAuditQuery(Rig rig, string authorization) + { + var context = Request(rig, "/api/audit/query", authorization); + context.Request.Method = "GET"; + return await Execute(context, await AuditEndpoints.HandleQuery(context)); + } + + /// The 401 body a bad password gets on the same surface — every Basic refusal must match it. + private static async Task<(int Status, string Body)> BadPassword(Func> send, string oneRole) + { + using var rig = BuildRig(Mapping.OneRole, oneRole); + return await send(rig, Basic("wrong")); + } + + private static CapturingLoggerProvider.Entry SingleRefusal(Rig rig) => + Assert.Single(rig.Logs.Entries, e => e.Category == Category && e.Level == LogLevel.Warning); + + private static void AssertBasicRefusalLogged(Rig rig, Mapping mapping, string endpoint) + { + var entry = SingleRefusal(rig); + Assert.Contains("alice", entry.Message); + Assert.Contains(endpoint, entry.Message); + if (mapping == Mapping.Throws) + { + Assert.Contains("role mapping failed", entry.Message); + Assert.IsType(entry.Exception); + } + else + { + Assert.Contains("maps to a ScadaBridge role", entry.Message); + } + } + + private static void AssertNoRefusalLogged(Rig rig) => + Assert.DoesNotContain(rig.Logs.Entries, e => e.Category == Category && e.Level >= LogLevel.Warning); + + // ── POST /management (CLI) ────────────────────────────────────────────────────────────── + + /// The command these tests send is one GetRequiredRoles opens to any authenticated user. + [Fact] + public void ListSites_IsOpenToAnyAuthenticatedUser() + { + Assert.Null(ManagementActor.GetRequiredRoles(new ListSitesCommand())); + } + + /// A zero-role or mapper-fault Basic bind gets the bad-password 401 on a null-role command, and it is logged. + /// The refused mapping outcome. + /// A task that represents the asynchronous operation. + [Theory] + [InlineData(Mapping.ZeroRoles)] + [InlineData(Mapping.Throws)] + public async Task Management_Basic_RefusedLikeABadPassword(Mapping mapping) + { + using var rig = BuildRig(mapping, Roles.Viewer); + + var (status, body) = await PostManagement(rig, Basic("password")); + var badPassword = await BadPassword((r, a) => PostManagement(r, a), Roles.Viewer); + + Assert.Equal(401, status); + Assert.Equal(badPassword, (status, body)); + Assert.Contains("AUTH_FAILED", body); + Assert.Contains(LdapAuthFailureMessages.InvalidCredentials, body); + AssertBasicRefusalLogged(rig, mapping, "/management"); + } + + /// A one-role Basic bind passes authentication and reaches dispatch (503: no actor in the rig). + /// A task that represents the asynchronous operation. + [Fact] + public async Task Management_Basic_OneRole_ReachesDispatch() + { + using var rig = BuildRig(Mapping.OneRole, Roles.Viewer); + + var (status, _) = await PostManagement(rig, Basic("password")); + + Assert.Equal(503, status); + AssertNoRefusalLogged(rig); + } + + /// A bearer token with no role claim is refused with the invalid-token 401, and it is logged. + /// A task that represents the asynchronous operation. + [Fact] + public async Task Management_Bearer_ZeroRoles_Refused() + { + using var rig = BuildRig(Mapping.OneRole, Roles.Viewer); + + var (status, body) = await PostManagement(rig, Bearer()); + var (_, invalidTokenBody) = await PostManagement(rig, "Bearer not-a-token"); + + Assert.Equal(401, status); + Assert.Equal(invalidTokenBody, body); + var entry = SingleRefusal(rig); + Assert.Contains("alice", entry.Message); + Assert.Contains("/management", entry.Message); + Assert.Contains("no ScadaBridge role", entry.Message); + } + + /// + /// Bearer performs no role mapping: a one-role token is accepted even while the mapper throws, and + /// the mapper is never called. (The mapper-fault refusal is a Basic-path rule.) + /// + /// The mapper state, which a bearer request must not consult. + /// A task that represents the asynchronous operation. + [Theory] + [InlineData(Mapping.OneRole)] + [InlineData(Mapping.Throws)] + public async Task Management_Bearer_OneRole_ReachesDispatch_WithoutMapping(Mapping mapping) + { + using var rig = BuildRig(mapping, Roles.Viewer); + + var (status, _) = await PostManagement(rig, Bearer(Roles.Viewer)); + + Assert.Equal(503, status); + AssertNoRefusalLogged(rig); + await rig.RoleMapper.DidNotReceiveWithAnyArgs().MapGroupsToRolesAsync(default!, default); + } + + /// Every management command GetRequiredRoles opens to any authenticated user. + /// The theory data rows of command names. + public static IEnumerable NullRoleCommands() + => typeof(ManagementEnvelope).Assembly.GetTypes() + .Where(t => t.Namespace == typeof(ManagementEnvelope).Namespace + && t.Name.EndsWith("Command", StringComparison.Ordinal) && !t.IsAbstract + && ManagementActor.GetRequiredRoles(RuntimeHelpers.GetUninitializedObject(t)) is null) + .Select(t => new object[] { t.Name[..^"Command".Length] }); + + /// + /// No command open to any authenticated user is reachable by a zero-role principal, over Basic or + /// Bearer: authentication answers 401 before the command is parsed or dispatched. + /// + /// A null-role command name. + /// A task that represents the asynchronous operation. + [Theory, MemberData(nameof(NullRoleCommands))] + public async Task NullRoleCommand_IsNotReachableByAZeroRolePrincipal(string command) + { + using var rig = BuildRig(Mapping.ZeroRoles, Roles.Viewer); + + var (basicStatus, _) = await PostManagement(rig, Basic("password"), command); + var (bearerStatus, _) = await PostManagement(rig, Bearer(), command); + + Assert.Equal(401, basicStatus); + Assert.Equal(401, bearerStatus); + } + + /// A zero-role Basic refusal counts against the login throttle like a bad password. + /// A task that represents the asynchronous operation. + [Fact] + public async Task Management_Basic_ZeroRoles_CountsAsAThrottleFailure() + { + using var rig = BuildRig(Mapping.ZeroRoles, Roles.Viewer, maxFailures: 2); + + await PostManagement(rig, Basic("password")); + await PostManagement(rig, Basic("password")); + + Assert.True(rig.Throttle.IsLockedOut("alice", Ip)); + var (status, body) = await PostManagement(rig, Basic("password")); + Assert.Equal(429, status); + Assert.Contains("AUTH_THROTTLED", body); + } + + /// + /// A refusal does not clear earlier failures the way a successful sign-in does: a bad password + /// followed by a zero-role bind leaves both failures on the throttle. + /// + /// A task that represents the asynchronous operation. + [Fact] + public async Task Management_Basic_ZeroRoles_DoesNotResetTheThrottle() + { + using var rig = BuildRig(Mapping.ZeroRoles, Roles.Viewer, maxFailures: 2); + + await PostManagement(rig, Basic("wrong")); + await PostManagement(rig, Basic("password")); + + Assert.True(rig.Throttle.IsLockedOut("alice", Ip)); + } + + // ── GET /api/audit/query ──────────────────────────────────────────────────────────────── + + /// A zero-role or mapper-fault Basic bind gets the bad-password 401 on an audit query (not a 403), and it is logged. + /// The refused mapping outcome. + /// A task that represents the asynchronous operation. + [Theory] + [InlineData(Mapping.ZeroRoles)] + [InlineData(Mapping.Throws)] + public async Task Audit_Basic_RefusedLikeABadPassword(Mapping mapping) + { + using var rig = BuildRig(mapping, Roles.Administrator); + + var (status, body) = await GetAuditQuery(rig, Basic("password")); + var badPassword = await BadPassword((r, a) => GetAuditQuery(r, a), Roles.Administrator); + + Assert.Equal(401, status); + Assert.Equal(badPassword, (status, body)); + AssertBasicRefusalLogged(rig, mapping, "/api/audit/query"); + } + + /// A one-role Basic bind with an audit role gets the query page. + /// A task that represents the asynchronous operation. + [Fact] + public async Task Audit_Basic_OneRole_Answers() + { + using var rig = BuildRig(Mapping.OneRole, Roles.Administrator); + + var (status, _) = await GetAuditQuery(rig, Basic("password")); + + Assert.Equal(200, status); + AssertNoRefusalLogged(rig); + } + + /// A bearer token with no role claim gets 401 on an audit query (not a 403), and it is logged. + /// A task that represents the asynchronous operation. + [Fact] + public async Task Audit_Bearer_ZeroRoles_Refused() + { + using var rig = BuildRig(Mapping.OneRole, Roles.Administrator); + + var (status, body) = await GetAuditQuery(rig, Bearer()); + + Assert.Equal(401, status); + Assert.Contains("AUTH_FAILED", body); + Assert.Contains("/api/audit/query", SingleRefusal(rig).Message); + } + + /// A one-role bearer token gets the query page without any role mapping, even while the mapper throws. + /// The mapper state, which a bearer request must not consult. + /// A task that represents the asynchronous operation. + [Theory] + [InlineData(Mapping.OneRole)] + [InlineData(Mapping.Throws)] + public async Task Audit_Bearer_OneRole_Answers(Mapping mapping) + { + using var rig = BuildRig(mapping, Roles.Administrator); + + var (status, _) = await GetAuditQuery(rig, Bearer(Roles.Administrator)); + + Assert.Equal(200, status); + AssertNoRefusalLogged(rig); + } + + // ── /hubs/debug-stream ────────────────────────────────────────────────────────────────── + + private static async Task ConnectHub(Rig rig, string authorization) + { + var http = Request(rig, "/hubs/debug-stream", authorization); + var debugStreamService = new DebugStreamService( + new CommunicationService(Options.Create(new CommunicationOptions()), NullLogger.Instance), + new ServiceCollection().BuildServiceProvider(), + new SiteStreamGrpcClientFactory(NullLoggerFactory.Instance), + NullLogger.Instance); + var hub = new DebugStreamHub(debugStreamService, Substitute.For>(), + NullLogger.Instance); + var ctx = new TestHubCallerContext(http); + hub.Context = ctx; + await hub.OnConnectedAsync(); + return ctx; + } + + /// + /// A zero-role or mapper-fault Basic connect is aborted by the shared authenticator — logged as a + /// sign-in refusal and counted as a throttle failure — not merely by the hub's Deployer check. + /// + /// The refused mapping outcome. + /// A task that represents the asynchronous operation. + [Theory] + [InlineData(Mapping.ZeroRoles)] + [InlineData(Mapping.Throws)] + public async Task Hub_Basic_Refused(Mapping mapping) + { + using var rig = BuildRig(mapping, Roles.Deployer, maxFailures: 1); + + var ctx = await ConnectHub(rig, Basic("password")); + + Assert.True(ctx.Aborted); + AssertBasicRefusalLogged(rig, mapping, "/hubs/debug-stream"); + Assert.True(rig.Throttle.IsLockedOut("alice", Ip)); + } + + /// A one-role (Deployer) Basic connect is established. + /// A task that represents the asynchronous operation. + [Fact] + public async Task Hub_Basic_OneRole_Connects() + { + using var rig = BuildRig(Mapping.OneRole, Roles.Deployer); + + var ctx = await ConnectHub(rig, Basic("password")); + + Assert.False(ctx.Aborted); + AssertNoRefusalLogged(rig); + } + + /// A bearer token with no role claim is refused by the shared authenticator, and it is logged. + /// A task that represents the asynchronous operation. + [Fact] + public async Task Hub_Bearer_ZeroRoles_Refused() + { + using var rig = BuildRig(Mapping.OneRole, Roles.Deployer); + + var ctx = await ConnectHub(rig, Bearer()); + + Assert.True(ctx.Aborted); + var entry = SingleRefusal(rig); + Assert.Contains("/hubs/debug-stream", entry.Message); + Assert.Contains("no ScadaBridge role", entry.Message); + } + + /// A one-role (Deployer) bearer connect is established without role mapping, even while the mapper throws. + /// The mapper state, which a bearer request must not consult. + /// A task that represents the asynchronous operation. + [Theory] + [InlineData(Mapping.OneRole)] + [InlineData(Mapping.Throws)] + public async Task Hub_Bearer_OneRole_Connects(Mapping mapping) + { + using var rig = BuildRig(mapping, Roles.Deployer); + + var ctx = await ConnectHub(rig, Bearer(Roles.Deployer)); + + Assert.False(ctx.Aborted); + AssertNoRefusalLogged(rig); + } + + // ── DisableLogin stays unchanged ──────────────────────────────────────────────────────── + + /// The dev/test bypass still admits every surface with all roles, without LDAP or role mapping. + /// A task that represents the asynchronous operation. + [Fact] + public async Task DisableLogin_StillBypasses_WithAllRoles() + { + var services = new ServiceCollection(); + services.AddSingleton>( + Options.Create(new AuthDisableLoginOptions { DisableLogin = true })); + using var provider = services.BuildServiceProvider(); + + var outcome = await ManagementAuthenticator.AuthenticateAsync(new DefaultHttpContext { RequestServices = provider }); + + Assert.Null(outcome.Failure); + Assert.Equal(Roles.All, outcome.User!.Roles); + } + + private sealed class TestHubCallerContext : HubCallerContext + { + private readonly FeatureCollection _features = new(); + + public TestHubCallerContext(HttpContext http) => + _features.Set(new TestHttpContextFeature { HttpContext = http }); + + public bool Aborted { get; private set; } + + public override string ConnectionId => "test-conn"; + + public override string? UserIdentifier => null; + + public override System.Security.Claims.ClaimsPrincipal? User => null; + + public override IDictionary Items { get; } = new Dictionary(); + + public override IFeatureCollection Features => _features; + + public override CancellationToken ConnectionAborted => CancellationToken.None; + + public override void Abort() => Aborted = true; + + private sealed class TestHttpContextFeature : IHttpContextFeature + { + public HttpContext? HttpContext { get; set; } + } + } +}