diff --git a/NetDevPack.Identity.sln b/NetDevPack.Identity.sln index 1911d14..7a9d2a4 100644 --- a/NetDevPack.Identity.sln +++ b/NetDevPack.Identity.sln @@ -11,20 +11,56 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Pack", "Pack", "{7985C809-6 EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AspNetCore.Jwt.Sample", "src\Samples\AspNetCore.Jwt.Sample\AspNetCore.Jwt.Sample.csproj", "{B5BE907B-0C79-489F-99BD-2AD82FA727E3}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0AB3BF05-4346-4AA6-1389-037BE0695223}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NetDevPack.Identity.Tests", "tests\NetDevPack.Identity.Tests\NetDevPack.Identity.Tests.csproj", "{85BF6109-3FD5-4E5E-908E-4192A26EA8AB}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {43A11876-765D-4387-BC28-4C9371DDD62D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {43A11876-765D-4387-BC28-4C9371DDD62D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Debug|x64.ActiveCfg = Debug|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Debug|x64.Build.0 = Debug|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Debug|x86.ActiveCfg = Debug|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Debug|x86.Build.0 = Debug|Any CPU {43A11876-765D-4387-BC28-4C9371DDD62D}.Release|Any CPU.ActiveCfg = Release|Any CPU {43A11876-765D-4387-BC28-4C9371DDD62D}.Release|Any CPU.Build.0 = Release|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Release|x64.ActiveCfg = Release|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Release|x64.Build.0 = Release|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Release|x86.ActiveCfg = Release|Any CPU + {43A11876-765D-4387-BC28-4C9371DDD62D}.Release|x86.Build.0 = Release|Any CPU {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Debug|x64.ActiveCfg = Debug|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Debug|x64.Build.0 = Debug|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Debug|x86.ActiveCfg = Debug|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Debug|x86.Build.0 = Debug|Any CPU {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Release|Any CPU.ActiveCfg = Release|Any CPU {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Release|Any CPU.Build.0 = Release|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Release|x64.ActiveCfg = Release|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Release|x64.Build.0 = Release|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Release|x86.ActiveCfg = Release|Any CPU + {B5BE907B-0C79-489F-99BD-2AD82FA727E3}.Release|x86.Build.0 = Release|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Debug|x64.ActiveCfg = Debug|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Debug|x64.Build.0 = Debug|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Debug|x86.ActiveCfg = Debug|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Debug|x86.Build.0 = Debug|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Release|Any CPU.Build.0 = Release|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Release|x64.ActiveCfg = Release|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Release|x64.Build.0 = Release|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Release|x86.ActiveCfg = Release|Any CPU + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -32,6 +68,7 @@ Global GlobalSection(NestedProjects) = preSolution {43A11876-765D-4387-BC28-4C9371DDD62D} = {7985C809-6CBD-44C2-BEA7-1AD828707F3E} {B5BE907B-0C79-489F-99BD-2AD82FA727E3} = {8A673A3F-D855-4F9B-BA0B-0D2B5DE369EB} + {85BF6109-3FD5-4E5E-908E-4192A26EA8AB} = {0AB3BF05-4346-4AA6-1389-037BE0695223} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {C92C10D5-BEA9-4EC0-BD95-6228657E412D} diff --git a/global.json b/global.json new file mode 100644 index 0000000..1d364c6 --- /dev/null +++ b/global.json @@ -0,0 +1,9 @@ +{ + "sdk": { + "version": "10.0.100", + "rollForward": "latestFeature" + }, + "test": { + "runner": "Microsoft.Testing.Platform" + } +} diff --git a/src/NetDevPack.Identity/Jwt/JwtBuilderInject.cs b/src/NetDevPack.Identity/Jwt/JwtBuilderInject.cs index 6b80d9b..834f0b1 100644 --- a/src/NetDevPack.Identity/Jwt/JwtBuilderInject.cs +++ b/src/NetDevPack.Identity/Jwt/JwtBuilderInject.cs @@ -39,6 +39,8 @@ internal class JwtBuilderInject : IJwtBuilder private string _email; private string _username; + private const string RefreshTokenJwtType = "rt+jwt"; + private bool _useClaims; private bool _useRoles; private bool _useRt; @@ -135,9 +137,7 @@ public async Task BuildRefreshToken() var handler = new JwtSecurityTokenHandler(); - var issuer = _settings.Value.Issuer; - if (string.IsNullOrEmpty(issuer)) - issuer = $"{_httpContext.HttpContext.Request.Scheme}://{_httpContext.HttpContext.Request.Host}"; + var issuer = GetIssuer(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { @@ -147,7 +147,7 @@ public async Task BuildRefreshToken() Subject = identityClaims, NotBefore = DateTime.UtcNow, Expires = DateTime.UtcNow.AddDays(_settings.Value.RefreshTokenExpiration), - TokenType = "rt+jwt" + TokenType = RefreshTokenJwtType }); await UpdateLastGeneratedClaim(jti, user); var encodedJwt = handler.WriteToken(securityToken); @@ -196,9 +196,7 @@ public async Task BuildToken() _identityClaims.AddClaims(_userClaims); } - var issuer = _settings.Value.Issuer; - if (string.IsNullOrEmpty(issuer)) - issuer = $"{_httpContext.HttpContext.Request.Scheme}://{_httpContext.HttpContext.Request.Host}"; + var issuer = GetIssuer(); var token = tokenHandler.CreateToken(new SecurityTokenDescriptor { @@ -262,21 +260,29 @@ public async Task BuildUserResponse() public async Task ValidateRefreshToken(string refreshToken) { + if (string.IsNullOrWhiteSpace(refreshToken)) + return new RefreshTokenValidation(false, reason: "Invalid refresh token"); + var handler = new JsonWebTokenHandler(); - var result = handler.ValidateToken(refreshToken, new TokenValidationParameters() + // RequireSignedTokens is true by default: unsigned ("alg": "none") tokens are rejected. + // ValidTypes makes sure an access token (at+jwt) can't be used as a refresh token. + var result = await handler.ValidateTokenAsync(refreshToken, new TokenValidationParameters { - RequireSignedTokens = false, - ValidIssuer = _settings.Value.Issuer, + ValidIssuer = GetIssuer(), ValidAudience = _settings.Value.Audience, - IssuerSigningKey = await _jwtService.GetCurrentSecurityKey(), + IssuerSigningKeys = await GetValidationKeys(), + ValidTypes = new[] { RefreshTokenJwtType }, }); if (!result.IsValid) - return new RefreshTokenValidation(false); + return new RefreshTokenValidation(false, reason: "Invalid refresh token"); + var userId = result.ClaimsIdentity.GetUserId(); + var user = string.IsNullOrEmpty(userId) ? null : await _userManager.FindByIdAsync(userId); + if (user is null) + return new RefreshTokenValidation(false, reason: "User not found"); - var user = await _userManager.FindByIdAsync(result.ClaimsIdentity.GetUserId()); var claims = await _userManager.GetClaimsAsync(user); var jti = result.ClaimsIdentity.GetJwtId(); @@ -285,11 +291,33 @@ public async Task ValidateRefreshToken(string refreshTok if (!claims.Any(c => c.Type == "LastRefreshToken" && c.Value == jti)) return new RefreshTokenValidation(false, reason: "Refresh Token already used"); - if (user.LockoutEnabled) - if (user.LockoutEnd < DateTime.Now) - return new RefreshTokenValidation(false, reason: "User blocked"); + if (await _userManager.IsLockedOutAsync(user)) + return new RefreshTokenValidation(false, reason: "User blocked"); + + return new RefreshTokenValidation(true, user.Id.ToString()); + } + + private string GetIssuer() + { + var issuer = _settings.Value.Issuer; + if (string.IsNullOrEmpty(issuer)) + issuer = $"{_httpContext.HttpContext.Request.Scheme}://{_httpContext.HttpContext.Request.Host}"; + return issuer; + } + + /// + /// Keys that may have signed a refresh token: the configured symmetric key, or the last keys of the JWKS store + /// (so tokens signed before a key rotation are still accepted until they expire). + /// + private async Task> GetValidationKeys() + { +#pragma warning disable CS0618 // SecretKey is obsolete but still supported + if (!string.IsNullOrEmpty(_settings.Value.SecretKey)) + return new[] { new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_settings.Value.SecretKey)) }; +#pragma warning restore CS0618 - return new RefreshTokenValidation(true, result.ClaimsIdentity.GetUserId()); + var keys = await _jwtService.GetLastKeys(); + return keys.Select(k => (SecurityKey)k.GetSecurityKey()).ToList(); } private static long ToUnixEpochDate(DateTime date) diff --git a/src/NetDevPack.Identity/NetDevPack.Identity.csproj b/src/NetDevPack.Identity/NetDevPack.Identity.csproj index 066135e..ee88920 100644 --- a/src/NetDevPack.Identity/NetDevPack.Identity.csproj +++ b/src/NetDevPack.Identity/NetDevPack.Identity.csproj @@ -21,13 +21,19 @@ - - + + + + + - - + + + + + @@ -44,9 +50,13 @@ + + + + - + diff --git a/src/Samples/AspNetCore.Jwt.Sample/AspNetCore.Jwt.Sample.csproj b/src/Samples/AspNetCore.Jwt.Sample/AspNetCore.Jwt.Sample.csproj index 84cc339..82addd5 100644 --- a/src/Samples/AspNetCore.Jwt.Sample/AspNetCore.Jwt.Sample.csproj +++ b/src/Samples/AspNetCore.Jwt.Sample/AspNetCore.Jwt.Sample.csproj @@ -8,18 +8,18 @@ - - - + + + all runtime; build; native; contentfiles; analyzers; buildtransitive - - - + + + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/tests/NetDevPack.Identity.Tests/JwksIntegrationTests.cs b/tests/NetDevPack.Identity.Tests/JwksIntegrationTests.cs new file mode 100644 index 0000000..77ab60e --- /dev/null +++ b/tests/NetDevPack.Identity.Tests/JwksIntegrationTests.cs @@ -0,0 +1,127 @@ +using AwesomeAssertions; +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Hosting; +using Microsoft.AspNetCore.Identity; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.IdentityModel.JsonWebTokens; +using Microsoft.IdentityModel.Tokens; +using NetDevPack.Identity.Interfaces; +using NetDevPack.Identity.Jwt; +using Xunit; +using JwtRegisteredClaimNames = System.IdentityModel.Tokens.Jwt.JwtRegisteredClaimNames; + +namespace NetDevPack.Identity.Tests; + +/// +/// The point of NetDevPack.Identity is to issue tokens that other services validate through JWKS: +/// they only need the public keys published at /jwks, never a shared secret. +/// +public class JwksIntegrationTests : IAsyncLifetime +{ + private const string Issuer = "https://identity.netdevpack.test"; + private const string Audience = "netdevpack-api"; + private const string Email = "user@netdevpack.test"; + + private WebApplication _app = null!; + private HttpClient _http = null!; + private IdentityUser _user = null!; + + public async ValueTask InitializeAsync() + { + var builder = WebApplication.CreateBuilder(); + builder.WebHost.UseUrls("http://127.0.0.1:0"); + var databaseName = Guid.NewGuid().ToString(); + builder.Services.AddIdentityEntityFrameworkContextConfiguration(o => o.UseInMemoryDatabase(databaseName)); + builder.Services.AddIdentityConfiguration(); + builder.Services.Configure(o => + { + o.Issuer = Issuer; + o.Audience = Audience; + }); + builder.Services.AddNetDevPackIdentity().PersistKeysInMemory(); + + _app = builder.Build(); + _app.UseJwksDiscovery(); + await _app.StartAsync(); + _http = new HttpClient { BaseAddress = new Uri(_app.Urls.First()) }; + + using var scope = _app.Services.CreateScope(); + var users = scope.ServiceProvider.GetRequiredService>(); + _user = new IdentityUser { UserName = "netdevpack", Email = Email }; + (await users.CreateAsync(_user, "NetDevPack@2026!")).Succeeded.Should().BeTrue(); + } + + public async ValueTask DisposeAsync() + { + _http.Dispose(); + await _app.DisposeAsync(); + } + + private async Task GetPublishedJwks() => + new(await _http.GetStringAsync("/jwks", TestContext.Current.CancellationToken)); + + [Fact] + public async Task JwksEndpoint_ShouldPublishOnlyPublicKeys() + { + // Issue a token first so the store has a key + using (var scope = _app.Services.CreateScope()) + await scope.ServiceProvider.GetRequiredService().WithEmail(Email).WithJwtClaims().BuildToken(); + + var jwks = await GetPublishedJwks(); + + jwks.Keys.Should().NotBeEmpty(); + jwks.Keys.Should().OnlyContain(k => k.D == null && k.P == null && k.Q == null && k.DP == null && k.DQ == null && k.QI == null && k.K == null, + "the JWKS document must never expose private or symmetric key material"); + } + + [Fact] + public async Task AccessToken_ShouldBeValidatedByThirdPartyUsingOnlyThePublishedJwks() + { + string accessToken; + using (var scope = _app.Services.CreateScope()) + { + accessToken = (await scope.ServiceProvider.GetRequiredService() + .WithEmail(Email).WithJwtClaims().WithRefreshToken().BuildUserResponse()).AccessToken; + } + + // A resource server only knows the issuer, the audience and the JWKS URL + var jwks = await GetPublishedJwks(); + var result = await new JsonWebTokenHandler().ValidateTokenAsync(accessToken, new TokenValidationParameters + { + ValidIssuer = Issuer, + ValidAudience = Audience, + IssuerSigningKeys = jwks.GetSigningKeys(), + }); + + result.IsValid.Should().BeTrue(result.Exception?.Message); + result.ClaimsIdentity.FindFirst(JwtRegisteredClaimNames.Sub)!.Value.Should().Be(_user.Id); + ((JsonWebToken)result.SecurityToken).Alg.Should().NotStartWith("HS", "tokens must be signed with the asymmetric JWKS key, not a shared secret"); + } + + [Fact] + public async Task RefreshToken_ShouldBeSignedWithTheJwksKeyAndStillWork() + { + string refreshToken; + using (var scope = _app.Services.CreateScope()) + { + refreshToken = (await scope.ServiceProvider.GetRequiredService() + .WithEmail(Email).WithRefreshToken().BuildUserResponse()).RefreshToken; + } + + var jwks = await GetPublishedJwks(); + var signature = await new JsonWebTokenHandler().ValidateTokenAsync(refreshToken, new TokenValidationParameters + { + ValidIssuer = Issuer, + ValidAudience = Audience, + IssuerSigningKeys = jwks.GetSigningKeys(), + }); + signature.IsValid.Should().BeTrue(signature.Exception?.Message); + + using (var scope = _app.Services.CreateScope()) + { + var validation = await scope.ServiceProvider.GetRequiredService().ValidateRefreshToken(refreshToken); + validation.IsValid.Should().BeTrue(validation.Reason); + } + } +} diff --git a/tests/NetDevPack.Identity.Tests/JwtBuilderTests.cs b/tests/NetDevPack.Identity.Tests/JwtBuilderTests.cs new file mode 100644 index 0000000..3d9e4f9 --- /dev/null +++ b/tests/NetDevPack.Identity.Tests/JwtBuilderTests.cs @@ -0,0 +1,155 @@ +using System.Security.Claims; +using AwesomeAssertions; +using Microsoft.AspNetCore.Identity; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.IdentityModel.JsonWebTokens; +using Microsoft.IdentityModel.Tokens; +using NetDevPack.Identity.Interfaces; +using NetDevPack.Identity.Jwt; +using NetDevPack.Security.Jwt.Core.Interfaces; +using Xunit; +using JwtRegisteredClaimNames = System.IdentityModel.Tokens.Jwt.JwtRegisteredClaimNames; + +namespace NetDevPack.Identity.Tests; + +public class JwtBuilderTests : IAsyncLifetime +{ + private const string Issuer = "https://identity.netdevpack.test"; + private const string Audience = "netdevpack-api"; + private const string Email = "user@netdevpack.test"; + + private ServiceProvider _provider = null!; + private IdentityUser _user = null!; + + public async ValueTask InitializeAsync() + { + var services = new ServiceCollection(); + services.AddLogging(); + var databaseName = Guid.NewGuid().ToString(); + services.AddIdentityEntityFrameworkContextConfiguration(o => o.UseInMemoryDatabase(databaseName)); + services.AddIdentityConfiguration(); + services.Configure(o => + { + o.Issuer = Issuer; + o.Audience = Audience; + o.RefreshTokenType = RefreshTokenType.OneTime; + }); + services.AddNetDevPackIdentity().PersistKeysInMemory(); + _provider = services.BuildServiceProvider(); + + using var scope = _provider.CreateScope(); + var users = scope.ServiceProvider.GetRequiredService>(); + var roles = scope.ServiceProvider.GetRequiredService>(); + + _user = new IdentityUser { UserName = "netdevpack", Email = Email }; + (await users.CreateAsync(_user, "NetDevPack@2026!")).Succeeded.Should().BeTrue(); + (await roles.CreateAsync(new IdentityRole("Admin"))).Succeeded.Should().BeTrue(); + (await users.AddToRoleAsync(_user, "Admin")).Succeeded.Should().BeTrue(); + (await users.AddClaimAsync(_user, new Claim("permission", "orders:read"))).Succeeded.Should().BeTrue(); + } + + public async ValueTask DisposeAsync() => await _provider.DisposeAsync(); + + private async Task ValidateAccessToken(string token) + { + using var scope = _provider.CreateScope(); + // Validate like NetDevPack.Security.Jwt does: against the last keys of the store, not only the current one + var keys = await scope.ServiceProvider.GetRequiredService().GetLastKeys(); + return await new JsonWebTokenHandler().ValidateTokenAsync(token, new TokenValidationParameters + { + ValidIssuer = Issuer, + ValidAudience = Audience, + IssuerSigningKeys = keys.Select(k => (SecurityKey)k.GetSecurityKey()).ToList(), + }); + } + + [Fact] + public async Task BuildUserResponse_ShouldIssueAccessTokenSignedWithCurrentJwksKey() + { + using var scope = _provider.CreateScope(); + var builder = scope.ServiceProvider.GetRequiredService(); + + var response = await builder.WithEmail(Email).WithJwtClaims().WithUserClaims().WithUserRoles().BuildUserResponse(); + + var result = await ValidateAccessToken(response.AccessToken); + result.IsValid.Should().BeTrue(result.Exception?.Message); + ((JsonWebToken)result.SecurityToken).Typ.Should().Be("at+jwt"); + result.ClaimsIdentity.Claims.Should().Contain(c => c.Type == JwtRegisteredClaimNames.Sub && c.Value == _user.Id); + result.ClaimsIdentity.Claims.Should().Contain(c => c.Type == JwtRegisteredClaimNames.Email && c.Value == Email); + result.ClaimsIdentity.Claims.Should().Contain(c => c.Type == "role" && c.Value == "Admin"); + result.ClaimsIdentity.Claims.Should().Contain(c => c.Type == "permission" && c.Value == "orders:read"); + + ((string)response.UserToken.Id).Should().Be(_user.Id); + response.UserToken.Email.Should().Be(Email); + response.UserToken.Claims.Should().ContainSingle(c => c.Type == "permission" && c.Value == "orders:read"); + response.ExpiresIn.Should().Be(TimeSpan.FromHours(1).TotalSeconds); + } + + [Fact] + public async Task BuildToken_ShouldFindUserByIdUsernameOrEmail() + { + // IJwtBuilder is scoped and stateful: use one scope per token + async Task Build(Func select) + { + using var scope = _provider.CreateScope(); + return await select(scope.ServiceProvider.GetRequiredService()).WithJwtClaims().BuildToken(); + } + + var byId = await Build(b => b.WithUserId(_user.Id)); + var byName = await Build(b => b.WithUsername("netdevpack")); + var byEmail = await Build(b => b.WithEmail(Email)); + + foreach (var token in new[] { byId, byName, byEmail }) + { + var result = await ValidateAccessToken(token); + result.IsValid.Should().BeTrue(result.Exception?.Message); + result.ClaimsIdentity.FindFirst(JwtRegisteredClaimNames.Sub)!.Value.Should().Be(_user.Id); + } + } + + [Fact] + public async Task BuildToken_WithoutUserIdentifier_ShouldThrow() + { + using var scope = _provider.CreateScope(); + var builder = scope.ServiceProvider.GetRequiredService(); + + await builder.Invoking(b => b.WithJwtClaims().BuildToken()).Should().ThrowAsync(); + } + + [Fact] + public async Task RefreshToken_OneTime_ShouldOnlyAcceptTheLatestToken() + { + string first, second; + using (var scope = _provider.CreateScope()) + first = (await scope.ServiceProvider.GetRequiredService().WithEmail(Email).WithRefreshToken().BuildUserResponse()).RefreshToken; + + using (var scope = _provider.CreateScope()) + { + var validation = await scope.ServiceProvider.GetRequiredService().ValidateRefreshToken(first); + validation.IsValid.Should().BeTrue(); + validation.UserId.Should().Be(_user.Id); + } + + using (var scope = _provider.CreateScope()) + second = (await scope.ServiceProvider.GetRequiredService().WithEmail(Email).WithRefreshToken().BuildUserResponse()).RefreshToken; + + using (var scope = _provider.CreateScope()) + { + var builder = scope.ServiceProvider.GetRequiredService(); + var old = await builder.ValidateRefreshToken(first); + old.IsValid.Should().BeFalse(); + old.Reason.Should().Be("Refresh Token already used"); + (await builder.ValidateRefreshToken(second)).IsValid.Should().BeTrue(); + } + } + + [Fact] + public async Task ValidateRefreshToken_ShouldRejectGarbage() + { + using var scope = _provider.CreateScope(); + var builder = scope.ServiceProvider.GetRequiredService(); + + (await builder.ValidateRefreshToken("not-a-jwt")).IsValid.Should().BeFalse(); + } +} diff --git a/tests/NetDevPack.Identity.Tests/NetDevPack.Identity.Tests.csproj b/tests/NetDevPack.Identity.Tests/NetDevPack.Identity.Tests.csproj new file mode 100644 index 0000000..acbf375 --- /dev/null +++ b/tests/NetDevPack.Identity.Tests/NetDevPack.Identity.Tests.csproj @@ -0,0 +1,35 @@ + + + + net8.0;net10.0 + Exe + false + true + enable + enable + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/NetDevPack.Identity.Tests/RefreshTokenSecurityTests.cs b/tests/NetDevPack.Identity.Tests/RefreshTokenSecurityTests.cs new file mode 100644 index 0000000..2946f9a --- /dev/null +++ b/tests/NetDevPack.Identity.Tests/RefreshTokenSecurityTests.cs @@ -0,0 +1,174 @@ +using System.Security.Claims; +using System.Security.Cryptography; +using AwesomeAssertions; +using Microsoft.AspNetCore.Identity; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.IdentityModel.JsonWebTokens; +using Microsoft.IdentityModel.Tokens; +using NetDevPack.Identity.Interfaces; +using NetDevPack.Identity.Jwt; +using NetDevPack.Identity.Jwt.Model; +using Xunit; + +namespace NetDevPack.Identity.Tests; + +/// +/// Regression tests for refresh token validation: only signed rt+jwt tokens issued by this +/// application, for an existing and not locked out user, may be accepted. +/// +public class RefreshTokenSecurityTests : IAsyncLifetime +{ + private const string Issuer = "https://identity.netdevpack.test"; + private const string Audience = "netdevpack-api"; + private const string Email = "user@netdevpack.test"; + + private ServiceProvider _provider = null!; + private IdentityUser _user = null!; + + public async ValueTask InitializeAsync() + { + var services = new ServiceCollection(); + services.AddLogging(); + var databaseName = Guid.NewGuid().ToString(); + services.AddIdentityEntityFrameworkContextConfiguration(o => o.UseInMemoryDatabase(databaseName)); + services.AddIdentityConfiguration(); + services.Configure(o => + { + o.Issuer = Issuer; + o.Audience = Audience; + // ReUse skips the "last refresh token" check, so the token itself is the only protection + o.RefreshTokenType = RefreshTokenType.ReUse; + }); + services.AddNetDevPackIdentity().PersistKeysInMemory(); + _provider = services.BuildServiceProvider(); + + using var scope = _provider.CreateScope(); + var users = scope.ServiceProvider.GetRequiredService>(); + _user = new IdentityUser { UserName = "netdevpack", Email = Email }; + (await users.CreateAsync(_user, "NetDevPack@2026!")).Succeeded.Should().BeTrue(); + } + + public async ValueTask DisposeAsync() => await _provider.DisposeAsync(); + + private async Task Validate(string token) + { + using var scope = _provider.CreateScope(); + return await scope.ServiceProvider.GetRequiredService().ValidateRefreshToken(token); + } + + private async Task IssueRefreshToken() + { + using var scope = _provider.CreateScope(); + var response = await scope.ServiceProvider.GetRequiredService() + .WithEmail(Email).WithRefreshToken().BuildUserResponse(); + return response.RefreshToken; + } + + private string ForgeToken(SigningCredentials? credentials, string type = "rt+jwt") => + new JsonWebTokenHandler().CreateToken(new SecurityTokenDescriptor + { + Issuer = Issuer, + Audience = Audience, + Subject = new ClaimsIdentity(new[] + { + new Claim(JwtRegisteredClaimNames.Sub, _user.Id), + new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), + }), + Expires = DateTime.UtcNow.AddDays(1), + SigningCredentials = credentials, + TokenType = type, + }); + + [Fact] + public async Task ShouldAcceptRefreshTokenIssuedByTheApplication() + { + var result = await Validate(await IssueRefreshToken()); + + result.IsValid.Should().BeTrue(result.Reason); + result.UserId.Should().Be(_user.Id); + } + + [Fact] + public async Task ShouldRejectUnsignedRefreshToken() + { + var forged = ForgeToken(credentials: null); + forged.Split('.')[2].Should().BeEmpty("the token must be unsigned (alg: none) for this test"); + + (await Validate(forged)).IsValid.Should().BeFalse(); + } + + [Fact] + public async Task ShouldRejectRefreshTokenSignedWithUnknownKey() + { + using var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256); + var forged = ForgeToken(new SigningCredentials(new ECDsaSecurityKey(ecdsa) { KeyId = "attacker" }, SecurityAlgorithms.EcdsaSha256)); + + (await Validate(forged)).IsValid.Should().BeFalse(); + } + + [Fact] + public async Task ShouldRejectAccessTokenUsedAsRefreshToken() + { + using var scope = _provider.CreateScope(); + var accessToken = await scope.ServiceProvider.GetRequiredService() + .WithEmail(Email).WithJwtClaims().BuildToken(); + + (await Validate(accessToken)).IsValid.Should().BeFalse(); + } + + [Theory] + [InlineData("")] + [InlineData("not-a-jwt")] + public async Task ShouldRejectMalformedRefreshToken(string token) + { + (await Validate(token)).IsValid.Should().BeFalse(); + } + + [Fact] + public async Task ShouldRejectRefreshTokenOfLockedOutUser() + { + var token = await IssueRefreshToken(); + using (var scope = _provider.CreateScope()) + { + var users = scope.ServiceProvider.GetRequiredService>(); + var user = await users.FindByIdAsync(_user.Id); + (await users.SetLockoutEndDateAsync(user!, DateTimeOffset.UtcNow.AddHours(1))).Succeeded.Should().BeTrue(); + } + + var result = await Validate(token); + + result.IsValid.Should().BeFalse(); + result.Reason.Should().Be("User blocked"); + } + + [Fact] + public async Task ShouldAcceptRefreshTokenWhenLockoutHasExpired() + { + var token = await IssueRefreshToken(); + using (var scope = _provider.CreateScope()) + { + var users = scope.ServiceProvider.GetRequiredService>(); + var user = await users.FindByIdAsync(_user.Id); + (await users.SetLockoutEndDateAsync(user!, DateTimeOffset.UtcNow.AddHours(-1))).Succeeded.Should().BeTrue(); + } + + (await Validate(token)).IsValid.Should().BeTrue(); + } + + [Fact] + public async Task ShouldRejectRefreshTokenOfDeletedUser() + { + var token = await IssueRefreshToken(); + using (var scope = _provider.CreateScope()) + { + var users = scope.ServiceProvider.GetRequiredService>(); + (await users.DeleteAsync((await users.FindByIdAsync(_user.Id))!)).Succeeded.Should().BeTrue(); + } + + var result = await Validate(token); + + result.IsValid.Should().BeFalse(); + result.Reason.Should().Be("User not found"); + } +} diff --git a/tests/NetDevPack.Identity.Tests/xunit.runner.json b/tests/NetDevPack.Identity.Tests/xunit.runner.json new file mode 100644 index 0000000..08c512b --- /dev/null +++ b/tests/NetDevPack.Identity.Tests/xunit.runner.json @@ -0,0 +1,4 @@ +{ + "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json", + "parallelizeTestCollections": false +}