using System; using System.Net.Http; using System.Net.Http.Headers; using System.Text; using System.Text.Json; using System.Threading; using System.Threading.Tasks; using CarpaNet.OAuth.Crypto; using CarpaNet.OAuth.Storage; using CarpaNet.Auth; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; namespace CarpaNet.OAuth; /// /// Token provider that uses OAuth 2.0 with DPoP for ATProtocol. /// public sealed class DPoPTokenProvider : ITokenProvider, IDisposable { private readonly HttpClient _httpClient; private readonly IOAuthSessionStore _sessionStore; private readonly AuthorizationServerDiscovery _discovery; private readonly DPoPNonceCache _nonceCache; private readonly TimeSpan _refreshBuffer; private readonly string? _clientId; private readonly string? _redirectUri; private readonly string? _scope; private readonly SemaphoreSlim _refreshLock = new SemaphoreSlim(1, 1); private readonly ILogger _logger; private string? _sub; private DPoPKeyPair? _dpopKey; private TokenSet? _tokenSet; private OAuthAuthorizationServerMetadata? _serverMetadata; private bool _disposed; /// public bool HasValidToken => _tokenSet != null && !_tokenSet.IsExpired(_refreshBuffer); /// public string? CurrentDid => _sub; /// public Uri? PdsUrl => _tokenSet != null ? new Uri(_tokenSet.Audience) : null; /// /// Gets the current access token. /// public string? AccessToken => _tokenSet?.AccessToken; /// /// Gets the current refresh token. /// public string? RefreshToken => _tokenSet?.RefreshToken; /// /// Gets when the current access token expires, if known. /// public DateTimeOffset? ExpiresAt => _tokenSet?.ExpiresAt; /// public event EventHandler? TokenRefreshed; /// /// Creates a new DPoP token provider. /// /// The HttpClient to use. /// The session store. /// The authorization server discovery client. /// Token refresh buffer time. /// The OAuth client ID to include in token requests. /// The OAuth redirect URI to persist with the session. /// The OAuth scope to persist with the session. /// Optional logger factory for diagnostic logging. public DPoPTokenProvider( HttpClient httpClient, IOAuthSessionStore sessionStore, AuthorizationServerDiscovery? discovery = null, TimeSpan? refreshBuffer = null, string? clientId = null, string? redirectUri = null, string? scope = null, ILoggerFactory? loggerFactory = null) { _httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient)); _sessionStore = sessionStore ?? throw new ArgumentNullException(nameof(sessionStore)); _discovery = discovery ?? new AuthorizationServerDiscovery(httpClient, loggerFactory: loggerFactory); _nonceCache = new DPoPNonceCache(); _refreshBuffer = refreshBuffer ?? TimeSpan.FromSeconds(30); _clientId = clientId; _redirectUri = redirectUri; _scope = scope; _logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger(); } /// /// Restores a session from stored data. /// /// The user's DID. /// Cancellation token. /// True if the session was restored, false if not found. public async Task RestoreSessionAsync(string sub, CancellationToken cancellationToken = default) { ThrowIfDisposed(); var sessionData = await _sessionStore.GetAsync(sub, cancellationToken).ConfigureAwait(false); if (sessionData == null) { _logger.LogWarning("No stored session found for {Did}", sub); return false; } _sub = sub; _tokenSet = sessionData.TokenSet; _dpopKey = DPoPKeyPair.Import(sessionData.DPoPKey); // Fetch server metadata _serverMetadata = await _discovery.GetMetadataAsync( sessionData.TokenSet.Issuer, cancellationToken).ConfigureAwait(false); _logger.LogDebug("DPoP session restored for {Did}", sub); return true; } /// /// Sets up the provider with a token set from a successful authorization. /// internal async Task SetupAsync( string sub, TokenSet tokenSet, DPoPKeyPair dpopKey, OAuthAuthorizationServerMetadata serverMetadata, CancellationToken cancellationToken = default) { ThrowIfDisposed(); _sub = sub; _tokenSet = tokenSet; _dpopKey = dpopKey; _serverMetadata = serverMetadata; // Store the session await _sessionStore.StoreAsync(sub, new OAuthSessionData { DPoPKey = dpopKey.ExportKeyPair(), TokenSet = tokenSet, ClientId = _clientId, RedirectUri = _redirectUri, Scope = _scope }, cancellationToken).ConfigureAwait(false); } /// public async Task GetAccessTokenAsync(CancellationToken cancellationToken = default) { ThrowIfDisposed(); if (_tokenSet == null) { return null; } // Check if we need to refresh if (_tokenSet.IsExpired(_refreshBuffer)) { await RefreshAsync(cancellationToken).ConfigureAwait(false); } return _tokenSet?.AccessToken; } /// public async Task RefreshAsync(CancellationToken cancellationToken = default) { ThrowIfDisposed(); if (_tokenSet == null || string.IsNullOrEmpty(_tokenSet.RefreshToken)) { throw new InvalidOperationException("No refresh token available."); } if (_dpopKey == null || _serverMetadata == null) { throw new InvalidOperationException("Session not properly initialized."); } _logger.LogDebug("Refreshing DPoP token for {Sub}", _sub); await _refreshLock.WaitAsync(cancellationToken).ConfigureAwait(false); try { // Double-check after acquiring lock if (HasValidToken) { _logger.LogDebug("Token still valid after lock, skipping refresh"); return; } var tokenEndpoint = _serverMetadata.TokenEndpoint; // Build refresh request var formContent = new StringBuilder(); formContent.Append("grant_type=refresh_token"); formContent.Append("&refresh_token="); formContent.Append(Uri.EscapeDataString(_tokenSet.RefreshToken)); if (!string.IsNullOrEmpty(_clientId)) { formContent.Append("&client_id="); formContent.Append(Uri.EscapeDataString(_clientId)); } // Try with cached nonce first, retry with new nonce if needed var newTokenSet = await ExecuteTokenRequestWithRetryAsync( tokenEndpoint, formContent.ToString(), cancellationToken).ConfigureAwait(false); // Update token set var oldRefreshToken = _tokenSet.RefreshToken; _tokenSet = newTokenSet; _tokenSet.Issuer = _serverMetadata.Issuer; _tokenSet.Audience = PdsUrl?.ToString() ?? string.Empty; // Keep old refresh token if new one not provided if (string.IsNullOrEmpty(_tokenSet.RefreshToken)) { _tokenSet.RefreshToken = oldRefreshToken; } // Update session store await _sessionStore.StoreAsync(_sub!, new OAuthSessionData { DPoPKey = _dpopKey.ExportKeyPair(), TokenSet = _tokenSet, ClientId = _clientId, RedirectUri = _redirectUri, Scope = _scope }, cancellationToken).ConfigureAwait(false); _logger.LogInformation("DPoP token refreshed for {Sub}", _sub); // Notify listeners TokenRefreshed?.Invoke(this, new TokenRefreshedEventArgs( _tokenSet.AccessToken, _tokenSet.RefreshToken!, _sub ?? string.Empty, null)); // OAuth doesn't return handle } catch (Exception ex) { _logger.LogError("DPoP token refresh failed for {Sub}", _sub); throw new TokenRefreshException( "refresh_failed", ex.Message, _sub, ex); } finally { _refreshLock.Release(); } } /// /// Adds DPoP proof and authorization headers to an existing HTTP request. /// /// The HTTP request to add headers to. /// Whether to include the access token. public void AddDPoPHeaders(HttpRequestMessage request, bool includeAccessToken = true) { ThrowIfDisposed(); if (_dpopKey == null) { throw new InvalidOperationException("No DPoP key available."); } var url = request.RequestUri!.ToString(); var nonce = _nonceCache.Get(url); var accessToken = includeAccessToken ? _tokenSet?.AccessToken : null; var proof = _dpopKey.CreateProof(request.Method.Method, url, nonce, accessToken); // Remove existing DPoP headers before adding new ones request.Headers.Remove("DPoP"); request.Headers.Remove("Authorization"); request.Headers.Add("DPoP", proof); if (includeAccessToken && !string.IsNullOrEmpty(accessToken)) { request.Headers.Authorization = new AuthenticationHeaderValue("DPoP", accessToken); } } /// /// Adds DPoP proof and authorization headers to an existing HTTP request asynchronously. /// Works on all platforms including browser. /// /// The HTTP request to add headers to. /// Whether to include the access token. public async Task AddDPoPHeadersAsync(HttpRequestMessage request, bool includeAccessToken = true) { ThrowIfDisposed(); if (_dpopKey == null) { throw new InvalidOperationException("No DPoP key available."); } var url = request.RequestUri!.ToString(); var nonce = _nonceCache.Get(url); var accessToken = includeAccessToken ? _tokenSet?.AccessToken : null; var proof = await _dpopKey.CreateProofAsync(request.Method.Method, url, nonce, accessToken).ConfigureAwait(false); // Remove existing DPoP headers before adding new ones request.Headers.Remove("DPoP"); request.Headers.Remove("Authorization"); request.Headers.Add("DPoP", proof); if (includeAccessToken && !string.IsNullOrEmpty(accessToken)) { request.Headers.Authorization = new AuthenticationHeaderValue("DPoP", accessToken); } } /// /// Creates a DPoP-signed HTTP request. /// /// The HTTP method. /// The request URL. /// Whether to include the access token. /// The HTTP request message with DPoP headers. public HttpRequestMessage CreateDPoPRequest(HttpMethod method, string url, bool includeAccessToken = true) { ThrowIfDisposed(); if (_dpopKey == null) { throw new InvalidOperationException("No DPoP key available."); } var nonce = _nonceCache.Get(url); var accessToken = includeAccessToken ? _tokenSet?.AccessToken : null; var proof = _dpopKey.CreateProof(method.Method, url, nonce, accessToken); var request = new HttpRequestMessage(method, url); request.Headers.Add("DPoP", proof); if (includeAccessToken && !string.IsNullOrEmpty(accessToken)) { request.Headers.Authorization = new AuthenticationHeaderValue("DPoP", accessToken); } return request; } /// /// Creates a DPoP-signed HTTP request asynchronously. /// Works on all platforms including browser. /// /// The HTTP method. /// The request URL. /// Whether to include the access token. /// The HTTP request message with DPoP headers. public async Task CreateDPoPRequestAsync(HttpMethod method, string url, bool includeAccessToken = true) { ThrowIfDisposed(); if (_dpopKey == null) { throw new InvalidOperationException("No DPoP key available."); } var nonce = _nonceCache.Get(url); var accessToken = includeAccessToken ? _tokenSet?.AccessToken : null; var proof = await _dpopKey.CreateProofAsync(method.Method, url, nonce, accessToken).ConfigureAwait(false); var request = new HttpRequestMessage(method, url); request.Headers.Add("DPoP", proof); if (includeAccessToken && !string.IsNullOrEmpty(accessToken)) { request.Headers.Authorization = new AuthenticationHeaderValue("DPoP", accessToken); } return request; } /// /// Updates the DPoP nonce from a response. /// /// The HTTP response. /// The request URL. public void UpdateNonceFromResponse(HttpResponseMessage response, string url) { if (response.Headers.TryGetValues("DPoP-Nonce", out var values)) { foreach (var nonce in values) { _nonceCache.Set(url, nonce); _logger.LogTrace("DPoP nonce updated for {Origin}", url); break; } } } private async Task ExecuteTokenRequestWithRetryAsync( string tokenEndpoint, string formContent, CancellationToken cancellationToken) { // First attempt try { return await ExecuteTokenRequestAsync(tokenEndpoint, formContent, cancellationToken).ConfigureAwait(false); } catch (DPoPNonceException ex) when (!string.IsNullOrEmpty(ex.NewNonce)) { _logger.LogDebug("DPoP nonce retry required"); // Store the new nonce and retry _nonceCache.Set(tokenEndpoint, ex.NewNonce!); return await ExecuteTokenRequestAsync(tokenEndpoint, formContent, cancellationToken).ConfigureAwait(false); } } private async Task ExecuteTokenRequestAsync( string tokenEndpoint, string formContent, CancellationToken cancellationToken) { _logger.LogDebug("Executing token request to {Endpoint}", tokenEndpoint); using var request = await CreateDPoPRequestAsync(HttpMethod.Post, tokenEndpoint, includeAccessToken: false).ConfigureAwait(false); request.Content = new StringContent(formContent, Encoding.UTF8, "application/x-www-form-urlencoded"); var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false); // Always update nonce from response UpdateNonceFromResponse(response, tokenEndpoint); if (!response.IsSuccessStatusCode) { var errorContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // Check for use_dpop_nonce error try { var errorResponse = JsonSerializer.Deserialize(errorContent, OAuthJsonContext.Default.OAuthErrorResponse); if (errorResponse?.Error == "use_dpop_nonce") { // Get the nonce from the response header string? newNonce = null; if (response.Headers.TryGetValues("DPoP-Nonce", out var nonceValues)) { foreach (var n in nonceValues) { newNonce = n; break; } } throw new DPoPNonceException(newNonce); } throw new OAuthException( errorResponse?.Error ?? "token_error", errorResponse?.ErrorDescription ?? errorContent); } catch (JsonException) { throw new OAuthException("token_error", errorContent); } } var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var tokenResponse = JsonSerializer.Deserialize(content, OAuthJsonContext.Default.OAuthTokenResponse); if (tokenResponse == null) { throw new OAuthException("invalid_response", "Failed to parse token response."); } return TokenSet.FromResponse(tokenResponse, _serverMetadata!.Issuer, _tokenSet!.Audience); } private void ThrowIfDisposed() { if (_disposed) { throw new ObjectDisposedException(nameof(DPoPTokenProvider)); } } /// public void Dispose() { if (_disposed) { return; } _disposed = true; _refreshLock.Dispose(); _dpopKey?.Dispose(); } }