Merge branch 'fix/145-management-zero-role': refuse zero-role principals on management/CLI surfaces (#145)
Claude-Session: https://claude.ai/code/session_01GT67AFKC45MBz1wPZnVbX8
This commit is contained in:
@@ -195,7 +195,7 @@ spec for each is `docs/requirements/Component-<Name>.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*.
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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 <jwt>` 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.
|
||||
|
||||
@@ -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;
|
||||
/// <see cref="AuthenticatedUser.PermittedSiteIds"/>). The startup <c>AUTH DISABLED</c> warning
|
||||
/// (emitted by <c>AddSecurity</c>) already announces this posture. Dev/test ONLY.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>No role, no login</b> (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 <c>401 AUTH_FAILED</c> body and a
|
||||
/// <see cref="LoginThrottle"/> failure — and a bearer token that carries no role claim is refused
|
||||
/// like any other invalid token. Every refusal is logged at Warning under
|
||||
/// <see cref="LoggerCategory"/> with the endpoint, the username and the reason. Because the three
|
||||
/// callers (<see cref="ManagementEndpoints"/>, <see cref="AuditEndpoints"/>, the debug-stream hub)
|
||||
/// take their <see cref="AuthenticatedUser"/> only from here, none of them can admit a role-less
|
||||
/// principal — including the commands <c>ManagementActor.GetRequiredRoles</c> opens to any
|
||||
/// authenticated user.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class ManagementAuthenticator
|
||||
{
|
||||
/// <summary>The logger category for the sign-in refusals logged by this authenticator.</summary>
|
||||
public const string LoggerCategory = "ZB.MOM.WW.ScadaBridge.ManagementService.ManagementAuthenticator";
|
||||
|
||||
/// <summary>Outcome of <see cref="AuthenticateAsync"/>: exactly one of the two fields is set.</summary>
|
||||
/// <param name="User">The authenticated principal on success; otherwise <see langword="null"/>.</param>
|
||||
/// <param name="Failure">The 401 <see cref="IResult"/> to return on failure; otherwise <see langword="null"/>.</param>
|
||||
@@ -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<RoleMapper>();
|
||||
var mappingResult = await roleMapper.MapGroupsToRolesAsync(authResult.Groups, context.RequestAborted);
|
||||
throttle.RecordSuccess(username, remoteIp!);
|
||||
|
||||
var permittedSiteIds = mappingResult.IsSystemWideDeployment
|
||||
? Array.Empty<string>()
|
||||
@@ -162,10 +187,67 @@ public static class ManagementAuthenticator
|
||||
return new AuthOutcome(resolvedUser, null);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Maps a successful Basic bind's groups to roles, enforcing <b>no role, no login</b>
|
||||
/// (ScadaBridge#145). Returns <see langword="null"/> — 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.
|
||||
/// </summary>
|
||||
/// <param name="context">The current HTTP context (services, request path, request-aborted token).</param>
|
||||
/// <param name="authResult">The successful LDAP bind result.</param>
|
||||
/// <param name="username">The username as sent, used when the bind returned no canonical name.</param>
|
||||
/// <returns>The role mapping, or <see langword="null"/> when the request must be refused.</returns>
|
||||
private static async Task<RoleMappingResult?> 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<RoleMapper>();
|
||||
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<ILoggerFactory>()?.CreateLogger(LoggerCategory) ?? NullLogger.Instance;
|
||||
|
||||
private static string EndpointName(HttpContext context) =>
|
||||
context.Request.Path.HasValue ? context.Request.Path.Value! : "management";
|
||||
|
||||
/// <summary>
|
||||
/// Validates a bearer JWT and projects its claims onto an <see cref="AuthenticatedUser"/>.
|
||||
/// 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): <c>/auth/token</c> no
|
||||
/// longer mints one, but a token minted before that rule shipped stays valid until it expires.
|
||||
/// </summary>
|
||||
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)
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
using System.Collections.Concurrent;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace ZB.MOM.WW.ScadaBridge.ManagementService.Tests;
|
||||
|
||||
/// <summary>An in-memory logger provider that records every formatted log line with its category and level.</summary>
|
||||
internal sealed class CapturingLoggerProvider : ILoggerProvider
|
||||
{
|
||||
/// <summary>One captured log entry.</summary>
|
||||
/// <param name="Category">The logger category.</param>
|
||||
/// <param name="Level">The log level.</param>
|
||||
/// <param name="Message">The formatted message.</param>
|
||||
/// <param name="Exception">The logged exception, if any.</param>
|
||||
public sealed record Entry(string Category, LogLevel Level, string Message, Exception? Exception);
|
||||
|
||||
/// <summary>Every entry logged through this provider, in order.</summary>
|
||||
public ConcurrentQueue<Entry> Entries { get; } = new();
|
||||
|
||||
/// <inheritdoc />
|
||||
public ILogger CreateLogger(string categoryName) => new Logger(categoryName, Entries);
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Dispose()
|
||||
{
|
||||
}
|
||||
|
||||
private sealed class Logger(string category, ConcurrentQueue<Entry> sink) : ILogger
|
||||
{
|
||||
public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
|
||||
|
||||
public bool IsEnabled(LogLevel logLevel) => true;
|
||||
|
||||
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception,
|
||||
Func<TState, Exception?, string> formatter) =>
|
||||
sink.Enqueue(new Entry(category, logLevel, formatter(state, exception), exception));
|
||||
}
|
||||
}
|
||||
+531
@@ -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;
|
||||
|
||||
/// <summary>
|
||||
/// ScadaBridge#145 — the management/CLI surfaces (<c>POST /management</c>, the audit REST endpoints and
|
||||
/// the debug-stream hub) refuse a principal with no ScadaBridge role, mirroring #144's rule for
|
||||
/// <c>/auth/login</c> and <c>/auth/token</c>. 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.
|
||||
/// </summary>
|
||||
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";
|
||||
|
||||
/// <summary>The role outcome the substituted <see cref="RoleMapper"/> produces.</summary>
|
||||
public enum Mapping
|
||||
{
|
||||
/// <summary>The groups map to no role.</summary>
|
||||
ZeroRoles,
|
||||
|
||||
/// <summary>The mapper throws (e.g. the configuration database is unreachable).</summary>
|
||||
Throws,
|
||||
|
||||
/// <summary>The groups map to exactly one role (the one the surface needs).</summary>
|
||||
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();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// LDAP accepts alice/password (groups ["Domain Users"]) and rejects alice/wrong; the role mapper
|
||||
/// answers per <paramref name="mapping"/>, with <paramref name="oneRole"/> as the single role.
|
||||
/// </summary>
|
||||
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<IOptions<AuthDisableLoginOptions>>(
|
||||
Options.Create(new AuthDisableLoginOptions { DisableLogin = false }));
|
||||
services.AddSingleton<IOptions<SecurityOptions>>(Options.Create(new SecurityOptions
|
||||
{
|
||||
JwtSigningKey = Key,
|
||||
JwtExpiryMinutes = 15,
|
||||
MaxLoginFailuresPerWindow = maxFailures,
|
||||
PerIpMaxFailures = 25,
|
||||
}));
|
||||
services.AddSingleton(TimeProvider.System);
|
||||
services.AddSingleton<LoginThrottle>();
|
||||
services.AddScoped<JwtTokenService>();
|
||||
|
||||
var ldap = Substitute.For<ILdapAuthService>();
|
||||
ldap.AuthenticateAsync("alice", "password", Arg.Any<CancellationToken>())
|
||||
.Returns(LdapAuthResult.Success("alice", "Alice", ["Domain Users"]));
|
||||
ldap.AuthenticateAsync("alice", "wrong", Arg.Any<CancellationToken>())
|
||||
.Returns(LdapAuthResult.Fail(LdapAuthFailure.BadCredentials));
|
||||
services.AddSingleton(ldap);
|
||||
|
||||
var roleMapper = Substitute.For<RoleMapper>(Substitute.For<ISecurityRepository>());
|
||||
var call = roleMapper.MapGroupsToRolesAsync(Arg.Any<IReadOnlyList<string>>(), Arg.Any<CancellationToken>());
|
||||
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<IAuditLogRepository>();
|
||||
repo.QueryAsync(Arg.Any<AuditLogQueryFilter>(), Arg.Any<AuditLogPaging>(), Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult<IReadOnlyList<AuditEvent>>(Array.Empty<AuditEvent>()));
|
||||
services.AddSingleton(repo);
|
||||
|
||||
var provider = services.BuildServiceProvider();
|
||||
return new Rig
|
||||
{
|
||||
Provider = provider,
|
||||
Throttle = provider.GetRequiredService<LoginThrottle>(),
|
||||
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<JwtTokenService>.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));
|
||||
}
|
||||
|
||||
/// <summary>The 401 body a bad password gets on the same surface — every Basic refusal must match it.</summary>
|
||||
private static async Task<(int Status, string Body)> BadPassword(Func<Rig, string, Task<(int, string)>> 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<InvalidOperationException>(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) ──────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>The command these tests send is one <c>GetRequiredRoles</c> opens to any authenticated user.</summary>
|
||||
[Fact]
|
||||
public void ListSites_IsOpenToAnyAuthenticatedUser()
|
||||
{
|
||||
Assert.Null(ManagementActor.GetRequiredRoles(new ListSitesCommand()));
|
||||
}
|
||||
|
||||
/// <summary>A zero-role or mapper-fault Basic bind gets the bad-password 401 on a null-role command, and it is logged.</summary>
|
||||
/// <param name="mapping">The refused mapping outcome.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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");
|
||||
}
|
||||
|
||||
/// <summary>A one-role Basic bind passes authentication and reaches dispatch (503: no actor in the rig).</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>A bearer token with no role claim is refused with the invalid-token 401, and it is logged.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.)
|
||||
/// </summary>
|
||||
/// <param name="mapping">The mapper state, which a bearer request must not consult.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>Every management command <c>GetRequiredRoles</c> opens to any authenticated user.</summary>
|
||||
/// <returns>The theory data rows of command names.</returns>
|
||||
public static IEnumerable<object[]> 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] });
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <param name="command">A null-role command name.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>A zero-role Basic refusal counts against the login throttle like a bad password.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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 ────────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>A zero-role or mapper-fault Basic bind gets the bad-password 401 on an audit query (not a 403), and it is logged.</summary>
|
||||
/// <param name="mapping">The refused mapping outcome.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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");
|
||||
}
|
||||
|
||||
/// <summary>A one-role Basic bind with an audit role gets the query page.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>A bearer token with no role claim gets 401 on an audit query (not a 403), and it is logged.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>A one-role bearer token gets the query page without any role mapping, even while the mapper throws.</summary>
|
||||
/// <param name="mapping">The mapper state, which a bearer request must not consult.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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<TestHubCallerContext> ConnectHub(Rig rig, string authorization)
|
||||
{
|
||||
var http = Request(rig, "/hubs/debug-stream", authorization);
|
||||
var debugStreamService = new DebugStreamService(
|
||||
new CommunicationService(Options.Create(new CommunicationOptions()), NullLogger<CommunicationService>.Instance),
|
||||
new ServiceCollection().BuildServiceProvider(),
|
||||
new SiteStreamGrpcClientFactory(NullLoggerFactory.Instance),
|
||||
NullLogger<DebugStreamService>.Instance);
|
||||
var hub = new DebugStreamHub(debugStreamService, Substitute.For<IHubContext<DebugStreamHub>>(),
|
||||
NullLogger<DebugStreamHub>.Instance);
|
||||
var ctx = new TestHubCallerContext(http);
|
||||
hub.Context = ctx;
|
||||
await hub.OnConnectedAsync();
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <param name="mapping">The refused mapping outcome.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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));
|
||||
}
|
||||
|
||||
/// <summary>A one-role (Deployer) Basic connect is established.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>A bearer token with no role claim is refused by the shared authenticator, and it is logged.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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);
|
||||
}
|
||||
|
||||
/// <summary>A one-role (Deployer) bearer connect is established without role mapping, even while the mapper throws.</summary>
|
||||
/// <param name="mapping">The mapper state, which a bearer request must not consult.</param>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[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 ────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>The dev/test bypass still admits every surface with all roles, without LDAP or role mapping.</summary>
|
||||
/// <returns>A task that represents the asynchronous operation.</returns>
|
||||
[Fact]
|
||||
public async Task DisableLogin_StillBypasses_WithAllRoles()
|
||||
{
|
||||
var services = new ServiceCollection();
|
||||
services.AddSingleton<IOptions<AuthDisableLoginOptions>>(
|
||||
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<IHttpContextFeature>(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<object, object?> Items { get; } = new Dictionary<object, object?>();
|
||||
|
||||
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; }
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user