fix(auth): aggregate bulk constraint denials into one audit event; ValueTask constraint checks

A bulk command with N denied items wrote N audit events into the bounded,
drop-on-full audit channel, so a low-privilege key could evict every other
pending audit record. Bulk filters now accumulate a ConstraintDenialSummary
(count, constraint names, <=20 sample targets) and write one aggregated
constraint-denied event per command.

The per-item constraint checks are synchronous, so IConstraintEnforcer's
Check* methods now return ValueTask instead of allocating a Task per item.
This commit is contained in:
Joseph Doherty
2026-10-22 06:12:02 -04:00
parent 488649ce99
commit ca0cf19a1f
10 changed files with 400 additions and 62 deletions
@@ -87,8 +87,56 @@ public sealed class MxAccessGatewayServiceConstraintTests
Assert.True(merged.Results[3].WasSuccessful);
Assert.Equal("Tank04.Public", merged.Results[3].TagAddress);
Assert.Equal(104, merged.Results[3].ItemHandle);
// Both denied tags recorded.
Assert.Equal(2, enforcer.RecordedDenials.Count);
// Both denied tags recorded in ONE aggregated bulk denial, not one audit call per item.
Assert.Empty(enforcer.RecordedDenials);
(string commandKind, ConstraintDenialSummary summary, _) = Assert.Single(enforcer.RecordedBulkDenials);
Assert.Equal(nameof(MxCommandKind.AddItemBulk), commandKind);
Assert.Equal(2, summary.DeniedCount);
Assert.Equal(4, summary.TotalCount);
Assert.Equal(["Tank01.Locked", "Tank03.Secret"], summary.SampleTargets);
}
/// <summary>
/// Audit-flood guard: a bulk write whose every entry is denied records exactly one
/// aggregated denial carrying the full denied count, the client correlation id and a sample
/// capped at <see cref="ConstraintDenialSummary.MaxSampleTargets"/> — so one low-privilege
/// key cannot push thousands of events into the bounded, drop-on-full audit channel.
/// </summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task Invoke_WriteBulk_WithManyDeniedEntries_RecordsOneAggregatedDenial()
{
const int EntryCount = 500;
PredicateConstraintEnforcer enforcer = new() { DenyWriteHandle = (_, _) => true };
FakeSessionManager sessionManager = CreateSessionManagerWithSeed();
MxAccessGatewayService service = CreateService(sessionManager, enforcer);
WriteBulkCommand payload = new() { ServerHandle = 7 };
for (int index = 0; index < EntryCount; index++)
{
payload.Entries.Add(new WriteBulkEntry { ItemHandle = index + 1 });
}
MxCommandRequest request = new()
{
SessionId = SessionId,
ClientCorrelationId = "bulk-flood-1",
Command = new MxCommand { Kind = MxCommandKind.WriteBulk, WriteBulk = payload },
};
MxCommandReply reply = await service.Invoke(request, new TestServerCallContext());
Assert.Equal(0, sessionManager.InvokeCount);
Assert.Equal(EntryCount, reply.WriteBulk.Results.Count);
Assert.Empty(enforcer.RecordedDenials);
(string commandKind, ConstraintDenialSummary summary, string? correlationId) =
Assert.Single(enforcer.RecordedBulkDenials);
Assert.Equal(nameof(MxCommandKind.WriteBulk), commandKind);
Assert.Equal("bulk-flood-1", correlationId);
Assert.Equal(EntryCount, summary.DeniedCount);
Assert.Equal(EntryCount, summary.TotalCount);
Assert.Equal(ConstraintDenialSummary.MaxSampleTargets, summary.SampleTargets.Count);
Assert.True(summary.SampleTruncated);
Assert.Equal(["write-handle"], summary.ConstraintNames);
}
/// <summary>
@@ -154,6 +154,70 @@ public sealed class ConstraintEnforcerTests
Assert.Equal("Read:Secret.Tag", auditEvent.Target);
}
/// <summary>
/// A bulk denial is written as ONE audit event carrying the denied/total counts, the distinct
/// constraint names and a sample capped at <see cref="ConstraintDenialSummary.MaxSampleTargets"/>,
/// however many items were denied.
/// </summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task RecordBulkDenialAsync_WritesOneAggregatedEventWithBoundedSample()
{
ConstraintEnforcer enforcer = CreateEnforcer(out FakeAuditWriter auditWriter);
ConstraintDenialSummary summary = new(totalCount: 1000);
for (int index = 0; index < 999; index++)
{
summary.Add(
$"Area1.Tag{index}",
index % 2 == 0
? new ConstraintFailure("read_scope", "Tag is outside the API key read scope.")
: new ConstraintFailure("tag_metadata", "Tag metadata is not available."));
}
await enforcer.RecordBulkDenialAsync(
CreateIdentity(ApiKeyConstraints.Empty),
"ReadBulk",
summary,
"trace-1",
CancellationToken.None);
AuditEvent auditEvent = Assert.Single(auditWriter.Events);
Assert.Equal("operator01", auditEvent.Actor);
Assert.Equal("constraint-denied", auditEvent.Action);
Assert.Equal(AuditOutcome.Denied, auditEvent.Outcome);
Assert.Equal("ReadBulk:bulk", auditEvent.Target);
Assert.Null(auditEvent.CorrelationId);
using JsonDocument details = JsonDocument.Parse(auditEvent.DetailsJson!);
JsonElement root = details.RootElement;
Assert.Equal(999, root.GetProperty("deniedCount").GetInt32());
Assert.Equal(1000, root.GetProperty("totalCount").GetInt32());
Assert.True(root.GetProperty("sampleTruncated").GetBoolean());
Assert.Equal(ConstraintDenialSummary.MaxSampleTargets, root.GetProperty("sampleTargets").GetArrayLength());
Assert.Equal(
["read_scope", "tag_metadata"],
root.GetProperty("constraints").EnumerateArray().Select(e => e.GetString() ?? string.Empty).ToArray());
Assert.Equal("ReadBulk", root.GetProperty("commandKind").GetString());
Assert.Equal("trace-1", root.GetProperty("clientCorrelationId").GetString());
}
/// <summary>An empty summary (nothing denied) writes no audit event at all.</summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task RecordBulkDenialAsync_WithNoDenials_WritesNothing()
{
ConstraintEnforcer enforcer = CreateEnforcer(out FakeAuditWriter auditWriter);
await enforcer.RecordBulkDenialAsync(
identity: null,
"ReadBulk",
new ConstraintDenialSummary(totalCount: 3),
correlationId: null,
CancellationToken.None);
Assert.Empty(auditWriter.Events);
}
/// <summary>Verifies that historized-only constraint requires historized attribute.</summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
@@ -11,26 +11,26 @@ namespace ZB.MOM.WW.MxGateway.Tests.TestSupport;
public sealed class AllowAllConstraintEnforcer : IConstraintEnforcer
{
/// <inheritdoc />
public Task<ConstraintFailure?> CheckReadTagAsync(
public ValueTask<ConstraintFailure?> CheckReadTagAsync(
ApiKeyIdentity? identity,
string tagAddress,
CancellationToken cancellationToken) => Task.FromResult<ConstraintFailure?>(null);
CancellationToken cancellationToken) => ValueTask.FromResult<ConstraintFailure?>(null);
/// <inheritdoc />
public Task<ConstraintFailure?> CheckReadHandleAsync(
public ValueTask<ConstraintFailure?> CheckReadHandleAsync(
ApiKeyIdentity? identity,
GatewaySession session,
int serverHandle,
int itemHandle,
CancellationToken cancellationToken) => Task.FromResult<ConstraintFailure?>(null);
CancellationToken cancellationToken) => ValueTask.FromResult<ConstraintFailure?>(null);
/// <inheritdoc />
public Task<ConstraintFailure?> CheckWriteHandleAsync(
public ValueTask<ConstraintFailure?> CheckWriteHandleAsync(
ApiKeyIdentity? identity,
GatewaySession session,
int serverHandle,
int itemHandle,
CancellationToken cancellationToken) => Task.FromResult<ConstraintFailure?>(null);
CancellationToken cancellationToken) => ValueTask.FromResult<ConstraintFailure?>(null);
/// <inheritdoc />
public Task RecordDenialAsync(
@@ -40,4 +40,12 @@ public sealed class AllowAllConstraintEnforcer : IConstraintEnforcer
ConstraintFailure failure,
string? correlationId,
CancellationToken cancellationToken) => Task.CompletedTask;
/// <inheritdoc />
public Task RecordBulkDenialAsync(
ApiKeyIdentity? identity,
string commandKind,
ConstraintDenialSummary summary,
string? correlationId,
CancellationToken cancellationToken) => Task.CompletedTask;
}
@@ -26,23 +26,26 @@ public sealed class PredicateConstraintEnforcer : IConstraintEnforcer
/// <summary>Recorded denial messages — (commandKind, target, correlationId) tuples.</summary>
public List<(string CommandKind, string Target, string? CorrelationId)> RecordedDenials { get; } = [];
/// <summary>Recorded aggregated bulk denials — one entry per bulk command that had any item denied.</summary>
public List<(string CommandKind, ConstraintDenialSummary Summary, string? CorrelationId)> RecordedBulkDenials { get; } = [];
/// <inheritdoc />
public Task<ConstraintFailure?> CheckReadTagAsync(
public ValueTask<ConstraintFailure?> CheckReadTagAsync(
ApiKeyIdentity? identity,
string tagAddress,
CancellationToken cancellationToken)
{
if (DenyTag(tagAddress))
{
return Task.FromResult<ConstraintFailure?>(
return ValueTask.FromResult<ConstraintFailure?>(
new ConstraintFailure("read-tag", $"Read denied for tag '{tagAddress}'."));
}
return Task.FromResult<ConstraintFailure?>(null);
return ValueTask.FromResult<ConstraintFailure?>(null);
}
/// <inheritdoc />
public Task<ConstraintFailure?> CheckReadHandleAsync(
public ValueTask<ConstraintFailure?> CheckReadHandleAsync(
ApiKeyIdentity? identity,
GatewaySession session,
int serverHandle,
@@ -51,15 +54,15 @@ public sealed class PredicateConstraintEnforcer : IConstraintEnforcer
{
if (DenyReadHandle(serverHandle, itemHandle))
{
return Task.FromResult<ConstraintFailure?>(
return ValueTask.FromResult<ConstraintFailure?>(
new ConstraintFailure("read-handle", $"Read denied for handle {itemHandle}."));
}
return Task.FromResult<ConstraintFailure?>(null);
return ValueTask.FromResult<ConstraintFailure?>(null);
}
/// <inheritdoc />
public Task<ConstraintFailure?> CheckWriteHandleAsync(
public ValueTask<ConstraintFailure?> CheckWriteHandleAsync(
ApiKeyIdentity? identity,
GatewaySession session,
int serverHandle,
@@ -68,11 +71,11 @@ public sealed class PredicateConstraintEnforcer : IConstraintEnforcer
{
if (DenyWriteHandle(serverHandle, itemHandle))
{
return Task.FromResult<ConstraintFailure?>(
return ValueTask.FromResult<ConstraintFailure?>(
new ConstraintFailure("write-handle", $"Write denied for handle {itemHandle}."));
}
return Task.FromResult<ConstraintFailure?>(null);
return ValueTask.FromResult<ConstraintFailure?>(null);
}
/// <inheritdoc />
@@ -87,4 +90,16 @@ public sealed class PredicateConstraintEnforcer : IConstraintEnforcer
RecordedDenials.Add((commandKind, target, correlationId));
return Task.CompletedTask;
}
/// <inheritdoc />
public Task RecordBulkDenialAsync(
ApiKeyIdentity? identity,
string commandKind,
ConstraintDenialSummary summary,
string? correlationId,
CancellationToken cancellationToken)
{
RecordedBulkDenials.Add((commandKind, summary, correlationId));
return Task.CompletedTask;
}
}