Versatile OpenID Connect stack for ASP.NET Core and Microsoft.Owin (compatible with ASP.NET 4.6.1)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

153 lines
6.2 KiB

using System.Security.Claims;
using System.Security.Cryptography;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;
using Xunit;
using static OpenIddict.Client.OpenIddictClientEvents;
using static OpenIddict.Client.OpenIddictClientHandlers;
namespace OpenIddict.Client.Tests;
public class OpenIddictClientHandlersRequestObjectTests
{
private static readonly RsaSecurityKey SigningKey = new(RSA.Create(keySizeInBits: 2048));
[Theory]
[InlineData(true, false, false, false)]
[InlineData(true, false, true, true)]
[InlineData(null, true, false, true)]
[InlineData(false, true, true, true)]
[InlineData(null, null, true, false)]
[InlineData(false, false, true, false)]
public async Task EvaluateRequestObject_RequestObjectIsSentWhenSupportedAndEnabledOrRequired(
bool? supported, bool? required, bool enabled, bool expected)
{
// Arrange
using var provider = CreateProvider(enabled);
var context = CreateContext(provider);
context.Configuration.RequestParameterSupported = supported;
context.Configuration.RequireSignedRequestObject = required;
// Act
await new EvaluateRequestObject().HandleAsync(context);
// Assert
Assert.Equal(expected, context.SendRequestObject);
}
[Fact]
public async Task EvaluateRequestObject_ThrowsAnExceptionWhenNoAsymmetricSigningKeyIsAvailable()
{
// Arrange
using var provider = CreateProvider(enabled: true);
var context = CreateContext(provider);
context.Configuration.RequireSignedRequestObject = true;
context.Registration.SigningCredentials.Clear();
// Act and assert
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
async () => await new EvaluateRequestObject().HandleAsync(context));
Assert.Equal(SR.GetResourceString(SR.ID0526), exception.Message);
}
[Fact]
public async Task GenerateRequestObject_AuthorizationRequestParametersAreReplacedBySignedRequestObject()
{
// Arrange
using var provider = CreateProvider(enabled: true);
var context = CreateContext(provider);
context.Configuration.RequestParameterSupported = true;
context.Request.ClientId = "Fabrikam";
context.Request.RedirectUri = "https://www.fabrikam.com/callback";
context.Request.ResponseType = ResponseTypes.Code;
context.Request.Scope = "openid profile";
context.Request.Resources = ["https://www.fabrikam.com/api/1", "https://www.fabrikam.com/api/2"];
context.Request.State = "af0ifjsldkj";
// Act
await new EvaluateRequestObject().HandleAsync(context);
await new PrepareRequestObjectPrincipal().HandleAsync(context);
await new GenerateRequestObject(provider.GetRequiredService<IOpenIddictClientDispatcher>()).HandleAsync(context);
// Assert
Assert.Equal("Fabrikam", context.Request.ClientId);
Assert.Equal(context.RequestObject, context.Request.Request);
Assert.Equal(2, context.Request.Count);
var result = await new JsonWebTokenHandler().ValidateTokenAsync(context.RequestObject, new TokenValidationParameters
{
IssuerSigningKey = SigningKey,
ValidAudience = "https://www.contoso.com/",
ValidIssuer = "Fabrikam",
ValidTypes = [JsonWebTokenTypes.AuthorizationRequest]
});
Assert.True(result.IsValid, result.Exception?.Message);
var token = (JsonWebToken) result.SecurityToken;
Assert.Equal("https://www.fabrikam.com/callback", token.GetPayloadValue<string>(Parameters.RedirectUri));
Assert.Equal(ResponseTypes.Code, token.GetPayloadValue<string>(Parameters.ResponseType));
Assert.Equal("openid profile", token.GetPayloadValue<string>(Parameters.Scope));
Assert.Equal("af0ifjsldkj", token.GetPayloadValue<string>(Parameters.State));
Assert.Equal("Fabrikam", token.GetPayloadValue<string>(Parameters.ClientId));
Assert.Equal(["https://www.fabrikam.com/api/1", "https://www.fabrikam.com/api/2"],
token.GetPayloadValue<string[]>(Parameters.Resource));
Assert.True(token.TryGetPayloadValue(Claims.JwtId, out string _));
Assert.True(token.TryGetPayloadValue(Claims.ExpiresAt, out long _));
}
private static ServiceProvider CreateProvider(bool enabled)
{
var services = new ServiceCollection();
services.AddOpenIddict()
.AddClient(options =>
{
options.AllowAuthorizationCodeFlow()
.SetRedirectionEndpointUris("callback/login");
options.AddEphemeralEncryptionKey()
.AddEphemeralSigningKey();
options.AddRegistration(new OpenIddictClientRegistration
{
ClientId = "Fabrikam",
Configuration = new OpenIddictConfiguration
{
Issuer = new Uri("https://www.contoso.com/", UriKind.Absolute)
},
Issuer = new Uri("https://www.contoso.com/", UriKind.Absolute),
SigningCredentials = { new SigningCredentials(SigningKey, SecurityAlgorithms.RsaSha256) },
UseSignedRequestObjects = enabled
});
});
return services.BuildServiceProvider();
}
private static ProcessChallengeContext CreateContext(IServiceProvider provider)
{
var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictClientOptions>>().CurrentValue;
var transaction = new OpenIddictClientTransaction
{
CancellationToken = CancellationToken.None,
Configuration = new OpenIddictConfiguration(),
Options = options,
Registration = options.Registrations[0],
Request = new OpenIddictRequest(),
ServiceProvider = provider
};
return new ProcessChallengeContext(transaction)
{
ClientId = "Fabrikam",
GrantType = GrantTypes.AuthorizationCode,
Principal = new ClaimsPrincipal(new ClaimsIdentity())
};
}
}