Browse Source

Harden admin API key set output and authorization revocation

- Strip private/symmetric JWK parameters (d, p, q, dp, dq, qi, oth, k, priv) from application key sets
- Revoke the tokens attached to an authorization when it is revoked
- Move admin API error codes to OpenIddictServerAspNetCoreConstants.AdminApi.ErrorCodes
- Tests for both behaviours
pull/2549/head
pieroviano 2 months ago
parent
commit
6a0d72b763
  1. 66
      src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreAdminApiEndpoints.cs
  2. 6
      src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreConstants.cs
  3. 65
      test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddictServerAspNetCoreAdminApiTests.cs

66
src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreAdminApiEndpoints.cs

@ -23,6 +23,13 @@ internal static class OpenIddictServerAspNetCoreAdminApiEndpoints
private const int DefaultCount = 100;
private const int MaximumCount = 1000;
// Private (RSA, EC, OKP, AKP) and symmetric (oct) key parameters.
// See https://datatracker.ietf.org/doc/html/rfc7518#section-6 for more information.
private static readonly HashSet<string> PrivateJsonWebKeyParameters = new(StringComparer.Ordinal)
{
"d", "dp", "dq", "k", "oth", "p", "priv", "q", "qi"
};
public static Task ListApplicationsAsync(HttpContext context) => ExecuteAsync(context, static async context =>
{
var manager = GetManager<IOpenIddictApplicationManager>(context);
@ -299,6 +306,14 @@ internal static class OpenIddictServerAspNetCoreAdminApiEndpoints
throw new AdminApiException(StatusCodes.Status409Conflict, SR.GetResourceString(SR.ID2244));
}
// Revoke the tokens attached to the authorization so that they are no longer considered valid
// (independently of whether token validation checks the status of the authorization entry).
if (context.RequestServices.GetService<IOpenIddictTokenManager>() is IOpenIddictTokenManager tokens &&
await manager.GetIdAsync(authorization, context.RequestAborted) is { Length: > 0 } identifier)
{
await tokens.RevokeByAuthorizationIdAsync(identifier, context.RequestAborted);
}
context.Response.StatusCode = StatusCodes.Status204NoContent;
});
@ -598,8 +613,8 @@ internal static class OpenIddictServerAspNetCoreAdminApiEndpoints
writer.WriteStartObject();
writer.WriteString(Parameters.Error, status switch
{
StatusCodes.Status404NotFound => "not_found",
StatusCodes.Status409Conflict => "conflict",
StatusCodes.Status404NotFound => ErrorCodes.NotFound,
StatusCodes.Status409Conflict => ErrorCodes.Conflict,
_ => Errors.InvalidRequest
});
writer.WriteString(Parameters.ErrorDescription, description);
@ -680,7 +695,10 @@ internal static class OpenIddictServerAspNetCoreAdminApiEndpoints
if (descriptor.JsonWebKeySet is not null)
{
JsonSerializer.Serialize(writer, descriptor.JsonWebKeySet, OpenIddictSerializer.Default.JsonWebKeySet);
using var set = JsonDocument.Parse(JsonSerializer.SerializeToUtf8Bytes(
descriptor.JsonWebKeySet, OpenIddictSerializer.Default.JsonWebKeySet));
WritePublicJsonWebKeySet(writer, set.RootElement);
}
else
@ -706,6 +724,48 @@ internal static class OpenIddictServerAspNetCoreAdminApiEndpoints
writer.WriteEndObject();
}
private static void WritePublicJsonWebKeySet(Utf8JsonWriter writer, JsonElement set)
{
// Note: the private and symmetric key parameters (that may have been attached to the client
// JSON Web Key Set, even if only public keys are expected) are deliberately never returned.
writer.WriteStartObject();
foreach (var property in set.EnumerateObject())
{
if (!property.NameEquals(JsonWebKeySetParameterNames.Keys) || property.Value.ValueKind is not JsonValueKind.Array)
{
property.WriteTo(writer);
continue;
}
writer.WriteStartArray(property.Name);
foreach (var key in property.Value.EnumerateArray())
{
if (key.ValueKind is not JsonValueKind.Object)
{
continue;
}
writer.WriteStartObject();
foreach (var parameter in key.EnumerateObject())
{
if (!PrivateJsonWebKeyParameters.Contains(parameter.Name))
{
parameter.WriteTo(writer);
}
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
private static void WriteScope(Utf8JsonWriter writer, string? identifier, OpenIddictScopeDescriptor descriptor)
{
writer.WriteStartObject();

6
src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreConstants.cs

@ -13,6 +13,12 @@ public static class OpenIddictServerAspNetCoreConstants
{
public static class AdminApi
{
public static class ErrorCodes
{
public const string Conflict = "conflict";
public const string NotFound = "not_found";
}
public static class Paths
{
public const string Applications = "applications";

65
test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddictServerAspNetCoreAdminApiTests.cs

@ -175,7 +175,7 @@ public class OpenIddictServerAspNetCoreAdminApiTests
}
[Fact]
public async Task GetApplication_ReturnsJsonWebKeySet()
public async Task GetApplication_ReturnsJsonWebKeySetWithoutPrivateKeyParameters()
{
// Arrange
var application = new object();
@ -185,7 +185,16 @@ public class OpenIddictServerAspNetCoreAdminApiTests
.ReturnsAsync(application);
manager.Setup(mock => mock.PopulateAsync(It.IsAny<OpenIddictApplicationDescriptor>(), application, It.IsAny<CancellationToken>()))
.Callback((OpenIddictApplicationDescriptor descriptor, object _, CancellationToken _) =>
descriptor.JsonWebKeySet = JsonWebKeySet.Create("""{ "keys": [ { "kty": "oct", "kid": "key-1", "k": "c2VjcmV0" } ] }"""))
descriptor.JsonWebKeySet = JsonWebKeySet.Create("""
{
"keys": [
{ "kty": "RSA", "kid": "key-1", "use": "sig", "n": "bW9kdWx1cw", "e": "AQAB",
"d": "cHJpdmF0ZS1leHBvbmVudA", "p": "cHJpbWUtMQ", "q": "cHJpbWUtMg",
"dp": "ZXhwb25lbnQtMQ", "dq": "ZXhwb25lbnQtMg", "qi": "Y29lZmZpY2llbnQ" },
{ "kty": "oct", "kid": "key-2", "k": "c3ltbWV0cmljLXNlY3JldA" }
]
}
"""))
.Returns(ValueTask.CompletedTask);
using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object));
@ -196,9 +205,23 @@ public class OpenIddictServerAspNetCoreAdminApiTests
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
var key = Assert.Single(document.RootElement.GetProperty("json_web_key_set").GetProperty("keys").EnumerateArray());
Assert.Equal("key-1", key.GetProperty("kid").GetString());
var content = await response.Content.ReadAsStringAsync();
using var document = JsonDocument.Parse(content);
var keys = document.RootElement.GetProperty("json_web_key_set").GetProperty("keys").EnumerateArray().ToArray();
Assert.Equal(2, keys.Length);
Assert.Equal("key-1", keys[0].GetProperty("kid").GetString());
Assert.Equal("bW9kdWx1cw", keys[0].GetProperty("n").GetString());
Assert.Equal("AQAB", keys[0].GetProperty("e").GetString());
Assert.Equal("key-2", keys[1].GetProperty("kid").GetString());
foreach (var parameter in (string[]) ["d", "p", "q", "dp", "dq", "qi", "k"])
{
Assert.All(keys, key => Assert.False(key.TryGetProperty(parameter, out _)));
}
Assert.DoesNotContain("cHJpdmF0ZS1leHBvbmVudA", content, StringComparison.Ordinal);
Assert.DoesNotContain("c3ltbWV0cmljLXNlY3JldA", content, StringComparison.Ordinal);
}
[Fact]
@ -513,6 +536,38 @@ public class OpenIddictServerAspNetCoreAdminApiTests
manager.Verify(mock => mock.TryRevokeAsync(token, It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task RevokeAuthorization_RevokesTheAssociatedTokens()
{
// Arrange
var authorization = new object();
var manager = new Mock<IOpenIddictAuthorizationManager>();
manager.Setup(mock => mock.FindByIdAsync("a1", It.IsAny<CancellationToken>()))
.ReturnsAsync(authorization);
manager.Setup(mock => mock.GetIdAsync(authorization, It.IsAny<CancellationToken>()))
.ReturnsAsync("a1");
manager.Setup(mock => mock.TryRevokeAsync(authorization, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
var tokens = new Mock<IOpenIddictTokenManager>();
tokens.Setup(mock => mock.RevokeByAuthorizationIdAsync("a1", It.IsAny<CancellationToken>()))
.ReturnsAsync(2);
using var host = await CreateHostAsync(services => services
.AddSingleton(manager.Object)
.AddSingleton(tokens.Object));
using var client = CreateClient(host, role: "admin");
// Act
var response = await client.PostAsync("/openiddict/admin/authorizations/a1/revoke", JsonContent("{}"));
// Assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
manager.Verify(mock => mock.TryRevokeAsync(authorization, It.IsAny<CancellationToken>()), Times.Once());
tokens.Verify(mock => mock.RevokeByAuthorizationIdAsync("a1", It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task RevokeAuthorization_ReturnsConflictWhenRevocationFails()
{

Loading…
Cancel
Save