From a43ba0c4335118cc18e55838f19bff680cb82060 Mon Sep 17 00:00:00 2001 From: Bruno Brito Date: Tue, 17 Nov 2026 18:25:45 -0300 Subject: [PATCH 1/2] fix(deps): patch vulnerable crypto packages System.Security.Cryptography.Xml/Pkcs 10.0.12 (pulled by 10.0.0) have high severity advisories. Pin the patched versions per TFM (8.0.5/8.0.2, 9.0.23, 10.0.15) and bump the Microsoft.* packages to the latest patch of each line (8.0.34, 9.0.23, 10.0.15). The PR vulnerability check now ignores only the accepted IdentityServer4 advisory (ADR-002). --- .github/workflows/pull-request.yml | 3 +- Directory.Packages.props | 91 +++++++++++++++--------------- 2 files changed, 49 insertions(+), 45 deletions(-) diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml index 13cba00..2446fe1 100644 --- a/.github/workflows/pull-request.yml +++ b/.github/workflows/pull-request.yml @@ -39,4 +39,5 @@ jobs: - name: Check vulnerable packages run: | dotnet list package --vulnerable --include-transitive 2>&1 | tee vulnerable.txt - ! grep -q "has the following vulnerable packages" vulnerable.txt + # IdentityServer4 is EOL with known advisories and is accepted on purpose (docs/Decisions/ADR-002) + ! grep -E '^\s+>' vulnerable.txt | grep -v ' IdentityServer4 ' diff --git a/Directory.Packages.props b/Directory.Packages.props index 683ed0f..a99f97e 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -30,59 +30,62 @@ - - - - - - - - - - - + + + + + + + + + + + - + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + From 48667ccb285d97f96dc2c77edd15167a24eaa7d1 Mon Sep 17 00:00:00 2001 From: Bruno Brito Date: Tue, 17 Nov 2026 20:30:58 -0300 Subject: [PATCH 2/2] fix: isolate in-memory key store per container PersistKeysInMemory kept the keys in a static list, so every host in the same process (e.g. parallel integration tests) shared and overwrote the same keys. The store is now a singleton with an instance list guarded by a lock, so scopes of one application still share keys and different service providers don't. --- docs/Architecture/Stores.md | 4 +- .../DefaultStore/InMemoryStore.cs | 54 +++++++++++-------- ...JsonWebKeySetManagerDependencyInjection.cs | 5 +- .../StoreTests/InMemoryStoreIsolationTests.cs | 46 ++++++++++++++++ 4 files changed, 82 insertions(+), 27 deletions(-) create mode 100644 tests/NetDevPack.Security.Jwt.Tests/StoreTests/InMemoryStoreIsolationTests.cs diff --git a/docs/Architecture/Stores.md b/docs/Architecture/Stores.md index 03b166f..475bb63 100644 --- a/docs/Architecture/Stores.md +++ b/docs/Architecture/Stores.md @@ -1,6 +1,6 @@ --- tags: [architecture, storage] -updated: 2026-10-01 +updated: 2026-11-17 --- # Stores (`IJsonWebKeyStore`) @@ -9,7 +9,7 @@ Contract (`Interfaces/IJsonWebKeyStore.cs`): `Store`, `GetCurrent(type)`, `Revok | Store | Registration | Persistence | Notes | | --- | --- | --- | --- | | `DataProtectionStore` (default, internal) | `AddJwksManager()` | ASP.NET DataProtection `IXmlRepository` (same place as cookie keys) | Payload protected with `IDataProtector`. Revocation is a separate XML element because `IXmlRepository` can't update. If no repository can be found, it falls back to Azure WebSites → default folder → Windows registry, then throws | -| `InMemoryStore` | `.PersistKeysInMemory()` | Process memory | Tests/dev only | +| `InMemoryStore` | `.PersistKeysInMemory()` | Memory of the service provider (singleton) | Tests/dev only. Each service provider has its own keys: hosts in the same process (e.g. parallel tests) don't share them. Lost on restart | | `FileSystemStore` | `.PersistKeysToFileSystem(dir)` | JSON files in a folder | Needs `IMemoryCache` | | `DatabaseJsonWebKeyStore` | `.PersistKeysToDatabaseStore()` | EF Core, `TContext : DbContext, ISecurityKeyContext` (`DbSet SecurityKeys`) | Mapping in `KeyMaterialMap.cs`; uses `AsNoTrackingWithIdentityResolution` | diff --git a/src/NetDevPack.Security.Jwt.Core/DefaultStore/InMemoryStore.cs b/src/NetDevPack.Security.Jwt.Core/DefaultStore/InMemoryStore.cs index 9bd2511..989e0f8 100644 --- a/src/NetDevPack.Security.Jwt.Core/DefaultStore/InMemoryStore.cs +++ b/src/NetDevPack.Security.Jwt.Core/DefaultStore/InMemoryStore.cs @@ -5,50 +5,55 @@ namespace NetDevPack.Security.Jwt.Core.DefaultStore; +/// +/// Keeps the keys in memory. Registered as a singleton, so each service provider (application) +/// has its own keys instead of sharing a static list with every other host in the process. +/// internal class InMemoryStore : IJsonWebKeyStore { - private static readonly List _store = new(); - private readonly SemaphoreSlim _slim = new(1); + private readonly List _store = new(); + private readonly object _lock = new(); internal const string DefaultRevocationReason = "Revoked"; public Task Store(KeyMaterial keyMaterial) { if (keyMaterial is null) throw new InvalidOperationException("Can't store empty value."); - _slim.Wait(); - _store.Add(keyMaterial); - _slim.Release(); + lock (_lock) + _store.Add(keyMaterial); return Task.CompletedTask; } public Task GetCurrent(JwtKeyType jwtKeyType = JwtKeyType.Jws) { - return Task.FromResult(_store.Where(s => s.Use == (jwtKeyType == JwtKeyType.Jws ? "sig" : "enc")).OrderByDescending(s => s.CreationDate).FirstOrDefault()); + var use = jwtKeyType == JwtKeyType.Jws ? "sig" : "enc"; + lock (_lock) + return Task.FromResult(_store.Where(s => s.Use == use).OrderByDescending(s => s.CreationDate).FirstOrDefault()); } - public async Task Revoke(KeyMaterial keyMaterial, string reason = null) + public Task Revoke(KeyMaterial keyMaterial, string reason = null) { - if(keyMaterial == null) - return; - var revokeReason = reason ?? DefaultRevocationReason; - keyMaterial.Revoke(revokeReason); - var oldOne = _store.Find(f => f.Id == keyMaterial.Id); - if (oldOne != null) + if (keyMaterial == null) + return Task.CompletedTask; + + keyMaterial.Revoke(reason ?? DefaultRevocationReason); + lock (_lock) { var index = _store.FindIndex(f => f.Id == keyMaterial.Id); - await _slim.WaitAsync(); - _store.RemoveAt(index); - _store.Insert(index, keyMaterial); - _slim.Release(); + if (index >= 0) + _store[index] = keyMaterial; } + + return Task.CompletedTask; } public Task> GetLastKeys(int quantity, JwtKeyType? jwtKeyType = null) { - return Task.FromResult( - _store - .Where(s => jwtKeyType == null || s.Use == (jwtKeyType == JwtKeyType.Jws ? "sig" : "enc")) + lock (_lock) + return Task.FromResult( + _store + .Where(s => jwtKeyType == null || s.Use == (jwtKeyType == JwtKeyType.Jws ? "sig" : "enc")) .OrderByDescending(s => s.CreationDate) .GroupBy(s => s.Use) .SelectMany(g => g.Take(quantity)) @@ -57,12 +62,15 @@ public Task> GetLastKeys(int quantity, JwtKeyTyp public Task Get(string keyId) { - return Task.FromResult(_store.FirstOrDefault(w => w.KeyId == keyId)); + lock (_lock) + return Task.FromResult(_store.FirstOrDefault(w => w.KeyId == keyId)); } public Task Clear() { - _store.Clear(); + lock (_lock) + _store.Clear(); + return Task.CompletedTask; } -} \ No newline at end of file +} diff --git a/src/NetDevPack.Security.Jwt.Core/JsonWebKeySetManagerDependencyInjection.cs b/src/NetDevPack.Security.Jwt.Core/JsonWebKeySetManagerDependencyInjection.cs index 0bd9012..d06c8a4 100644 --- a/src/NetDevPack.Security.Jwt.Core/JsonWebKeySetManagerDependencyInjection.cs +++ b/src/NetDevPack.Security.Jwt.Core/JsonWebKeySetManagerDependencyInjection.cs @@ -24,12 +24,13 @@ public static IJwksBuilder AddJwksManager(this IServiceCollection services, Acti } /// - /// Sets the signing credential. + /// Keeps the keys in memory, for the lifetime of the service provider. Keys are lost on restart + /// and are not shared between instances, so use it only for development and tests. /// /// public static IJwksBuilder PersistKeysInMemory(this IJwksBuilder builder) { - builder.Services.AddScoped(); + builder.Services.AddSingleton(); return builder; } diff --git a/tests/NetDevPack.Security.Jwt.Tests/StoreTests/InMemoryStoreIsolationTests.cs b/tests/NetDevPack.Security.Jwt.Tests/StoreTests/InMemoryStoreIsolationTests.cs new file mode 100644 index 0000000..d4a9a2a --- /dev/null +++ b/tests/NetDevPack.Security.Jwt.Tests/StoreTests/InMemoryStoreIsolationTests.cs @@ -0,0 +1,46 @@ +using System.Threading.Tasks; +using AwesomeAssertions; +using Microsoft.Extensions.DependencyInjection; +using NetDevPack.Security.Jwt.Core.Interfaces; +using Xunit; + +namespace NetDevPack.Security.Jwt.Tests.StoreTests; + +[Trait("Category", "InMemory Tests")] +public class InMemoryStoreIsolationTests +{ + private static ServiceProvider CreateProvider() + { + var services = new ServiceCollection(); + services.AddLogging(); + services.AddMemoryCache(); + services.AddJwksManager().PersistKeysInMemory(); + return services.BuildServiceProvider(); + } + + [Fact] + public async Task ServiceProviders_ShouldNotShareKeys() + { + await using var first = CreateProvider(); + await using var second = CreateProvider(); + + using (var scope = first.CreateScope()) + await scope.ServiceProvider.GetRequiredService().GenerateKey(); + + using (var scope = second.CreateScope()) + (await scope.ServiceProvider.GetRequiredService().GetLastKeys(5)).Should().BeEmpty(); + } + + [Fact] + public async Task Scopes_OfTheSameServiceProvider_ShouldShareKeys() + { + await using var provider = CreateProvider(); + + string keyId; + using (var scope = provider.CreateScope()) + keyId = (await scope.ServiceProvider.GetRequiredService().GenerateKey()).KeyId; + + using (var scope = provider.CreateScope()) + (await scope.ServiceProvider.GetRequiredService().Get(keyId)).Should().NotBeNull(); + } +}