fix(auth): authenticate client- and duplex-streaming gRPC calls

GatewayGrpcAuthorizationInterceptor only overrode the unary and
server-streaming handlers; the base Interceptor passes client- and
duplex-streaming calls through unauthenticated. Both now run the same
API-key pipeline and fail closed to the admin scope, since there is no
single request message to resolve a scope from.
This commit is contained in:
Joseph Doherty
2026-10-22 06:14:33 -04:00
parent ca0cf19a1f
commit 19cc74f21a
3 changed files with 211 additions and 11 deletions
@@ -717,6 +717,151 @@ public sealed class GatewayGrpcAuthorizationInterceptorTests
Assert.Null(GatewayGrpcAuthorizationInterceptor.TryResolveKeyId($"Bearer mxgw_{overCap}_secret"));
}
/// <summary>
/// A client-streaming call is authenticated exactly like a unary call: a missing key is
/// rejected with Unauthenticated and the handler never runs. The base Interceptor passes
/// client- and duplex-streaming calls straight through, so without the override any such RPC
/// added to the service would be reachable unauthenticated.
/// </summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task ClientStreamingServerHandler_MissingApiKey_ReturnsUnauthenticatedWithoutRunningHandler()
{
GatewayGrpcAuthorizationInterceptor interceptor = CreateInterceptor(
new FakeApiKeyVerifier(Failure(ApiKeyFailure.MissingOrMalformed)),
new GatewayRequestIdentityAccessor());
bool handlerRan = false;
RpcException exception = await Assert.ThrowsAsync<RpcException>(
() => interceptor.ClientStreamingServerHandler<MxCommandRequest, MxCommandReply>(
new EmptyStreamReader<MxCommandRequest>(),
new TestServerCallContext([]),
(_, _) =>
{
handlerRan = true;
return Task.FromResult(new MxCommandReply());
}));
Assert.Equal(StatusCode.Unauthenticated, exception.StatusCode);
Assert.False(handlerRan);
}
/// <summary>
/// A client-streaming call has no single request message to derive a scope from, so the
/// interceptor fails closed to the <c>admin</c> scope, the resolver's default for an
/// unrecognized request.
/// </summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task ClientStreamingServerHandler_KeyWithoutAdminScope_ReturnsPermissionDenied()
{
GatewayGrpcAuthorizationInterceptor interceptor = CreateInterceptor(
new FakeApiKeyVerifier(SuccessWithScopes(GatewayScopes.InvokeRead, GatewayScopes.InvokeWrite)),
new GatewayRequestIdentityAccessor());
RpcException exception = await Assert.ThrowsAsync<RpcException>(
() => interceptor.ClientStreamingServerHandler<MxCommandRequest, MxCommandReply>(
new EmptyStreamReader<MxCommandRequest>(),
ContextWithAuthorization("Bearer mxgw_operator01_secret"),
(_, _) => Task.FromResult(new MxCommandReply())));
Assert.Equal(StatusCode.PermissionDenied, exception.StatusCode);
Assert.Contains(GatewayScopes.Admin, exception.Status.Detail, StringComparison.Ordinal);
}
/// <summary>An admin-scoped key reaches the client-streaming handler with its identity pushed.</summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task ClientStreamingServerHandler_AdminScope_RunsHandlerWithIdentity()
{
GatewayRequestIdentityAccessor identityAccessor = new();
GatewayGrpcAuthorizationInterceptor interceptor = CreateInterceptor(
new FakeApiKeyVerifier(SuccessWithScopes(GatewayScopes.Admin)),
identityAccessor);
string? keyIdSeenByHandler = null;
await interceptor.ClientStreamingServerHandler<MxCommandRequest, MxCommandReply>(
new EmptyStreamReader<MxCommandRequest>(),
ContextWithAuthorization("Bearer mxgw_operator01_secret"),
(_, _) =>
{
keyIdSeenByHandler = identityAccessor.Current?.KeyId;
return Task.FromResult(new MxCommandReply());
});
Assert.Equal("operator01", keyIdSeenByHandler);
Assert.Null(identityAccessor.Current);
}
/// <summary>A duplex-streaming call with no key is rejected before the handler runs.</summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task DuplexStreamingServerHandler_MissingApiKey_ReturnsUnauthenticatedWithoutRunningHandler()
{
GatewayGrpcAuthorizationInterceptor interceptor = CreateInterceptor(
new FakeApiKeyVerifier(Failure(ApiKeyFailure.MissingOrMalformed)),
new GatewayRequestIdentityAccessor());
bool handlerRan = false;
RpcException exception = await Assert.ThrowsAsync<RpcException>(
() => interceptor.DuplexStreamingServerHandler<MxCommandRequest, MxCommandReply>(
new EmptyStreamReader<MxCommandRequest>(),
new RecordingServerStreamWriter<MxCommandReply>(),
new TestServerCallContext([]),
(_, _, _) =>
{
handlerRan = true;
return Task.CompletedTask;
}));
Assert.Equal(StatusCode.Unauthenticated, exception.StatusCode);
Assert.False(handlerRan);
}
/// <summary>A duplex-streaming call fails closed to the admin scope, like client streaming.</summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task DuplexStreamingServerHandler_KeyWithoutAdminScope_ReturnsPermissionDenied()
{
GatewayGrpcAuthorizationInterceptor interceptor = CreateInterceptor(
new FakeApiKeyVerifier(SuccessWithScopes(GatewayScopes.EventsRead)),
new GatewayRequestIdentityAccessor());
RpcException exception = await Assert.ThrowsAsync<RpcException>(
() => interceptor.DuplexStreamingServerHandler<MxCommandRequest, MxCommandReply>(
new EmptyStreamReader<MxCommandRequest>(),
new RecordingServerStreamWriter<MxCommandReply>(),
ContextWithAuthorization("Bearer mxgw_operator01_secret"),
(_, _, _) => Task.CompletedTask));
Assert.Equal(StatusCode.PermissionDenied, exception.StatusCode);
}
/// <summary>An admin-scoped key reaches the duplex handler with its identity pushed.</summary>
/// <returns>A task that represents the asynchronous operation.</returns>
[Fact]
public async Task DuplexStreamingServerHandler_AdminScope_RunsHandlerWithIdentity()
{
GatewayRequestIdentityAccessor identityAccessor = new();
GatewayGrpcAuthorizationInterceptor interceptor = CreateInterceptor(
new FakeApiKeyVerifier(SuccessWithScopes(GatewayScopes.Admin)),
identityAccessor);
RecordingServerStreamWriter<MxCommandReply> writer = new();
await interceptor.DuplexStreamingServerHandler<MxCommandRequest, MxCommandReply>(
new EmptyStreamReader<MxCommandRequest>(),
writer,
ContextWithAuthorization("Bearer mxgw_operator01_secret"),
async (_, responseStream, _) =>
{
Assert.Equal("operator01", identityAccessor.Current?.KeyId);
await responseStream.WriteAsync(new MxCommandReply { SessionId = "duplex" });
});
Assert.Equal("duplex", Assert.Single(writer.Messages).SessionId);
Assert.Null(identityAccessor.Current);
}
private static MxAccessGatewayService CreateService(
ISessionManager sessionManager,
IGatewayRequestIdentityAccessor identityAccessor)
@@ -933,4 +1078,15 @@ public sealed class GatewayGrpcAuthorizationInterceptorTests
}
}
/// <summary>An <see cref="IAsyncStreamReader{T}"/> that yields no messages.</summary>
/// <typeparam name="T">The streamed message type.</typeparam>
private sealed class EmptyStreamReader<T> : IAsyncStreamReader<T>
{
/// <inheritdoc />
public T Current => throw new InvalidOperationException("The stream is empty.");
/// <inheritdoc />
public Task<bool> MoveNext(CancellationToken cancellationToken) => Task.FromResult(false);
}
}