/* * 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.Buffers.Text; using System.ComponentModel; using System.Diagnostics; using System.Globalization; using System.Security.Cryptography; using System.Security.Cryptography.X509Certificates; using System.Text; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Options; using Microsoft.IdentityModel.Tokens; namespace OpenIddict.Server; /// /// Contains the methods required to ensure that the OpenIddict server configuration is valid. /// [EditorBrowsable(EditorBrowsableState.Advanced)] public sealed class OpenIddictServerConfiguration : IPostConfigureOptions, IValidateOptions { private readonly IServiceProvider _provider; /// /// Creates a new instance of the class. /// /// The service provider. public OpenIddictServerConfiguration(IServiceProvider provider) => _provider = provider ?? throw new ArgumentNullException(nameof(provider)); /// public void PostConfigure(string? name, OpenIddictServerOptions options) { ArgumentNullException.ThrowIfNull(options); options.TimeProvider ??= _provider.GetService() ?? TimeProvider.System; // If no user code display format was explicitly set, generate a default format based on the configured length. if (options.UserCodeLength is >= 1 && string.IsNullOrEmpty(options.UserCodeDisplayFormat)) { options.UserCodeDisplayFormat = ComputeDefaultUserCodeDisplayFormat(options.UserCodeLength); } // Explicitly disable all the features that are implicitly excluded when the degraded mode is active. if (options.EnableDegradedMode) { options.DisableAuthorizationStorage = options.DisableTokenStorage = options.DisableRollingRefreshTokens = true; options.EnableAuthorizationRequestCaching = options.EnableEndSessionRequestCaching = false; options.IgnoreEndpointPermissions = options.IgnoreGrantTypePermissions = true; options.IgnoreResponseTypePermissions = options.IgnoreScopePermissions = true; options.UseReferenceAccessTokens = options.UseReferenceRefreshTokens = false; } // Explicitly disable rolling refresh tokens when token storage is disabled. if (options.DisableTokenStorage) { options.DisableRollingRefreshTokens = true; } // If token storage was disabled, user codes will be returned as-is by OpenIddict instead of being // automatically converted to reference identifiers (in this case, custom event handlers must be // registered to manually store the token payload in a database or cache and return a user code // that can be used and entered by a human user in a web form). Since the default logic is not // going be used, disable the formatting logic by setting UserCodeDisplayFormat to null here. if (options.DisableTokenStorage) { options.UserCodeLength = 0; options.UserCodeCharset.Clear(); options.UserCodeDisplayFormat = null; } // Sort the handlers collection using the order associated with each handler. options.Handlers.Sort(static (left, right) => left.Order.CompareTo(right.Order)); var now = options.TimeProvider.GetUtcNow().LocalDateTime; // Sort the encryption and signing credentials. options.EncryptionCredentials.Sort((left, right) => Compare(left.Key, right.Key, now)); options.SigningCredentials.Sort((left, right) => Compare(left.Key, right.Key, now)); // Generate a key identifier for the encryption/signing keys that don't already have one. foreach (var key in options.EncryptionCredentials.Select(static credentials => credentials.Key) .Concat(options.SigningCredentials.Select(static credentials => credentials.Key)) .Where(static key => string.IsNullOrEmpty(key.KeyId))) { key.KeyId = GetKeyIdentifier(key); } // Attach the signing credentials to the token validation parameters. options.TokenValidationParameters.IssuerSigningKeys = from credentials in options.SigningCredentials select credentials.Key; // Attach the encryption credentials to the token validation parameters. options.TokenValidationParameters.TokenDecryptionKeys = from credentials in options.EncryptionCredentials select credentials.Key; static int Compare(SecurityKey left, SecurityKey right, DateTime now) => (left, right) switch { // If the two keys refer to the same instances, return 0. (SecurityKey first, SecurityKey second) when ReferenceEquals(first, second) => 0, // If one of the keys is a symmetric key, prefer it to the other one. (SymmetricSecurityKey, SymmetricSecurityKey) => 0, (SymmetricSecurityKey, SecurityKey) => -1, (SecurityKey, SymmetricSecurityKey) => 1, // If one of the keys is backed by a X.509 certificate, don't prefer it if it's not valid yet. (X509SecurityKey first, SecurityKey) when first.Certificate.NotBefore > now => 1, (SecurityKey, X509SecurityKey second) when second.Certificate.NotBefore > now => -1, // If the two keys are backed by a X.509 certificate, prefer the one with the furthest expiration date. (X509SecurityKey first, X509SecurityKey second) => -first.Certificate.NotAfter.CompareTo(second.Certificate.NotAfter), // If one of the keys is backed by a X.509 certificate, prefer the X.509 security key. (X509SecurityKey, SecurityKey) => -1, (SecurityKey, X509SecurityKey) => 1, // If the two keys are not backed by a X.509 certificate, none should be preferred to the other. (SecurityKey, SecurityKey) => 0 }; static string ComputeDefaultUserCodeDisplayFormat(int length) { var builder = new StringBuilder(); var count = length % 5 is 0 ? 5 : length % 4 is 0 ? 4 : length % 3 is 0 ? 3 : length % 2 is 0 ? 2 : 1; for (var index = 0; index < length; index++) { if (index is > 0 && index % count is 0) { builder.Append(Separators.Dash[0]); } builder.Append('{'); builder.Append(index); builder.Append('}'); } return builder.ToString(); } static string? GetKeyIdentifier(SecurityKey key) { // When no key identifier can be retrieved from the security keys, a value is automatically // inferred from the hexadecimal representation of the certificate thumbprint (SHA-1) // when the key is bound to a X.509 certificate or from the public part of the signing key. return key switch { X509SecurityKey value => value.Certificate.Thumbprint, RsaSecurityKey value => GetRsaSecurityKeyIdentifier(value), ECDsaSecurityKey value => GetEcdsaSecurityKeyIdentifier(value), MlDsaSecurityKey value => GetMLDsaSecurityKeyIdentifier(value), _ => null }; static string GetEcdsaSecurityKeyIdentifier(ECDsaSecurityKey key) { var parameters = key.ECDsa.ExportParameters(includePrivateParameters: false); Debug.Assert(parameters.Q.X is not null, SR.GetResourceString(SR.ID4004)); // Only use the 40 first chars of the base64url-encoded X coordinate. var identifier = Base64Url.EncodeToString(parameters.Q.X); return identifier[.. Math.Min(identifier.Length, 40)].ToUpperInvariant(); } static string GetMLDsaSecurityKeyIdentifier(MlDsaSecurityKey key) { // Only use the 40 first chars of the base64url-encoded SHA256 of the ML-DSA public key. var identifier = Base64Url.EncodeToString(SHA256.HashData(key.MLDsa.ExportMLDsaPublicKey())); return identifier[.. Math.Min(identifier.Length, 40)].ToUpperInvariant(); } static string GetRsaSecurityKeyIdentifier(RsaSecurityKey key) { // Note: if the RSA parameters are not attached to the signing key, // extract them by calling ExportParameters on the RSA instance. var parameters = key.Parameters; if (parameters.Modulus is null) { parameters = key.Rsa.ExportParameters(includePrivateParameters: false); Debug.Assert(parameters.Modulus is not null, SR.GetResourceString(SR.ID4003)); } // Only use the 40 first chars of the base64url-encoded modulus. var identifier = Base64Url.EncodeToString(parameters.Modulus); return identifier[.. Math.Min(identifier.Length, 40)].ToUpperInvariant(); } } } /// public ValidateOptionsResult Validate(string? name, OpenIddictServerOptions options) { ArgumentNullException.ThrowIfNull(options); var builder = new ValidateOptionsResultBuilder(); if (options.JsonWebTokenHandler is null) { builder.AddError(SR.GetResourceString(SR.ID0075)); } // Ensure at least one flow has been enabled. if (options.GrantTypes.Count is 0 && options.ResponseTypes.Count is 0) { builder.AddError(SR.GetResourceString(SR.ID0076)); } var uris = options.AuthorizationEndpointUris.Distinct() .Concat(options.BackchannelAuthenticationEndpointUris.Distinct()) .Concat(options.ConfigurationEndpointUris.Distinct()) .Concat(options.JsonWebKeySetEndpointUris.Distinct()) .Concat(options.DeviceAuthorizationEndpointUris.Distinct()) .Concat(options.IntrospectionEndpointUris.Distinct()) .Concat(options.EndSessionEndpointUris.Distinct()) .Concat(options.PushedAuthorizationEndpointUris.Distinct()) .Concat(options.RevocationEndpointUris.Distinct()) .Concat(options.TokenEndpointUris.Distinct()) .Concat(options.UserInfoEndpointUris.Distinct()) .Concat(options.EndUserVerificationEndpointUris.Distinct()) .ToList(); // Ensure endpoint URIs are unique across endpoints. if (uris.Count != uris.Distinct().Count()) { builder.AddError(SR.GetResourceString(SR.ID0285)); } // Ensure the authorization endpoint has been enabled when // the authorization code or implicit grants are supported. if (options.AuthorizationEndpointUris.Count is 0 && (options.GrantTypes.Contains(GrantTypes.AuthorizationCode) || options.GrantTypes.Contains(GrantTypes.Implicit))) { builder.AddError(SR.GetResourceString(SR.ID0077)); } // Ensure the device authorization endpoint has been enabled when the device grant is supported. if (options.DeviceAuthorizationEndpointUris.Count is 0 && options.GrantTypes.Contains(GrantTypes.DeviceCode)) { builder.AddError(SR.GetResourceString(SR.ID0078)); } // Ensure the token endpoint has been enabled when the authorization code, // client credentials, device, password or refresh token grants are supported. if (options.TokenEndpointUris.Count is 0 && (options.GrantTypes.Contains(GrantTypes.AuthorizationCode) || options.GrantTypes.Contains(GrantTypes.Ciba) || options.GrantTypes.Contains(GrantTypes.ClientCredentials) || options.GrantTypes.Contains(GrantTypes.DeviceCode) || options.GrantTypes.Contains(GrantTypes.Password) || options.GrantTypes.Contains(GrantTypes.RefreshToken))) { builder.AddError(SR.GetResourceString(SR.ID0079)); } // Ensure the end-user verification endpoint has been enabled when the device grant is supported. if (options.EndUserVerificationEndpointUris.Count is 0 && options.GrantTypes.Contains(GrantTypes.DeviceCode)) { builder.AddError(SR.GetResourceString(SR.ID0080)); } // Ensure the device grant is allowed when the device authorization endpoint is enabled. if (options.DeviceAuthorizationEndpointUris.Count is > 0 && !options.GrantTypes.Contains(GrantTypes.DeviceCode)) { builder.AddError(SR.GetResourceString(SR.ID0084)); } // Ensure the backchannel authentication endpoint and the CIBA grant are always enabled together. if (options.BackchannelAuthenticationEndpointUris.Count is 0 && options.GrantTypes.Contains(GrantTypes.Ciba)) { builder.AddError(SR.GetResourceString(SR.ID0527)); } if (options.BackchannelAuthenticationEndpointUris.Count is > 0 && !options.GrantTypes.Contains(GrantTypes.Ciba)) { builder.AddError(SR.GetResourceString(SR.ID0528)); } // Ensure the CIBA grant is not used with the degraded mode, with token storage disabled or without an explicit // issuer, as authentication requests are persisted and completed outside the context of an HTTP request. if (options.GrantTypes.Contains(GrantTypes.Ciba) && (options.EnableDegradedMode || options.DisableTokenStorage || options.Issuer is null)) { builder.AddError(SR.GetResourceString(SR.ID0529)); } // Ensure the grant types/response types configuration is consistent. foreach (var type in options.ResponseTypes) { var types = type.Split(Separators.Space, StringSplitOptions.RemoveEmptyEntries).ToHashSet(StringComparer.Ordinal); if (types.Contains(ResponseTypes.Code) && !options.GrantTypes.Contains(GrantTypes.AuthorizationCode)) { builder.AddError(SR.FormatID0281(ResponseTypes.Code)); } if (types.Contains(ResponseTypes.IdToken) && !options.GrantTypes.Contains(GrantTypes.Implicit)) { builder.AddError(SR.FormatID0282(ResponseTypes.IdToken)); } if (types.Contains(ResponseTypes.Token) && !options.GrantTypes.Contains(GrantTypes.Implicit)) { builder.AddError(SR.FormatID0282(ResponseTypes.Token)); } } // Ensure at least one client authentication method is enabled (unless no non-interactive endpoint was enabled). if (options.ClientAuthenticationMethods.Count is 0 && (options.BackchannelAuthenticationEndpointUris.Count is not 0 || options.DeviceAuthorizationEndpointUris.Count is not 0 || options.IntrospectionEndpointUris.Count is not 0 || options.PushedAuthorizationEndpointUris.Count is not 0 || options.RevocationEndpointUris.Count is not 0 || options.TokenEndpointUris.Count is not 0)) { builder.AddError(SR.GetResourceString(SR.ID0419)); } // Ensure signed request objects are not required when request object support is disabled. if (options.RequireSignedRequestObjects && !options.EnableRequestObjectSupport) { builder.AddError(SR.GetResourceString(SR.ID0524)); } // Ensure the DPoP configuration is consistent. if (options.RequireDPoP && !options.EnableDPoPSupport) { builder.AddError(SR.GetResourceString(SR.ID0544)); } if (options.RequireDPoPNonces && !options.EnableDPoPSupport) { builder.AddError(SR.GetResourceString(SR.ID0545)); } if (options.EnableDPoPSupport && (options.DPoPSigningAlgorithms.Count is 0 || options.DPoPSigningAlgorithms.Any( static algorithm => !OpenIddictDPoPHelpers.SupportedAlgorithms.Contains(algorithm, StringComparer.Ordinal)))) { builder.AddError(SR.GetResourceString(SR.ID0546)); } if (options.DPoPProofLifetime <= TimeSpan.Zero || options.DPoPNonceLifetime <= TimeSpan.Zero) { builder.AddError(SR.GetResourceString(SR.ID0547)); } // Ensure the client authentication methods/client assertion types configuration is consistent. if (options.ClientAuthenticationMethods.Contains(ClientAuthenticationMethods.PrivateKeyJwt) && !options.ClientAssertionTypes.Contains(ClientAssertionTypes.JwtBearer)) { builder.AddError(SR.FormatID0420(ClientAssertionTypes.JwtBearer, ClientAuthenticationMethods.PrivateKeyJwt)); } if (options.ClientAuthenticationMethods.Contains(ClientAuthenticationMethods.ClientSecretJwt) && !options.ClientAssertionTypes.Contains(ClientAssertionTypes.JwtBearer)) { builder.AddError(SR.FormatID0420(ClientAssertionTypes.JwtBearer, ClientAuthenticationMethods.ClientSecretJwt)); } // If the tls_client_auth or self_signed_tls_client_auth methods are enabled, ensure a chain policy has been set. if (options.ClientAuthenticationMethods.Contains(ClientAuthenticationMethods.TlsClientAuth) && options.PublicKeyInfrastructureTlsClientAuthenticationPolicy is null) { builder.AddError(SR.GetResourceString(SR.ID0505)); } if (options.ClientAuthenticationMethods.Contains(ClientAuthenticationMethods.SelfSignedTlsClientAuth) && options.SelfSignedTlsClientAuthenticationPolicy is null) { builder.AddError(SR.GetResourceString(SR.ID0506)); } // Ensure at least one supported subject type is listed. if (options.SubjectTypes.Count is 0) { builder.AddError(SR.GetResourceString(SR.ID0421)); } // Ensure reference tokens support was not enabled when token storage is disabled. if (options.DisableTokenStorage && (options.UseReferenceAccessTokens || options.UseReferenceRefreshTokens)) { builder.AddError(SR.GetResourceString(SR.ID0083)); } // Ensure authorization or end session request caching was not enabled when token storage is disabled. if (options.DisableTokenStorage && (options.EnableAuthorizationRequestCaching || options.EnableEndSessionRequestCaching)) { builder.AddError(SR.GetResourceString(SR.ID0465)); } // Prevent the device authorization flow from being used if token storage is disabled, unless the degraded // mode has been enabled (in this case, additional checks will be enforced later to require custom handlers). if (options.DisableTokenStorage && !options.EnableDegradedMode && options.GrantTypes.Contains(GrantTypes.DeviceCode)) { builder.AddError(SR.GetResourceString(SR.ID0367)); } // Ensure at least one subject token type is configured when the token exchange grant is enabled. if (options.SubjectTokenTypes.Count is 0 && options.GrantTypes.Contains(GrantTypes.TokenExchange)) { builder.AddError(SR.GetResourceString(SR.ID0486)); } // Prevent internal token types from being used as subject, actor or requested token types. if (options.SubjectTokenTypes.Any(static type => type.StartsWith( TokenTypeIdentifiers.Prefixes.OpenIddict, StringComparison.OrdinalIgnoreCase))) { builder.AddError(SR.GetResourceString(SR.ID0487)); } if (options.ActorTokenTypes.Any(static type => type.StartsWith( TokenTypeIdentifiers.Prefixes.OpenIddict, StringComparison.OrdinalIgnoreCase))) { builder.AddError(SR.GetResourceString(SR.ID0488)); } if (options.RequestedTokenTypes.Any(static type => type.StartsWith( TokenTypeIdentifiers.Prefixes.OpenIddict, StringComparison.OrdinalIgnoreCase))) { builder.AddError(SR.GetResourceString(SR.ID0489)); } // Ensure that the default requested token type (used when the caller doesn't specify a // requested_token_type parameter during an OAuth 2.0 token exchange flow) was configured // and that the configured value is also present in the list of allowed token types. if (string.IsNullOrEmpty(options.DefaultRequestedTokenType)) { builder.AddError(SR.GetResourceString(SR.ID0490)); } if (options.DefaultRequestedTokenType.StartsWith( TokenTypeIdentifiers.Prefixes.OpenIddict, StringComparison.OrdinalIgnoreCase)) { builder.AddError(SR.GetResourceString(SR.ID0491)); } if (!options.RequestedTokenTypes.Contains(options.DefaultRequestedTokenType)) { builder.AddError(SR.GetResourceString(SR.ID0492)); } // Note: when automatic key management is enabled, static credentials are optional. if (options.EnableAutomaticKeyManagement) { if (_provider.GetService() is null) { builder.AddError(SR.GetResourceString(SR.ID0542)); } if (options.KeyRotationInterval <= TimeSpan.Zero || options.KeyPropagationTime < TimeSpan.Zero || options.KeyRetentionTime < TimeSpan.Zero || options.KeyRingCacheLifetime <= TimeSpan.Zero || options.KeyPropagationTime >= options.KeyRotationInterval) { builder.AddError(SR.GetResourceString(SR.ID0543)); } } else { if (options.EncryptionCredentials.Count is 0) { builder.AddError(SR.GetResourceString(SR.ID0085)); } if (!options.SigningCredentials.Exists(static credentials => credentials.Key is AsymmetricSecurityKey)) { builder.AddError(SR.GetResourceString(SR.ID0086)); } var now = options.TimeProvider.GetUtcNow().LocalDateTime; // If all the registered encryption credentials are backed by a X.509 certificate, at least one of them must be valid. if (options.EncryptionCredentials.TrueForAll(credentials => credentials.Key is X509SecurityKey { Certificate: X509Certificate2 certificate } && (certificate.NotBefore > now || certificate.NotAfter < now))) { builder.AddError(SR.GetResourceString(SR.ID0087)); } // If all the registered signing credentials are backed by a X.509 certificate, at least one of them must be valid. if (options.SigningCredentials.TrueForAll(credentials => credentials.Key is X509SecurityKey { Certificate: X509Certificate2 certificate } && (certificate.NotBefore > now || certificate.NotAfter < now))) { builder.AddError(SR.GetResourceString(SR.ID0088)); } } // When set, the mTLS endpoint aliases MUST represent absolute HTTPS URLs. if (!TryValidateMtlsEndpointAlias(options.MtlsDeviceAuthorizationEndpointAliasUri) || !TryValidateMtlsEndpointAlias(options.MtlsIntrospectionEndpointAliasUri) || !TryValidateMtlsEndpointAlias(options.MtlsPushedAuthorizationEndpointAliasUri) || !TryValidateMtlsEndpointAlias(options.MtlsRevocationEndpointAliasUri) || !TryValidateMtlsEndpointAlias(options.MtlsTokenEndpointAliasUri) || !TryValidateMtlsEndpointAlias(options.MtlsUserInfoEndpointAliasUri)) { builder.AddError(SR.GetResourceString(SR.ID0499)); } // Prevent the mTLS aliases from being configured if the corresponding endpoints haven't been enabled. if ((options.MtlsDeviceAuthorizationEndpointAliasUri is not null && options.DeviceAuthorizationEndpointUris.Count is 0) || (options.MtlsIntrospectionEndpointAliasUri is not null && options.IntrospectionEndpointUris.Count is 0) || (options.MtlsPushedAuthorizationEndpointAliasUri is not null && options.PushedAuthorizationEndpointUris.Count is 0) || (options.MtlsRevocationEndpointAliasUri is not null && options.RevocationEndpointUris.Count is 0) || (options.MtlsTokenEndpointAliasUri is not null && options.TokenEndpointUris.Count is 0) || (options.MtlsUserInfoEndpointAliasUri is not null && options.UserInfoEndpointUris.Count is 0)) { builder.AddError(SR.GetResourceString(SR.ID0510)); } // If at least one mTLS endpoint alias was configured, require that the issuer be explicitly set // to ensure it is not dynamically computed based on the current URI, as this would result in two // different issuers being used (one pointing to the mTLS domain and one pointing to the regular one). if (options.Issuer is null && (options.MtlsDeviceAuthorizationEndpointAliasUri is not null || options.MtlsIntrospectionEndpointAliasUri is not null || options.MtlsPushedAuthorizationEndpointAliasUri is not null || options.MtlsRevocationEndpointAliasUri is not null || options.MtlsTokenEndpointAliasUri is not null || options.MtlsUserInfoEndpointAliasUri is not null)) { builder.AddError(SR.GetResourceString(SR.ID0500)); } // Ensure no end certificate was included in the PKI TLS client authentication // chain policy and that none of the certificates contains a private key. if (options.PublicKeyInfrastructureTlsClientAuthenticationPolicy is not null) { if (options.PublicKeyInfrastructureTlsClientAuthenticationPolicy.ExtraStore.Cast() .Any(static certificate => !OpenIddictHelpers.IsCertificateAuthority(certificate) || !OpenIddictHelpers.HasKeyUsage(certificate, X509KeyUsageFlags.KeyCertSign))) { builder.AddError(SR.GetResourceString(SR.ID0501)); } if (options.PublicKeyInfrastructureTlsClientAuthenticationPolicy.ExtraStore.Cast() .Any(static certificate => certificate.HasPrivateKey)) { builder.AddError(SR.GetResourceString(SR.ID0511)); } #if NET if (options.PublicKeyInfrastructureTlsClientAuthenticationPolicy.CustomTrustStore.Cast() .Any(static certificate => !OpenIddictHelpers.IsCertificateAuthority(certificate) || !OpenIddictHelpers.HasKeyUsage(certificate, X509KeyUsageFlags.KeyCertSign))) { builder.AddError(SR.GetResourceString(SR.ID0501)); } if (options.PublicKeyInfrastructureTlsClientAuthenticationPolicy.CustomTrustStore.Cast() .Any(static certificate => certificate.HasPrivateKey)) { builder.AddError(SR.GetResourceString(SR.ID0511)); } #endif } // Ensure the self-signed TLS client authentication chain policy doesn't contain any certificate. if (options.SelfSignedTlsClientAuthenticationPolicy is not null) { if (options.SelfSignedTlsClientAuthenticationPolicy.ExtraStore.Count is not 0) { builder.AddError(SR.GetResourceString(SR.ID0502)); } #if NET if (options.SelfSignedTlsClientAuthenticationPolicy.CustomTrustStore.Count is not 0) { builder.AddError(SR.GetResourceString(SR.ID0502)); } #endif } if (options.EnableDegradedMode) { // If the degraded mode was enabled, ensure custom validation handlers // have been registered for the endpoints that require manual validation. if (options.AuthorizationEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => descriptor.ContextType == typeof(ValidateAuthorizationRequestContext) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0089)); } if (options.DeviceAuthorizationEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => (descriptor.ContextType == typeof(ValidateDeviceAuthorizationRequestContext) || descriptor.ContextType == typeof(ProcessAuthenticationContext)) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0090)); } if (options.IntrospectionEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => (descriptor.ContextType == typeof(ValidateIntrospectionRequestContext) || descriptor.ContextType == typeof(ProcessAuthenticationContext)) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0091)); } if (options.EndSessionEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => descriptor.ContextType == typeof(ValidateEndSessionRequestContext) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0092)); } if (options.PushedAuthorizationEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => (descriptor.ContextType == typeof(ValidatePushedAuthorizationRequestContext) || descriptor.ContextType == typeof(ProcessAuthenticationContext)) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0466)); } if (options.RevocationEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => (descriptor.ContextType == typeof(ValidateRevocationRequestContext) || descriptor.ContextType == typeof(ProcessAuthenticationContext)) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0093)); } if (options.TokenEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => (descriptor.ContextType == typeof(ValidateTokenRequestContext) || descriptor.ContextType == typeof(ProcessAuthenticationContext)) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0094)); } if (options.EndUserVerificationEndpointUris.Count is not 0 && !options.Handlers.Exists(static descriptor => descriptor.ContextType == typeof(ValidateEndUserVerificationRequestContext) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0095)); } // If the degraded mode was enabled, ensure custom validation/generation handlers // have been registered to deal with device/user codes validation and generation. if (options.GrantTypes.Contains(GrantTypes.DeviceCode)) { if (!options.Handlers.Exists(static descriptor => descriptor.ContextType == typeof(ValidateTokenContext) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0096)); } if (!options.Handlers.Exists(static descriptor => descriptor.ContextType == typeof(GenerateTokenContext) && descriptor.Type is OpenIddictServerHandlerType.Custom && descriptor.FilterTypes.All(static type => !typeof(RequireDegradedModeDisabled).IsAssignableFrom(type)))) { builder.AddError(SR.GetResourceString(SR.ID0097)); } } } if (!options.DisableTokenStorage) { if (options.UserCodeLength is < 6) { builder.AddError(SR.FormatID0439(6)); } if (options.UserCodeCharset.Count is < 9) { builder.AddError(SR.FormatID0440(9)); } if (options.UserCodeCharset.Count != options.UserCodeCharset.Distinct(StringComparer.Ordinal).Count()) { builder.AddError(SR.GetResourceString(SR.ID0436)); } #if NET // On supported platforms, ensure each character added to the // charset represents exactly one grapheme cluster/text element. if (options.UserCodeCharset.Any(static character => !ValidateUserCodeCharacter(character))) { builder.AddError(SR.GetResourceString(SR.ID0437)); } #else // On unsupported platforms, prevent non-ASCII characters from being used. if (options.UserCodeCharset.Any(static character => character.Any(static character => (uint) character > '\x007f'))) { builder.AddError(SR.GetResourceString(SR.ID0438)); } #endif if (!string.IsNullOrEmpty(options.UserCodeDisplayFormat) && options.UserCodeCharset.Contains("-", StringComparer.Ordinal) && options.UserCodeDisplayFormat.Any(static character => character is '-')) { builder.AddError(SR.FormatID0441('-')); } #if NET static bool ValidateUserCodeCharacter(string character) { var enumerator = StringInfo.GetTextElementEnumerator(character); return enumerator.MoveNext() && !enumerator.MoveNext(); } #endif } return builder.Build(); static bool TryValidateMtlsEndpointAlias(Uri? uri) => uri is null || (uri.IsAbsoluteUri && string.Equals(uri.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)); } }