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