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.
 
 
 
 
 
 

1284 lines
52 KiB

/*
* Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
* See https://github.com/openiddict/openiddict-core for more information concerning
* the license and the contributors participating to this project.
*/
using System.Collections.Immutable;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.JsonWebTokens;
using Moq;
using OpenIddict.Core;
using Xunit;
using static OpenIddict.Server.OpenIddictServerEvents;
using static OpenIddict.Server.OpenIddictServerHandlers;
using static OpenIddict.Server.OpenIddictServerHandlers.Protection;
namespace OpenIddict.Server.IntegrationTests;
public abstract partial class OpenIddictServerIntegrationTests
{
private const string LogoutSessionId = "3E228451-1555-46F7-A471-951EFBA23A56";
[Fact]
public async Task HandleConfigurationRequest_LogoutMetadataAreNotReturnedByDefault()
{
// Arrange
await using var server = await CreateServerAsync(options => options.EnableDegradedMode());
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/.well-known/openid-configuration");
// Assert
Assert.Null((bool?) response[Metadata.BackchannelLogoutSupported]);
Assert.Null((bool?) response[Metadata.FrontchannelLogoutSupported]);
Assert.Null((string?) response[Metadata.CheckSessionIframe]);
}
[Fact]
public async Task HandleConfigurationRequest_LogoutMetadataAreReturnedWhenEnabled()
{
// Arrange
await using var server = await CreateServerAsync(options =>
{
options.EnableBackchannelLogout()
.EnableFrontchannelLogout()
.EnableSessionManagement()
.SetCheckSessionIframeEndpointUris("/connect/checksession");
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/.well-known/openid-configuration");
// Assert
Assert.True((bool) response[Metadata.BackchannelLogoutSupported]);
Assert.True((bool) response[Metadata.BackchannelLogoutSessionSupported]);
Assert.True((bool) response[Metadata.FrontchannelLogoutSupported]);
Assert.True((bool) response[Metadata.FrontchannelLogoutSessionSupported]);
Assert.EndsWith("/connect/checksession", (string?) response[Metadata.CheckSessionIframe], StringComparison.Ordinal);
}
[Fact]
public async Task ProcessSignOut_SessionIsNotRevokedByDefault()
{
// Arrange
var manager = CreateSessionManager();
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(manager);
ConfigureSignOut(options);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Mock.Get(manager).Verify(manager => manager.FindByIdAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Never());
}
[Fact]
public async Task ProcessSignOut_SessionAndTokensAreRevokedWhenEnabled()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
var tokens = CreateTokenManager(mock =>
{
mock.Setup(manager => manager.RevokeBySessionIdAsync(LogoutSessionId, It.IsAny<CancellationToken>()))
.ReturnsAsync(2);
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(tokens);
options.EnableSessionRevocationOnSignOut();
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(session, It.IsAny<CancellationToken>()), Times.Once());
Mock.Get(tokens).Verify(manager => manager.RevokeBySessionIdAsync(LogoutSessionId, It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task ProcessSignOut_SessionIsResolvedFromIdentityTokenHintWhenEnabled()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.EnableSessionRevocationOnSignOut();
options.EnableIdentityTokenHintSessionResolution();
options.AddEventHandler<ValidateTokenContext>(builder =>
{
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetTokenType(TokenTypeIdentifiers.IdentityToken)
.SetClaim(Claims.Subject, "Bob le Bricoleur")
.SetClaim(Claims.SessionId, LogoutSessionId);
return ValueTask.CompletedTask;
});
builder.SetOrder(ValidateIdentityModelToken.Descriptor.Order - 500);
});
ConfigureSignOut(options);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession", new OpenIddictRequest
{
IdTokenHint = "id_token"
});
// Assert
Assert.Null(response.Error);
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(session, It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task ProcessSignOut_SessionsSharingLoginIdentifierAreRevoked()
{
// Arrange
var session = new OpenIddictSession();
var other = new OpenIddictSession();
var foreign = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: "login", mock =>
{
mock.Setup(manager => manager.FindByLoginIdAsync("login", It.IsAny<CancellationToken>()))
.Returns(new[] { session, other, foreign }.ToAsyncEnumerable());
mock.Setup(manager => manager.GetIdAsync(other, It.IsAny<CancellationToken>()))
.ReturnsAsync("other");
mock.Setup(manager => manager.GetSubjectAsync(other, It.IsAny<CancellationToken>()))
.ReturnsAsync("Bob le Bricoleur");
mock.Setup(manager => manager.HasStatusAsync(other, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
// Sessions attached to a different subject are never terminated.
mock.Setup(manager => manager.GetIdAsync(foreign, It.IsAny<CancellationToken>()))
.ReturnsAsync("foreign");
mock.Setup(manager => manager.GetSubjectAsync(foreign, It.IsAny<CancellationToken>()))
.ReturnsAsync("Bob l'Eponge");
mock.Setup(manager => manager.HasStatusAsync(foreign, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.EnableSessionRevocationOnSignOut();
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(session, It.IsAny<CancellationToken>()), Times.Once());
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(other, It.IsAny<CancellationToken>()), Times.Once());
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(foreign, It.IsAny<CancellationToken>()), Times.Never());
}
[Fact]
public async Task ProcessSignOut_BackchannelLogoutTokenIsSentToParticipants()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
var applications = CreateLogoutApplicationManager(new Dictionary<string, string>(StringComparer.Ordinal)
{
[Settings.Logout.BackchannelLogoutUri] = "https://www.fabrikam.com/logout/backchannel"
});
SendBackchannelLogoutRequestContext? notification = null;
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(applications);
options.SetIssuer("https://www.contoso.com/");
options.EnableBackchannelLogout();
options.AddEventHandler<SendBackchannelLogoutRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
notification = context;
context.IsSent = true;
return ValueTask.CompletedTask;
}));
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Assert.NotNull(notification);
Assert.Equal("https://www.fabrikam.com/logout/backchannel", notification.Uri.AbsoluteUri);
Assert.Equal("Fabrikam", notification.Participant.ClientId);
var token = new JsonWebToken(notification.LogoutToken);
Assert.Equal(JsonWebTokenTypes.LogoutToken, token.Typ);
Assert.Equal("https://www.contoso.com/", token.Issuer);
Assert.Equal("Fabrikam", Assert.Single(token.Audiences));
Assert.Equal("Bob le Bricoleur", token.Subject);
Assert.Equal(LogoutSessionId, token.GetPayloadValue<string>(Claims.SessionId));
Assert.False(string.IsNullOrEmpty(token.Id));
Assert.True(token.TryGetPayloadValue(Claims.IssuedAt, out long _));
Assert.True(token.TryGetPayloadValue(Claims.ExpiresAt, out long _));
Assert.False(token.TryGetPayloadValue(Claims.Nonce, out string _));
Assert.True(token.TryGetPayloadValue(Claims.Events, out JsonElement events));
Assert.Equal(JsonValueKind.Object, events.GetProperty(SecurityEventTypes.BackchannelLogout).ValueKind);
}
[Fact]
public async Task ProcessSignOut_BackchannelLogoutFailureDoesNotPreventSignOut()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
var applications = CreateLogoutApplicationManager(new Dictionary<string, string>(StringComparer.Ordinal)
{
[Settings.Logout.BackchannelLogoutUri] = "https://www.fabrikam.com/logout/backchannel"
});
ProcessSessionTerminationContext? termination = null;
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(applications);
options.EnableBackchannelLogout();
options.AddEventHandler<SendBackchannelLogoutRequestContext>(builder =>
builder.UseInlineHandler(context => throw new HttpRequestException("The request timed out.")));
options.AddEventHandler<ApplyEndSessionResponseContext>(builder =>
builder.UseInlineHandler(context =>
{
termination = context.Transaction.GetProperty<ProcessSessionTerminationContext>(
typeof(ProcessSessionTerminationContext).FullName!);
return ValueTask.CompletedTask;
}));
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Assert.NotNull(termination);
Assert.Equal("Fabrikam", Assert.Single(termination.FailedParticipants).ClientId);
Assert.Empty(termination.NotifiedParticipants);
}
[Fact]
public async Task ProcessSignOut_SessionIsNotResolvedFromIdentityTokenHintByDefault()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.EnableSessionRevocationOnSignOut();
options.AddEventHandler<ValidateTokenContext>(builder =>
{
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetTokenType(TokenTypeIdentifiers.IdentityToken)
.SetClaim(Claims.Subject, "Bob le Bricoleur")
.SetClaim(Claims.SessionId, LogoutSessionId);
return ValueTask.CompletedTask;
});
builder.SetOrder(ValidateIdentityModelToken.Descriptor.Order - 500);
});
ConfigureSignOut(options);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession", new OpenIddictRequest
{
IdTokenHint = "id_token"
});
// Assert
Assert.Null(response.Error);
Mock.Get(sessions).Verify(manager => manager.FindByIdAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Never());
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(It.IsAny<OpenIddictSession>(), It.IsAny<CancellationToken>()), Times.Never());
}
[Fact]
public async Task ProcessSignOut_ExpiredSessionIsTerminatedUsingSignedIdentityTokenHint()
{
// Arrange
var session = new OpenIddictSession();
var token = new OpenIddictToken();
var sessions = CreateLogoutSessionManager(session, login: null, mock =>
{
// The session has expired: the identity token hint must still be accepted (RP-Initiated Logout 1.0, section 2).
mock.Setup(manager => manager.HasExpiredAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
var tokens = CreateTokenManager(mock =>
{
mock.Setup(manager => manager.CreateAsync(It.IsAny<OpenIddictTokenDescriptor>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(token);
mock.Setup(manager => manager.GetIdAsync(token, It.IsAny<CancellationToken>()))
.ReturnsAsync("3E228451-1555-46F7-A471-951EFBA23A58");
mock.Setup(manager => manager.FindByIdAsync("3E228451-1555-46F7-A471-951EFBA23A58", It.IsAny<CancellationToken>()))
.ReturnsAsync(token);
mock.Setup(manager => manager.GetTypeAsync(token, It.IsAny<CancellationToken>()))
.ReturnsAsync(TokenTypeIdentifiers.IdentityToken);
mock.Setup(manager => manager.HasStatusAsync(token, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.GetSessionIdAsync(token, It.IsAny<CancellationToken>()))
.ReturnsAsync(LogoutSessionId);
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(tokens);
options.DisableAuthorizationStorage();
options.EnableSessionRevocationOnSignOut();
options.EnableIdentityTokenHintSessionResolution();
options.AddEventHandler<HandleTokenRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Bricoleur")
.SetScopes(Scopes.OpenId)
.SetSessionId(LogoutSessionId);
return ValueTask.CompletedTask;
}));
ConfigureSignOut(options);
});
await using var client = await server.CreateClientAsync();
var response = await client.PostAsync("/connect/token", new OpenIddictRequest
{
GrantType = GrantTypes.Password,
Username = "johndoe",
Password = "A3ddj3w",
Scope = Scopes.OpenId
});
Assert.Null(response.Error);
Assert.NotNull(response.IdToken);
Assert.Equal(LogoutSessionId, new JsonWebToken(response.IdToken).GetPayloadValue<string>(Claims.SessionId));
// Act
response = await client.GetAsync("/connect/endsession", new OpenIddictRequest
{
IdTokenHint = response.IdToken
});
// Assert
Assert.Null(response.Error);
Mock.Get(tokens).Verify(manager => manager.GetSessionIdAsync(token, It.IsAny<CancellationToken>()), Times.AtLeastOnce());
Mock.Get(sessions).Verify(manager => manager.HasExpiredAsync(session, It.IsAny<CancellationToken>()), Times.Never());
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(session, It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task ProcessSignOut_AuthorizationIsRevokedWhenEnabled()
{
// Arrange
var session = new OpenIddictSession();
var authorization = new OpenIddictAuthorization();
var sessions = CreateLogoutSessionManager(session, login: null, mock =>
{
mock.Setup(manager => manager.GetAuthorizationIdAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync("3E228451-1555-46F7-A471-951EFBA23A59");
});
var authorizations = CreateAuthorizationManager(mock =>
{
mock.Setup(manager => manager.FindByIdAsync("3E228451-1555-46F7-A471-951EFBA23A59", It.IsAny<CancellationToken>()))
.ReturnsAsync(authorization);
mock.Setup(manager => manager.TryRevokeAsync(authorization, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
var tokens = CreateTokenManager();
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(authorizations);
options.Services.AddSingleton(tokens);
options.EnableSessionRevocationOnSignOut();
options.RevokeAuthorizationsOnSessionTermination();
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Mock.Get(authorizations).Verify(manager => manager.TryRevokeAsync(authorization, It.IsAny<CancellationToken>()), Times.Once());
Mock.Get(tokens).Verify(manager => manager.RevokeByAuthorizationIdAsync("3E228451-1555-46F7-A471-951EFBA23A59", It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task ProcessSignOut_AlreadyRevokedSessionIsNotNotifiedAgain()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null, mock =>
{
mock.Setup(manager => manager.HasStatusAsync(session, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(false);
});
var applications = CreateLogoutApplicationManager(new Dictionary<string, string>(StringComparer.Ordinal)
{
[Settings.Logout.BackchannelLogoutUri] = "https://www.fabrikam.com/logout/backchannel"
});
var notified = false;
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(applications);
options.EnableBackchannelLogout();
options.AddEventHandler<SendBackchannelLogoutRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
notified = true;
context.IsSent = true;
return ValueTask.CompletedTask;
}));
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession");
// Assert
Assert.Null(response.Error);
Assert.False(notified);
}
[Fact]
public async Task ApplyAuthorizationResponse_BrowserStateCookiesAreAttachedAndRemovedOnSignOut()
{
// Arrange
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
options.EnableSessionManagement()
.SetCheckSessionIframeEndpointUris("/connect/checksession");
options.AddEventHandler<HandleAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique");
return ValueTask.CompletedTask;
}));
ConfigureSignOut(options);
});
await using var client = await server.CreateClientAsync();
// Act
using var authorization = await client.HttpClient.PostAsync("/connect/authorize", new FormUrlEncodedContent(new Dictionary<string, string>(StringComparer.Ordinal)
{
[Parameters.ClientId] = "Fabrikam",
[Parameters.Nonce] = "n-0S6_WzA2Mj",
[Parameters.RedirectUri] = "http://www.fabrikam.com/path",
[Parameters.ResponseType] = ResponseTypes.Code,
[Parameters.Scope] = Scopes.OpenId
}));
var cookies = authorization.Headers.TryGetValues("Set-Cookie", out var values) ? values.ToList() : [];
// Assert
var state = Assert.Single(cookies, static cookie => cookie.StartsWith("openiddict.browser_state=", StringComparison.Ordinal));
var binding = Assert.Single(cookies, static cookie => cookie.StartsWith("openiddict.browser_state.binding=", StringComparison.Ordinal));
Assert.DoesNotContain("httponly", state, StringComparison.OrdinalIgnoreCase);
Assert.Contains("httponly", binding, StringComparison.OrdinalIgnoreCase);
Assert.Contains("path=/", state, StringComparison.OrdinalIgnoreCase);
// Act
using var request = new HttpRequestMessage(HttpMethod.Get, "/connect/endsession");
request.Headers.Add("Cookie", string.Join("; ", state.Split(';')[0], binding.Split(';')[0]));
using var signout = await client.HttpClient.SendAsync(request);
cookies = signout.Headers.TryGetValues("Set-Cookie", out values) ? values.ToList() : [];
// Assert
Assert.Contains(cookies, static cookie => cookie.StartsWith("openiddict.browser_state=;", StringComparison.Ordinal));
Assert.Contains(cookies, static cookie => cookie.StartsWith("openiddict.browser_state.binding=;", StringComparison.Ordinal));
}
[Fact]
public async Task ApplyAuthorizationResponse_SessionStateIsNotReturnedWithoutOpenIdScope()
{
// Arrange
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
options.EnableSessionManagement()
.SetCheckSessionIframeEndpointUris("/connect/checksession");
options.AddEventHandler<HandleAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique");
return ValueTask.CompletedTask;
}));
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/authorize", new OpenIddictRequest
{
ClientId = "Fabrikam",
RedirectUri = "http://www.fabrikam.com/path",
ResponseType = ResponseTypes.Code
});
// Assert
Assert.Null(response.Error);
Assert.NotNull(response.Code);
Assert.Null((string?) response[Parameters.SessionState]);
}
[Fact]
public async Task ProcessSignIn_ExpiredSessionIsRejectedAndNotExtended()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateSessionManager(mock =>
{
mock.Setup(manager => manager.FindByIdAsync(LogoutSessionId, It.IsAny<CancellationToken>()))
.ReturnsAsync(session);
mock.Setup(manager => manager.HasStatusAsync(session, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.HasExpiredAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.SetDeviceAuthorizationEndpointUris(Array.Empty<Uri>());
options.SetRevocationEndpointUris(Array.Empty<Uri>());
options.Configure(options => options.GrantTypes.Remove(GrantTypes.DeviceCode));
options.DisableTokenStorage();
options.DisableAuthorizationStorage();
options.DisableSlidingRefreshTokenExpiration();
options.SetSessionIdleTimeout(TimeSpan.FromMinutes(30));
options.AddEventHandler<HandleTokenRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique")
.SetSessionId(LogoutSessionId);
return ValueTask.CompletedTask;
}));
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/token", new OpenIddictRequest
{
GrantType = GrantTypes.Password,
Username = "johndoe",
Password = "A3ddj3w"
});
// Assert
Assert.Equal(Errors.InvalidGrant, response.Error);
Assert.Equal(SR.GetResourceString(SR.ID2363), response.ErrorDescription);
Assert.Null(response.AccessToken);
Mock.Get(sessions).Verify(manager => manager.TryExtendAsync(It.IsAny<OpenIddictSession>(), It.IsAny<DateTimeOffset>(),
It.IsAny<DateTimeOffset?>(), It.IsAny<CancellationToken>()), Times.Never());
}
[Fact]
public async Task ProcessSignIn_SessionIsAutomaticallyCreatedWhenEnabled()
{
// Arrange
var session = new OpenIddictSession();
string? identifier = null;
var sessions = CreateSessionManager(mock =>
{
mock.Setup(manager => manager.FindAsync(It.IsAny<(string?, string?, string?, string?, string?)>(), It.IsAny<CancellationToken>()))
.Returns(AsyncEnumerable.Empty<OpenIddictSession>());
mock.Setup(manager => manager.CreateAsync(It.IsAny<OpenIddictSessionDescriptor>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(session);
mock.Setup(manager => manager.GetIdAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(LogoutSessionId);
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(CreateApplicationManager(mock =>
{
var application = new OpenIddictApplication();
mock.Setup(manager => manager.FindByClientIdAsync("Fabrikam", It.IsAny<CancellationToken>()))
.ReturnsAsync(application);
mock.Setup(manager => manager.GetIdAsync(application, It.IsAny<CancellationToken>()))
.ReturnsAsync("3E228451-1555-46F7-A471-951EFBA23A57");
mock.Setup(manager => manager.ValidateRedirectUriAsync(application, "http://www.fabrikam.com/path", It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.HasClientTypeAsync(application, ClientTypes.Public, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.GetSettingsAsync(application, It.IsAny<CancellationToken>()))
.ReturnsAsync(ImmutableDictionary.Create<string, string>(StringComparer.Ordinal));
}));
options.SetDeviceAuthorizationEndpointUris(Array.Empty<Uri>());
options.SetRevocationEndpointUris(Array.Empty<Uri>());
options.Configure(options => options.GrantTypes.Remove(GrantTypes.DeviceCode));
options.DisableTokenStorage();
options.DisableAuthorizationStorage();
options.DisableSlidingRefreshTokenExpiration();
options.EnableAutomaticSessionCreation();
options.AddEventHandler<HandleAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique")
.SetScopes(Scopes.OpenId);
return ValueTask.CompletedTask;
}));
options.AddEventHandler<ProcessSignInContext>(builder =>
{
builder.UseInlineHandler(context =>
{
context.Properties[Properties.LoginId] = "login";
return ValueTask.CompletedTask;
});
builder.SetOrder(Logout.CreateSessionEntry.Descriptor.Order - 1);
});
options.AddEventHandler<ProcessSignInContext>(builder =>
{
builder.UseInlineHandler(context =>
{
identifier = context.Principal?.GetSessionId();
return ValueTask.CompletedTask;
});
builder.SetOrder(Logout.CreateSessionEntry.Descriptor.Order + 1);
});
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/authorize", new OpenIddictRequest
{
ClientId = "Fabrikam",
Nonce = "n-0S6_WzA2Mj",
RedirectUri = "http://www.fabrikam.com/path",
ResponseType = ResponseTypes.Code,
Scope = Scopes.OpenId
});
// Assert
Assert.Null(response.Error);
Assert.Equal(LogoutSessionId, identifier);
Mock.Get(sessions).Verify(manager => manager.CreateAsync(It.Is<OpenIddictSessionDescriptor>(descriptor =>
descriptor.ApplicationId == "3E228451-1555-46F7-A471-951EFBA23A57" &&
descriptor.LoginId == "login" &&
descriptor.Status == Statuses.Valid &&
descriptor.Subject == "Bob le Magnifique"), It.IsAny<CancellationToken>()), Times.Once());
}
[Fact]
public async Task ProcessSignOut_FrontchannelLogoutIframesAreRendered()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
var applications = CreateLogoutApplicationManager(new Dictionary<string, string>(StringComparer.Ordinal)
{
[Settings.Logout.FrontchannelLogoutUri] = "https://www.fabrikam.com/logout/frontchannel?tenant=1"
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(applications);
options.SetIssuer("https://www.contoso.com/");
options.EnableFrontchannelLogout();
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
using var response = await client.HttpClient.GetAsync("/connect/endsession");
var content = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("text/html", response.Content.Headers.ContentType?.MediaType);
Assert.Contains("<iframe", content, StringComparison.Ordinal);
var start = content.IndexOf("src=\"", content.IndexOf("<iframe", StringComparison.Ordinal), StringComparison.Ordinal) + 5;
var uri = new Uri(WebUtility.HtmlDecode(content[start..content.IndexOf('"', start)]), UriKind.Absolute);
Assert.Equal("https://www.fabrikam.com/logout/frontchannel", uri.GetLeftPart(UriPartial.Path));
var parameters = uri.Query.TrimStart('?').Split('&')
.Select(static parameter => parameter.Split('='))
.ToDictionary(static parts => parts[0], static parts => Uri.UnescapeDataString(parts[1]), StringComparer.Ordinal);
Assert.Equal("1", parameters["tenant"]);
Assert.Equal("https://www.contoso.com/", parameters[Parameters.Iss]);
Assert.Equal(LogoutSessionId, parameters[Parameters.Sid]);
Assert.Contains("frame-src https://www.fabrikam.com", string.Join(';', response.Headers.GetValues("Content-Security-Policy")), StringComparison.Ordinal);
// Front-channel logout doesn't revoke the session unless session revocation is enabled.
Mock.Get(sessions).Verify(manager => manager.TryRevokeAsync(session, It.IsAny<CancellationToken>()), Times.Never());
}
[Fact]
public async Task ProcessSignOut_FrontchannelLogoutPageRedirectsToPostLogoutRedirectUri()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
var applications = CreateLogoutApplicationManager(new Dictionary<string, string>(StringComparer.Ordinal)
{
[Settings.Logout.FrontchannelLogoutUri] = "https://www.fabrikam.com/logout/frontchannel"
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(applications);
options.EnableFrontchannelLogout();
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
using var response = await client.HttpClient.GetAsync("/connect/endsession?post_logout_redirect_uri=http%3A%2F%2Fwww.fabrikam.com%2Fpath&state=af0ifjsldkj");
var content = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Contains("www.fabrikam.com", content, StringComparison.Ordinal);
Assert.Contains("state=af0ifjsldkj", content, StringComparison.Ordinal);
Assert.Contains("window.location.replace", content, StringComparison.Ordinal);
}
[Fact]
public async Task ProcessSignOut_NoFrontchannelLogoutPageIsRenderedWithoutParticipants()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateLogoutSessionManager(session, login: null);
var applications = CreateLogoutApplicationManager(new Dictionary<string, string>(StringComparer.Ordinal));
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.Services.AddSingleton(applications);
options.EnableFrontchannelLogout();
ConfigureSignOut(options, LogoutSessionId);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.GetAsync("/connect/endsession", new OpenIddictRequest
{
PostLogoutRedirectUri = "http://www.fabrikam.com/path",
State = "af0ifjsldkj"
});
// Assert
Assert.Equal("af0ifjsldkj", response.State);
}
[Fact]
public async Task CheckSessionIframe_PageIsReturnedWhenSessionManagementIsEnabled()
{
// Arrange
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
options.EnableSessionManagement()
.SetCheckSessionIframeEndpointUris("/connect/checksession")
.SetBrowserStateCookieName("custom.browser_state");
});
await using var client = await server.CreateClientAsync();
// Act
using var response = await client.HttpClient.GetAsync("/connect/checksession");
var content = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("text/html", response.Content.Headers.ContentType?.MediaType);
Assert.Contains("custom.browser_state", content, StringComparison.Ordinal);
Assert.Contains("postMessage", content, StringComparison.Ordinal);
Assert.Contains("script-src 'nonce-", string.Join(';', response.Headers.GetValues("Content-Security-Policy")), StringComparison.Ordinal);
}
[Fact]
public async Task CheckSessionIframe_PostRequestIsRejected()
{
// Arrange
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
options.EnableSessionManagement()
.SetCheckSessionIframeEndpointUris("/connect/checksession");
});
await using var client = await server.CreateClientAsync();
// Act
using var response = await client.HttpClient.PostAsync("/connect/checksession", new StringContent(string.Empty));
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task ApplyAuthorizationResponse_SessionStateIsReturnedWhenSessionManagementIsEnabled()
{
// Arrange
string? state = null;
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
options.EnableSessionManagement()
.SetCheckSessionIframeEndpointUris("/connect/checksession");
options.AddEventHandler<HandleAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique");
return ValueTask.CompletedTask;
}));
options.AddEventHandler<ApplyAuthorizationResponseContext>(builder =>
{
builder.UseInlineHandler(context =>
{
state = context.Transaction.BrowserState;
return ValueTask.CompletedTask;
});
builder.SetOrder(Logout.AttachSessionState.Descriptor.Order + 1);
});
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/authorize", new OpenIddictRequest
{
ClientId = "Fabrikam",
Nonce = "n-0S6_WzA2Mj",
RedirectUri = "http://www.fabrikam.com/path",
ResponseType = ResponseTypes.Code,
Scope = Scopes.OpenId
});
// Assert
Assert.Null(response.Error);
Assert.NotNull(state);
Assert.Equal(32, state.Length);
var value = (string?) response[Parameters.SessionState];
Assert.NotNull(value);
var salt = value[(value.LastIndexOf('.') + 1)..];
Assert.Equal(OpenIddictServerHelpers.ComputeSessionState("Fabrikam", "http://www.fabrikam.com", state, salt), value);
}
[Fact]
public async Task ApplyAuthorizationResponse_SessionStateIsNotReturnedByDefault()
{
// Arrange
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
options.AddEventHandler<HandleAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique");
return ValueTask.CompletedTask;
}));
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/authorize", new OpenIddictRequest
{
ClientId = "Fabrikam",
Nonce = "n-0S6_WzA2Mj",
RedirectUri = "http://www.fabrikam.com/path",
ResponseType = ResponseTypes.Code,
Scope = Scopes.OpenId
});
// Assert
Assert.Null((string?) response[Parameters.SessionState]);
}
[Fact]
public async Task ProcessSignIn_SessionExpirationIsExtendedWhenIdleTimeoutIsConfigured()
{
// Arrange
var session = new OpenIddictSession();
var sessions = CreateSessionManager(mock =>
{
mock.Setup(manager => manager.FindByIdAsync(LogoutSessionId, It.IsAny<CancellationToken>()))
.ReturnsAsync(session);
mock.Setup(manager => manager.HasStatusAsync(session, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.GetCreationDateAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(DateTimeOffset.UtcNow.AddHours(-1));
mock.Setup(manager => manager.TryExtendAsync(session, It.IsAny<DateTimeOffset>(),
It.IsAny<DateTimeOffset?>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
await using var server = await CreateServerAsync(options =>
{
options.Services.AddSingleton(sessions);
options.SetDeviceAuthorizationEndpointUris(Array.Empty<Uri>());
options.SetRevocationEndpointUris(Array.Empty<Uri>());
options.Configure(options => options.GrantTypes.Remove(GrantTypes.DeviceCode));
options.DisableTokenStorage();
options.DisableAuthorizationStorage();
options.DisableSlidingRefreshTokenExpiration();
options.SetSessionIdleTimeout(TimeSpan.FromMinutes(30));
options.SetSessionLifetime(TimeSpan.FromHours(8));
options.AddEventHandler<HandleTokenRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique")
.SetSessionId(LogoutSessionId);
return ValueTask.CompletedTask;
}));
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/token", new OpenIddictRequest
{
GrantType = GrantTypes.Password,
Username = "johndoe",
Password = "A3ddj3w"
});
// Assert
Assert.Null(response.Error);
Mock.Get(sessions).Verify(manager => manager.TryExtendAsync(session, It.IsAny<DateTimeOffset>(),
It.Is<DateTimeOffset?>(date => date > DateTimeOffset.UtcNow.AddMinutes(25) && date < DateTimeOffset.UtcNow.AddMinutes(35)),
It.IsAny<CancellationToken>()), Times.Once());
}
[Theory]
[InlineData(false)]
[InlineData(true)]
public async Task ProcessSignIn_SessionIdIsAddedToAccessTokensWhenEnabled(bool enabled)
{
// Arrange
ClaimsPrincipal? principal = null;
await using var server = await CreateServerAsync(options =>
{
options.EnableDegradedMode();
if (enabled)
{
options.IncludeSessionIdInAccessTokens();
}
options.AddEventHandler<HandleTokenRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetClaim(Claims.Subject, "Bob le Magnifique")
.SetSessionId(LogoutSessionId);
return ValueTask.CompletedTask;
}));
options.AddEventHandler<ProcessSignInContext>(builder =>
{
builder.UseInlineHandler(context =>
{
principal = context.AccessTokenPrincipal;
return ValueTask.CompletedTask;
});
builder.SetOrder(Logout.AttachAccessTokenSessionId.Descriptor.Order + 1);
});
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/token", new OpenIddictRequest
{
GrantType = GrantTypes.Password,
Username = "johndoe",
Password = "A3ddj3w"
});
// Assert
Assert.Null(response.Error);
Assert.NotNull(principal);
Assert.Equal(enabled ? LogoutSessionId : null, principal.GetClaim(Claims.SessionId));
}
[Fact]
public async Task ValidateToken_RequestIsRejectedWhenSessionAssociatedWithTokenIsExpired()
{
// Arrange
var session = new OpenIddictSession();
var manager = CreateSessionManager(mock =>
{
mock.Setup(manager => manager.FindByIdAsync("DE7F0AF0-9595-4546-BE3D-F6BB43FB5FA5", It.IsAny<CancellationToken>()))
.ReturnsAsync(session);
mock.Setup(manager => manager.HasStatusAsync(session, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.HasExpiredAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
await using var server = await CreateServerAsync(options =>
{
options.AddEventHandler<ValidateTokenContext>(builder =>
{
builder.UseInlineHandler(context =>
{
context.Principal = new ClaimsPrincipal(new ClaimsIdentity("Bearer"))
.SetTokenType(TokenTypeIdentifiers.RefreshToken)
.SetTokenId("60FFF7EA-F98E-437B-937E-5073CC313103")
.SetClaim(Claims.Subject, "Bob le Bricoleur");
return ValueTask.CompletedTask;
});
builder.SetOrder(ValidateIdentityModelToken.Descriptor.Order - 500);
});
options.Services.AddSingleton(CreateTokenManager(mock =>
{
var token = new OpenIddictToken();
mock.Setup(manager => manager.FindByIdAsync("60FFF7EA-F98E-437B-937E-5073CC313103", It.IsAny<CancellationToken>()))
.ReturnsAsync(token);
mock.Setup(manager => manager.GetIdAsync(token, It.IsAny<CancellationToken>()))
.ReturnsAsync("60FFF7EA-F98E-437B-937E-5073CC313103");
mock.Setup(manager => manager.GetTypeAsync(token, It.IsAny<CancellationToken>()))
.ReturnsAsync(TokenTypeIdentifiers.RefreshToken);
mock.Setup(manager => manager.HasStatusAsync(token, Statuses.Redeemed, It.IsAny<CancellationToken>()))
.ReturnsAsync(false);
mock.Setup(manager => manager.HasStatusAsync(token, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.GetSessionIdAsync(token, It.IsAny<CancellationToken>()))
.ReturnsAsync("DE7F0AF0-9595-4546-BE3D-F6BB43FB5FA5");
}));
options.Services.AddSingleton(manager);
});
await using var client = await server.CreateClientAsync();
// Act
var response = await client.PostAsync("/connect/token", new OpenIddictRequest
{
GrantType = GrantTypes.RefreshToken,
RefreshToken = "8xLOxBtZp8"
});
// Assert
Assert.Equal(SR.GetResourceString(SR.ID2210), response.ErrorDescription);
Mock.Get(manager).Verify(manager => manager.HasExpiredAsync(session, It.IsAny<CancellationToken>()), Times.Once());
}
private static void ConfigureSignOut(OpenIddictServerBuilder options, string? session = null)
{
options.AddEventHandler<HandleEndSessionRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
context.SignOut();
return ValueTask.CompletedTask;
}));
if (session is not null)
{
options.AddEventHandler<ProcessSignOutContext>(builder =>
{
builder.UseInlineHandler(context =>
{
context.Properties[Properties.SessionId] = session;
return ValueTask.CompletedTask;
});
builder.SetOrder(Logout.TerminateSignOutSession.Descriptor.Order - 100);
});
}
}
private OpenIddictSessionManager<OpenIddictSession> CreateLogoutSessionManager(
OpenIddictSession session, string? login,
Action<Mock<OpenIddictSessionManager<OpenIddictSession>>>? configuration = null)
=> CreateSessionManager(mock =>
{
mock.Setup(manager => manager.FindByIdAsync(LogoutSessionId, It.IsAny<CancellationToken>()))
.ReturnsAsync(session);
mock.Setup(manager => manager.GetIdAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(LogoutSessionId);
mock.Setup(manager => manager.GetLoginIdAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync(login);
mock.Setup(manager => manager.GetSubjectAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync("Bob le Bricoleur");
mock.Setup(manager => manager.GetApplicationIdAsync(session, It.IsAny<CancellationToken>()))
.ReturnsAsync("3E228451-1555-46F7-A471-951EFBA23A57");
mock.Setup(manager => manager.HasStatusAsync(session, Statuses.Valid, It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
mock.Setup(manager => manager.TryRevokeAsync(It.IsAny<OpenIddictSession>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
configuration?.Invoke(mock);
});
private OpenIddictApplicationManager<OpenIddictApplication> CreateLogoutApplicationManager(
Dictionary<string, string> settings)
=> CreateApplicationManager(mock =>
{
var application = new OpenIddictApplication();
mock.Setup(manager => manager.FindByIdAsync("3E228451-1555-46F7-A471-951EFBA23A57", It.IsAny<CancellationToken>()))
.ReturnsAsync(application);
mock.Setup(manager => manager.GetClientIdAsync(application, It.IsAny<CancellationToken>()))
.ReturnsAsync("Fabrikam");
mock.Setup(manager => manager.GetSettingsAsync(application, It.IsAny<CancellationToken>()))
.ReturnsAsync(settings.ToImmutableDictionary(StringComparer.Ordinal));
mock.Setup(manager => manager.FindByPostLogoutRedirectUriAsync("http://www.fabrikam.com/path", It.IsAny<CancellationToken>()))
.Returns(new[] { application }.ToAsyncEnumerable());
mock.Setup(manager => manager.ValidatePostLogoutRedirectUriAsync(application, "http://www.fabrikam.com/path", It.IsAny<CancellationToken>()))
.ReturnsAsync(true);
});
}