220 lines
9.6 KiB
C#
220 lines
9.6 KiB
C#
using System.Net;
|
|
using Bifrost.Web.Configuration;
|
|
using Bifrost.Web.Data;
|
|
using Microsoft.IdentityModel.JsonWebTokens;
|
|
using Microsoft.IdentityModel.Tokens;
|
|
using Microsoft.Extensions.Options;
|
|
using OpenIddict.Abstractions;
|
|
using OpenIddict.Server;
|
|
using static OpenIddict.Abstractions.OpenIddictConstants;
|
|
|
|
namespace Bifrost.Web.Features.Oidc;
|
|
|
|
/// <summary>
|
|
/// Ends the chat sessions of a subject who is no longer allowed to chat (suspended, or the account gone). Each tick it lists the subjects holding valid
|
|
/// authorizations of the configured client; for each one the shared chat-eligibility reading refuses, it POSTs one signed
|
|
/// OIDC back-channel logout token to MAS and, only after a 2xx, revokes that subject's authorizations. The
|
|
/// authorizations table is the queue: nothing is stored, so a restart, a MAS outage or a later-set URI resumes from it.
|
|
/// Per-subject backoff lives in memory only. One subject's unexpected exception is logged and skipped, never aborting the
|
|
/// pass. It never writes membership.
|
|
/// </summary>
|
|
public sealed class OidcLogoutReconciler(
|
|
IServiceScopeFactory scopeFactory,
|
|
OidcIssuerOptions options,
|
|
OidcKeyMaterial material,
|
|
IOptions<OpenIddictServerOptions> serverOptions,
|
|
IHttpClientFactory httpClients,
|
|
TimeProvider time,
|
|
ILogger<OidcLogoutReconciler> logger) : BackgroundService
|
|
{
|
|
public const string HttpClientName = "bifrost-oidc-logout";
|
|
public const string LogoutEvent = "http://schemas.openid.net/event/backchannel-logout";
|
|
public const string LogoutTokenType = "logout+jwt";
|
|
|
|
public static readonly TimeSpan Interval = TimeSpan.FromSeconds(30);
|
|
public static readonly TimeSpan RequestTimeout = TimeSpan.FromSeconds(10);
|
|
public static readonly TimeSpan TokenLifetime = TimeSpan.FromMinutes(2);
|
|
public static readonly TimeSpan MaxBackoff = TimeSpan.FromMinutes(15);
|
|
|
|
private readonly Dictionary<string, Backoff> _backoff = new(StringComparer.Ordinal);
|
|
|
|
private sealed record Backoff(int Failures, DateTimeOffset NotBefore);
|
|
|
|
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
|
{
|
|
while (!stoppingToken.IsCancellationRequested)
|
|
{
|
|
try
|
|
{
|
|
await ReconcileOnceAsync(stoppingToken);
|
|
await Task.Delay(Interval, time, stoppingToken);
|
|
}
|
|
catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
|
|
{
|
|
return;
|
|
}
|
|
catch (Exception error)
|
|
{
|
|
// The type only: messages can carry connection strings or URLs.
|
|
logger.LogError("Back-channel logout reconcile failed: {ErrorType}", error.GetType().Name);
|
|
try
|
|
{
|
|
await Task.Delay(Interval, time, stoppingToken);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>One reconcile pass. Subjects are independent: one that cannot be delivered never blocks another.</summary>
|
|
public async Task ReconcileOnceAsync(CancellationToken cancellationToken)
|
|
{
|
|
var subjects = await ListSubjectsAsync(cancellationToken);
|
|
foreach (var gone in _backoff.Keys.Except(subjects).ToArray())
|
|
{
|
|
_backoff.Remove(gone);
|
|
}
|
|
|
|
foreach (var subject in subjects)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
try
|
|
{
|
|
await ReconcileSubjectAsync(subject, cancellationToken);
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
throw;
|
|
}
|
|
catch (Exception error)
|
|
{
|
|
// One subject's fault never stops the pass: its authorizations stay valid and the next tick retries it.
|
|
// The subject id and the exception type only: messages can carry connection strings or URLs.
|
|
logger.LogError("Back-channel logout for subject {Subject} failed: {ErrorType}", subject, error.GetType().Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task<HashSet<string>> ListSubjectsAsync(CancellationToken cancellationToken)
|
|
{
|
|
await using var scope = scopeFactory.CreateAsyncScope();
|
|
var applications = scope.ServiceProvider.GetRequiredService<IOpenIddictApplicationManager>();
|
|
var authorizations = scope.ServiceProvider.GetRequiredService<IOpenIddictAuthorizationManager>();
|
|
|
|
var subjects = new HashSet<string>(StringComparer.Ordinal);
|
|
var application = await applications.FindByClientIdAsync(options.Clients.Mas.ClientId, cancellationToken);
|
|
if (application is null || await applications.GetIdAsync(application, cancellationToken) is not { } applicationId)
|
|
{
|
|
return subjects;
|
|
}
|
|
|
|
await foreach (var authorization in authorizations.FindByApplicationIdAsync(applicationId, cancellationToken))
|
|
{
|
|
if (await authorizations.HasStatusAsync(authorization, Statuses.Valid, cancellationToken) &&
|
|
await authorizations.GetSubjectAsync(authorization, cancellationToken) is { Length: > 0 } subject)
|
|
{
|
|
subjects.Add(subject);
|
|
}
|
|
}
|
|
|
|
return subjects;
|
|
}
|
|
|
|
private async Task ReconcileSubjectAsync(string subject, CancellationToken cancellationToken)
|
|
{
|
|
await using var scope = scopeFactory.CreateAsyncScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<BifrostDbContext>();
|
|
if (await OidcEndpoints.IsStillChatEligibleAsync(db, subject, cancellationToken))
|
|
{
|
|
_backoff.Remove(subject);
|
|
return;
|
|
}
|
|
|
|
// A subject that recovered is forgotten at once; one still owed a logout waits out its backoff.
|
|
_backoff.TryGetValue(subject, out var previous);
|
|
if (previous is not null && time.GetUtcNow() < previous.NotBefore)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var failures = (previous?.Failures ?? 0) + 1;
|
|
var status = await SendLogoutAsync(subject, cancellationToken);
|
|
if (status is { } code && (int)code is >= 200 and < 300)
|
|
{
|
|
var authorizations = scope.ServiceProvider.GetRequiredService<IOpenIddictAuthorizationManager>();
|
|
await foreach (var authorization in authorizations.FindBySubjectAsync(subject, cancellationToken))
|
|
{
|
|
if (await authorizations.HasStatusAsync(authorization, Statuses.Valid, cancellationToken))
|
|
{
|
|
await authorizations.TryRevokeAsync(authorization, cancellationToken);
|
|
}
|
|
}
|
|
|
|
_backoff.Remove(subject);
|
|
return;
|
|
}
|
|
|
|
// 400 (token refused) and 404 (unknown provider) are configuration faults: retrying sooner cannot fix them.
|
|
var fault = status is HttpStatusCode.BadRequest or HttpStatusCode.NotFound;
|
|
var delay = fault ? MaxBackoff : BackoffFor(failures);
|
|
_backoff[subject] = new Backoff(failures, time.GetUtcNow() + delay);
|
|
logger.LogWarning(
|
|
"Back-channel logout to MAS failed with {Status}; retrying in {Delay}",
|
|
status is { } s ? (int)s : "no response",
|
|
delay);
|
|
}
|
|
|
|
internal static TimeSpan BackoffFor(int failures)
|
|
{
|
|
var seconds = Interval.TotalSeconds * Math.Pow(2, Math.Min(failures, 16) - 1);
|
|
return TimeSpan.FromSeconds(Math.Min(seconds, MaxBackoff.TotalSeconds));
|
|
}
|
|
|
|
/// <summary>The status MAS answered, or null on a network fault or timeout. The response body is never read.</summary>
|
|
private async Task<HttpStatusCode?> SendLogoutAsync(string subject, CancellationToken cancellationToken)
|
|
{
|
|
var token = BuildLogoutToken(subject);
|
|
using var request = new HttpRequestMessage(HttpMethod.Post, options.Clients.Mas.BackchannelLogoutUri)
|
|
{
|
|
Content = new FormUrlEncodedContent([new KeyValuePair<string, string>("logout_token", token)])
|
|
};
|
|
try
|
|
{
|
|
using var response = await httpClients.CreateClient(HttpClientName)
|
|
.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
|
|
return response.StatusCode;
|
|
}
|
|
catch (Exception error) when (error is HttpRequestException or TaskCanceledException && !cancellationToken.IsCancellationRequested)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The OIDC back-channel logout token MAS verifies like an id_token: iss and aud as the id_token carries them, exp
|
|
/// and iat both present, an events member, and neither nonce nor sid (MAS finds the session by sub).
|
|
/// </summary>
|
|
private string BuildLogoutToken(string subject)
|
|
{
|
|
var now = time.GetUtcNow();
|
|
var descriptor = new SecurityTokenDescriptor
|
|
{
|
|
TokenType = LogoutTokenType,
|
|
Issuer = serverOptions.Value.Issuer!.AbsoluteUri,
|
|
Audience = options.Clients.Mas.ClientId,
|
|
IssuedAt = now.UtcDateTime,
|
|
Expires = now.UtcDateTime + TokenLifetime,
|
|
SigningCredentials = new SigningCredentials(material.SigningKey, SecurityAlgorithms.EcdsaSha256),
|
|
Claims = new Dictionary<string, object>
|
|
{
|
|
[Claims.Subject] = Guid.TryParse(subject, out var id) ? id.ToString("D") : subject,
|
|
[Claims.JwtId] = Guid.NewGuid().ToString("D"),
|
|
["events"] = new Dictionary<string, object> { [LogoutEvent] = new Dictionary<string, object>() }
|
|
}
|
|
};
|
|
return new JsonWebTokenHandler().CreateToken(descriptor);
|
|
}
|
|
}
|