/* * 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.Concurrent; using System.Globalization; using System.Net; using System.Net.Http; using System.Net.Http.Headers; using System.Net.Sockets; using System.Text; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Options; using Xunit; namespace OpenIddict.Server.SystemNetHttp.Tests; public class OpenIddictServerSystemNetHttpRequestObjectFetcherTests { private const string ContentType = "application/oauth-authz-req+jwt"; private static readonly Uri RequestUri = new("https://www.fabrikam.com/request_objects/1", UriKind.Absolute); [Theory] [InlineData("0.1.2.3", false)] [InlineData("10.0.0.1", false)] [InlineData("100.64.0.1", false)] [InlineData("127.0.0.1", false)] [InlineData("169.254.169.254", false)] [InlineData("172.16.0.1", false)] [InlineData("172.31.255.255", false)] [InlineData("192.168.1.1", false)] [InlineData("198.18.0.1", false)] [InlineData("224.0.0.1", false)] [InlineData("255.255.255.255", false)] [InlineData("::", false)] [InlineData("::1", false)] [InlineData("::ffff:127.0.0.1", false)] [InlineData("::ffff:10.0.0.1", false)] [InlineData("64:ff9b::a00:1", false)] [InlineData("2002:a00:1::", false)] [InlineData("2001:db8::1", false)] [InlineData("fc00::1", false)] [InlineData("fd12:3456::1", false)] [InlineData("fe80::1", false)] [InlineData("ff02::1", false)] [InlineData("64:ff9b:1::a00:1", false)] [InlineData("2001:2::1", false)] [InlineData("2001:10::1", false)] [InlineData("2001:20::1", false)] [InlineData("2001:2f::1", false)] [InlineData("3fff::1", false)] [InlineData("5f00::1", false)] [InlineData("2001:30::1", true)] [InlineData("2001:4860:4860::8888", true)] [InlineData("8.8.8.8", true)] [InlineData("172.32.0.1", true)] [InlineData("100.128.0.1", true)] [InlineData("::ffff:8.8.8.8", true)] [InlineData("64:ff9b::808:808", true)] [InlineData("2606:4700:4700::1111", true)] public void IsPublicAddress_ReturnsExpectedResult(string address, bool result) => Assert.Equal(result, OpenIddictServerSystemNetHttpHelpers.IsPublicAddress(IPAddress.Parse(address))); [Fact] public async Task FetchAsync_ReturnsRequestObject() { // Arrange HttpRequestMessage? message = null; using var fetcher = CreateFetcher(request => { message = request; return CreateResponse("eyJhbGciOiJSUzI1NiJ9.e30.c2ln"); }); // Act var result = await fetcher.FetchAsync(new Uri(RequestUri.AbsoluteUri + "#hash"), CancellationToken.None); // Assert Assert.Equal("eyJhbGciOiJSUzI1NiJ9.e30.c2ln", result); Assert.NotNull(message); Assert.Equal(HttpMethod.Get, message.Method); Assert.Equal(RequestUri, message.RequestUri); Assert.Contains(message.Headers.Accept, header => string.Equals(header.MediaType, ContentType, StringComparison.Ordinal)); } [Theory] [InlineData("http://www.fabrikam.com/request_objects/1")] [InlineData("https://user:password@www.fabrikam.com/request_objects/1")] public async Task FetchAsync_ReturnsNullForInvalidUris(string uri) { // Arrange var sent = false; using var fetcher = CreateFetcher(_ => { sent = true; return CreateResponse("token"); }); // Act and assert Assert.Null(await fetcher.FetchAsync(new Uri(uri, UriKind.Absolute), CancellationToken.None)); Assert.False(sent); } [Theory] [InlineData(HttpStatusCode.Found)] [InlineData(HttpStatusCode.MovedPermanently)] [InlineData(HttpStatusCode.NotFound)] [InlineData(HttpStatusCode.InternalServerError)] public async Task FetchAsync_ReturnsNullForNonSuccessfulResponses(HttpStatusCode status) { // Arrange using var fetcher = CreateFetcher(_ => { var response = CreateResponse("token"); response.StatusCode = status; response.Headers.Location = new Uri("https://www.fabrikam.com/other"); return response; }); // Act and assert Assert.Null(await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Theory] [InlineData(null)] [InlineData("application/json")] [InlineData("text/html")] [InlineData("application/jwt")] public async Task FetchAsync_ReturnsNullForInvalidContentTypes(string? type) { // Arrange using var fetcher = CreateFetcher(_ => { var response = CreateResponse("token"); response.Content.Headers.ContentType = type is null ? null : new MediaTypeHeaderValue(type); return response; }); // Act and assert Assert.Null(await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Fact] public async Task FetchAsync_AcceptsAdditionalContentTypes() { // Arrange using var fetcher = CreateFetcher(_ => { var response = CreateResponse("token"); response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/jwt") { CharSet = "utf-8" }; return response; }, options => options.RequestObjectContentTypes.Add("application/jwt")); // Act and assert Assert.Equal("token", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Theory] [InlineData(false)] [InlineData(true)] public async Task FetchAsync_ReturnsNullForOversizedResponses(bool length) { // Arrange using var fetcher = CreateFetcher(_ => { var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = length ? new ByteArrayContent(new byte[1025]) : new StreamContent(new UnseekableStream(new byte[1025])) }; response.Content.Headers.ContentType = new MediaTypeHeaderValue(ContentType); return response; }, options => options.MaximumRequestObjectSize = 1024); // Act and assert Assert.Null(await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Fact] public async Task FetchAsync_ReturnsNullForInvalidUtf8Content() { // Arrange using var fetcher = CreateFetcher(_ => { var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent([0xC3, 0x28]) }; response.Content.Headers.ContentType = new MediaTypeHeaderValue(ContentType); return response; }); // Act and assert Assert.Null(await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Fact] public async Task FetchAsync_ReturnsNullWhenTimeoutExpires() { // Arrange using var fetcher = new OpenIddictServerSystemNetHttpRequestObjectFetcher( CreateOptions(options => options.RequestObjectTimeout = TimeSpan.FromMilliseconds(50)), NullLogger.Instance, new DelayingHandler()); // Act and assert Assert.Null(await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Fact] public async Task FetchAsync_ThrowsWhenCallerCancelsOperation() { // Arrange using var fetcher = new OpenIddictServerSystemNetHttpRequestObjectFetcher( CreateOptions(), NullLogger.Instance, new DelayingHandler()); using var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(50)); // Act and assert await Assert.ThrowsAnyAsync(async () => await fetcher.FetchAsync(RequestUri, source.Token)); } [Fact] public async Task FetchAsync_CachesResponsesAccordingToCacheControlHeaders() { // Arrange var provider = new MutableTimeProvider(new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero)); var count = 0; using var fetcher = CreateFetcher(_ => { var response = CreateResponse("token" + (++count).ToString(CultureInfo.InvariantCulture)); response.Headers.CacheControl = new CacheControlHeaderValue { MaxAge = TimeSpan.FromMinutes(1) }; return response; }, options => options.TimeProvider = provider); // Act and assert Assert.Equal("token1", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); Assert.Equal("token1", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); // Note: the fragment is part of the cache key. Assert.Equal("token2", await fetcher.FetchAsync(new Uri(RequestUri.AbsoluteUri + "#hash"), CancellationToken.None)); provider.Now += TimeSpan.FromMinutes(2); Assert.Equal("token3", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Fact] public async Task FetchAsync_CacheLifetimeIsCappedByMaximumCacheLifetime() { // Arrange var provider = new MutableTimeProvider(new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero)); var count = 0; using var fetcher = CreateFetcher(_ => { var response = CreateResponse("token" + (++count).ToString(CultureInfo.InvariantCulture)); response.Headers.CacheControl = new CacheControlHeaderValue { MaxAge = TimeSpan.FromDays(1) }; return response; }, options => { options.MaximumRequestObjectCacheLifetime = TimeSpan.FromMinutes(1); options.TimeProvider = provider; }); // Act and assert Assert.Equal("token1", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); provider.Now += TimeSpan.FromMinutes(2); Assert.Equal("token2", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Theory] [InlineData(true, false)] [InlineData(false, true)] [InlineData(false, false)] public async Task FetchAsync_DoesNotCacheResponsesThatDisallowCaching(bool store, bool cache) { // Arrange var count = 0; using var fetcher = CreateFetcher(_ => { var response = CreateResponse("token" + (++count).ToString(CultureInfo.InvariantCulture)); if (store || cache) { response.Headers.CacheControl = new CacheControlHeaderValue { MaxAge = TimeSpan.FromMinutes(1), NoCache = cache, NoStore = store }; } return response; }); // Act and assert Assert.Equal("token1", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); Assert.Equal("token2", await fetcher.FetchAsync(RequestUri, CancellationToken.None)); } [Theory] [InlineData("10.0.0.1")] [InlineData("169.254.169.254")] [InlineData("[::1]")] public async Task FetchAsync_RejectsDisallowedRemoteAddressesUsingFilter(string host) { // Arrange var addresses = new ConcurrentBag(); using var fetcher = new OpenIddictServerSystemNetHttpRequestObjectFetcher( CreateOptions(options => options.RemoteAddressFilter = address => { addresses.Add(address); return OpenIddictServerSystemNetHttpHelpers.IsPublicAddress(address); }), NullLogger.Instance); // Act var result = await fetcher.FetchAsync(new Uri($"https://{host}/request_objects/1", UriKind.Absolute), CancellationToken.None); // Assert Assert.Null(result); Assert.Contains(IPAddress.Parse(host.Trim('[', ']')), addresses); } [Theory] [InlineData("127.0.0.1")] [InlineData("localhost")] public async Task FetchAsync_DoesNotConnectToDisallowedRemoteAddresses(string host) { // Arrange var listener = TcpListener.Create(0); listener.Start(); try { var port = ((IPEndPoint) listener.LocalEndpoint).Port.ToString(CultureInfo.InvariantCulture); var addresses = new ConcurrentBag(); using var fetcher = new OpenIddictServerSystemNetHttpRequestObjectFetcher( CreateOptions(options => options.RemoteAddressFilter = address => { addresses.Add(address); return OpenIddictServerSystemNetHttpHelpers.IsPublicAddress(address); }), NullLogger.Instance); // Act var result = await fetcher.FetchAsync(new Uri($"https://{host}:{port}/request_objects/1", UriKind.Absolute), CancellationToken.None); // Assert Assert.Null(result); Assert.NotEmpty(addresses); Assert.All(addresses, address => Assert.True(IPAddress.IsLoopback(address))); Assert.False(listener.Pending()); } finally { listener.Stop(); } } [Fact] public async Task FetchAsync_ConnectsToRemoteAddressesAllowedByFilter() { // Arrange var listener = new TcpListener(IPAddress.Loopback, 0); listener.Start(); try { var port = ((IPEndPoint) listener.LocalEndpoint).Port.ToString(CultureInfo.InvariantCulture); var addresses = new ConcurrentBag(); using var fetcher = new OpenIddictServerSystemNetHttpRequestObjectFetcher( CreateOptions(options => { options.RequestObjectTimeout = TimeSpan.FromSeconds(10); options.RemoteAddressFilter = address => { addresses.Add(address); return true; }; }), NullLogger.Instance); // Act var task = fetcher.FetchAsync(new Uri($"https://127.0.0.1:{port}/request_objects/1", UriKind.Absolute), CancellationToken.None).AsTask(); var accept = listener.AcceptTcpClientAsync(); // Assert #if NET var delay = Task.Delay(TimeSpan.FromSeconds(10), TimeProvider.System); #else var delay = TimeProvider.System.Delay(TimeSpan.FromSeconds(10)); #endif Assert.Same(accept, await Task.WhenAny(accept, delay)); // Close the connection without completing the TLS handshake. (await accept).Dispose(); Assert.Null(await task); Assert.Contains(IPAddress.Loopback, addresses); } finally { listener.Stop(); } } [Fact] public void UseSystemNetHttp_RegistersFetcher() { // Arrange var services = new ServiceCollection().AddLogging(); // Act services.AddOpenIddict().AddServer().UseSystemNetHttp(options => options .AddRequestObjectContentType("application/jwt") .SetMaximumRequestObjectSize(1024) .SetMaximumRequestObjectCacheLifetime(TimeSpan.Zero) .SetRequestObjectTimeout(TimeSpan.FromSeconds(1))); // Assert using var provider = services.BuildServiceProvider(); Assert.IsType(provider.GetRequiredService()); var options = provider.GetRequiredService>().Value; Assert.Contains("application/jwt", options.RequestObjectContentTypes); Assert.Contains(ContentType, options.RequestObjectContentTypes); Assert.Equal(1024, options.MaximumRequestObjectSize); Assert.Equal(TimeSpan.Zero, options.MaximumRequestObjectCacheLifetime); Assert.Equal(TimeSpan.FromSeconds(1), options.RequestObjectTimeout); } [Fact] public void Builder_RejectsInvalidValues() { // Arrange var builder = new OpenIddictServerSystemNetHttpBuilder(new ServiceCollection()); // Act and assert Assert.Throws(() => builder.SetRequestObjectTimeout(TimeSpan.Zero)); Assert.Throws(() => builder.SetMaximumRequestObjectSize(0)); Assert.Throws(() => builder.SetMaximumRequestObjectCacheLifetime(TimeSpan.FromSeconds(-1))); } private static OpenIddictServerSystemNetHttpRequestObjectFetcher CreateFetcher( Func handler, Action? configuration = null) => new(CreateOptions(configuration), NullLogger.Instance, new InlineHandler(handler)); private static IOptionsMonitor CreateOptions( Action? configuration = null) { var services = new ServiceCollection(); services.Configure(configuration ?? (static _ => { })); return services.BuildServiceProvider().GetRequiredService>(); } private static HttpResponseMessage CreateResponse(string content) { var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(Encoding.UTF8.GetBytes(content)) }; response.Content.Headers.ContentType = new MediaTypeHeaderValue(ContentType); return response; } private sealed class InlineHandler(Func handler) : HttpMessageHandler { protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) => Task.FromResult(handler(request)); } private sealed class DelayingHandler : HttpMessageHandler { protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken); return CreateResponse("token"); } } private sealed class MutableTimeProvider(DateTimeOffset now) : TimeProvider { public DateTimeOffset Now { get; set; } = now; public override DateTimeOffset GetUtcNow() => Now; } private sealed class UnseekableStream(byte[] buffer) : MemoryStream(buffer) { public override bool CanSeek => false; } }