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();
}
}