Bifrost/tests/Bifrost.Web.Tests/LinkedAccountsTests.cs
Heimdall 425af74500 Passkeys: WebAuthn enrolment under a fresh sign-in, 48 h cooling-off, assertion proof at unlink (#85)
Delta Soul clean at 73f97ed (no blocking findings; one Low: challenge check and spend not atomic).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-14 00:37:56 +00:00

912 lines
43 KiB
C#

using System.Net;
using System.Text.Json;
using Bifrost.Web.Features.Heimdall;
using Bifrost.Web.Features.Shared;
using Bifrost.Web.Tests.Support;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.DependencyInjection;
namespace Bifrost.Web.Tests;
/// <summary>
/// The Linked accounts page from the member's side, against a fake Heimdall. Bifrost keeps no Heimdall token: a list, a link
/// and an unlink each follow a fresh Heimdall sign-in begun by Bifrost, and the bearer lives inside that one completion request.
/// </summary>
public sealed class LinkedAccountsTests
{
private const string Page = "/Membership/LinkedAccounts";
private const string ErrorRedirect = "/?auth=heimdall-error";
private static string Jar(string session, StartedAttempt attempt) =>
$"{BifrostCookies.Session}={session}; {attempt.CookieName}={attempt.Cookie}";
private static string? Location(HttpResponseMessage response) => response.Headers.Location?.OriginalString;
private static string Unprotect(HeimdallHost host, string cookie) =>
host.Services.GetRequiredService<IDataProtectionProvider>().CreateProtector("Bifrost.Heimdall.Attempt.v1").Unprotect(cookie);
/// <summary>The fresh sign-in's completion as the browser posts it: Heimdall minted a code for <paramref name="proofAccount"/>.</summary>
private static async Task<HttpResponseMessage> Finish(
HeimdallHost host, string session, StartedAttempt attempt, string proofAccount, string? token = null,
string mode = "sign_in", string provider = "discord", string? sessionOverride = null, bool? stepUpRequested = null)
{
var code = host.CodeFor(attempt, proofAccount, token, mode: mode, provider: provider, stepUpRequested: stepUpRequested);
return await host.PostCompleteAsync(
new Dictionary<string, string> { ["attempt"] = attempt.Nonce, ["code"] = code }, Jar(sessionOverride ?? session, attempt));
}
private static string StepUpToken(HeimdallHost host, string account) =>
host.Token(account, mutate: claims => claims["step_up_at"] = host.Clock.Now.ToUnixTimeSeconds());
private sealed record Member(string Account, string Session);
/// <summary>A signed-in member whose fake Heimdall account holds these providers, and whose list has been read once.</summary>
private static async Task<Member> ListedMember(HeimdallHost host, params string[] providers)
{
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
foreach (var provider in providers)
{
host.Heimdall.AddIdentity(provider, "Name of " + provider);
}
var start = await host.StartListAsync(session, providers[0]);
var done = await Finish(host, session, start, account);
Assert.Equal(Page + "?result=listed", Location(done));
Assert.Empty(host.Heimdall.OrphanMints);
return new Member(account, session);
}
// ---- who may use the page ----
[Fact]
public async Task An_anonymous_visitor_is_challenged_and_nothing_is_started()
{
using var host = new HeimdallHost(realSessions: true);
var (get, _) = await host.GetLinkedAccountsAsync(session: null);
var post = await host.PostLinkedAccountsAsync(session: null, "Refresh");
Assert.Equal(HttpStatusCode.Redirect, get.StatusCode);
Assert.Contains("/auth/sign-in", Location(get));
Assert.NotEqual(HttpStatusCode.OK, post.Response.StatusCode);
Assert.Empty(host.Heimdall.StartBodies);
}
[Fact]
public async Task The_page_is_no_store_and_a_member_without_a_list_is_offered_one()
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
var (response, html) = await host.GetLinkedAccountsAsync(session);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Contains("no-store", response.Headers.CacheControl?.ToString());
Assert.Contains("Show my logins through", html);
Assert.Contains("Show my logins through Patreon", html);
Assert.Contains("will not choose one for you", html);
Assert.DoesNotContain("Link Discord", html);
Assert.DoesNotContain("Unlink", html);
}
[Fact]
public async Task With_a_list_the_page_offers_each_admitted_provider_to_link_and_never_twitch()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var (_, html) = await host.GetLinkedAccountsAsync(member.Session);
Assert.Contains("Link Discord", html);
Assert.Contains("Link Patreon", html);
Assert.Contains("Link Google", html);
Assert.DoesNotContain("Link Twitch", html);
}
[Fact]
public async Task After_the_list_expired_a_proof_is_never_started_through_a_provider_the_member_unlinked()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account); // signed in through Discord
var discord = host.Heimdall.AddIdentity("discord", "D");
host.Heimdall.AddIdentity("google", "G");
var list = await host.StartListAsync(session, "discord");
await Finish(host, session, list, account);
var unlink = await host.StartUnlinkAsync(session, discord);
var done = await Finish(host, session, unlink, account, provider: "google");
Assert.Equal(Page + "?result=unlinked", Location(done));
host.Clock.Advance(LinkedAccountsSnapshots.Lifetime + TimeSpan.FromSeconds(1));
var starts = host.Heimdall.StartBodies.Count;
var refresh = await host.StartListAsync(session, via: null);
var link = await host.StartLinkAsync(session, "patreon", seedList: false);
var (_, html) = await host.GetLinkedAccountsAsync(session);
// Signing in through Discord again would mint an unrelated account holding that login: nothing is started.
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=provider_needed", Location(refresh.Response));
Assert.Equal(Page + "?result=list_expired", Location(link.Response));
Assert.Empty(host.Heimdall.OrphanMints);
Assert.Contains("will not choose one for you", html);
Assert.DoesNotContain("Link Patreon", html);
}
[Theory]
[InlineData(HttpStatusCode.InternalServerError)]
[InlineData(HttpStatusCode.OK)]
public async Task An_unlink_whose_answer_is_lost_drops_the_list_and_a_link_then_starts_nothing(HttpStatusCode lost)
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var discord = (string)host.Heimdall.Identities[0]["id"]!;
var start = await host.StartUnlinkAsync(member.Session, discord);
host.Heimdall.UnlinkApplyThenFail = lost;
var done = await Finish(host, member.Session, start, member.Account, provider: "google");
var starts = host.Heimdall.StartBodies.Count;
var link = await host.StartLinkAsync(member.Session, "patreon", seedList: false);
var (_, html) = await host.GetLinkedAccountsAsync(member.Session);
// Heimdall did unlink Discord. Linking now through the stale list would sign in through Discord and mint an orphan.
Assert.Equal(Page + "?result=error", Location(done));
Assert.Single(host.Heimdall.Identities);
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=list_expired", Location(link.Response));
Assert.Empty(host.Heimdall.OrphanMints);
Assert.Contains("will not choose one for you", html);
}
[Fact]
public async Task Without_a_list_the_picker_names_Google_first_as_unable_to_create_an_account()
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
var (_, html) = await host.GetLinkedAccountsAsync(session);
Assert.Contains("Google cannot do that", html);
Assert.Contains("through Google (cannot create an account)", html);
Assert.True(html.IndexOf("Show my logins through Google", StringComparison.Ordinal) < html.IndexOf("Show my logins through Discord", StringComparison.Ordinal));
}
[Fact]
public void With_no_list_and_no_choice_there_is_no_proof_provider()
{
Assert.Null(HeimdallAuthService.ProofProvider(null, null));
Assert.Null(HeimdallAuthService.ProofProvider(null, "twitch"));
Assert.Equal("patreon", HeimdallAuthService.ProofProvider(null, "Patreon"));
Assert.Null(HeimdallAuthService.ProofProvider([], "discord"));
Assert.Null(HeimdallAuthService.ProofProvider(["twitch"], null));
Assert.Equal("patreon", HeimdallAuthService.ProofProvider(["google", "patreon"], null));
}
[Fact]
public async Task The_service_refuses_to_start_a_proof_with_no_list_and_no_choice()
{
using var host = new HeimdallHost(realSessions: true);
using var scope = host.Services.CreateScope();
var service = scope.ServiceProvider.GetRequiredService<HeimdallAuthService>();
var starts = host.Heimdall.StartBodies.Count;
await Assert.ThrowsAsync<HeimdallAuthException>(() => service.StartListAsync(
HeimdallShapes.NewAccountId(), null, "https://localhost", [], CancellationToken.None));
await Assert.ThrowsAsync<HeimdallAuthException>(() => service.StartLinkAsync(
HeimdallShapes.NewAccountId(), "patreon", "https://localhost", [], CancellationToken.None));
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
}
[Theory]
[InlineData(null)]
[InlineData("twitch")]
[InlineData("nonsense")]
public async Task Without_a_list_the_member_must_name_an_admitted_provider_or_nothing_is_started(string? via)
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
var starts = host.Heimdall.StartBodies.Count;
var post = await host.StartListAsync(session, via);
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=provider_needed", Location(post.Response));
}
[Fact]
public async Task With_a_list_the_member_cannot_steer_the_proof_to_a_provider_the_account_does_not_hold()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "patreon", "google");
var post = await host.StartListAsync(member.Session, "discord");
Assert.Equal("/v1/oauth/patreon/start", host.Heimdall.StartPaths[^1]);
Assert.Empty(host.Heimdall.OrphanMints);
Assert.NotNull(post.Cookie);
}
[Fact]
public async Task A_session_with_no_Heimdall_account_has_nothing_to_list_and_starts_nothing()
{
using var host = new HeimdallHost();
var (response, html) = await host.GetLinkedAccountsAsync(session: null);
var start = await host.StartListAsync(session: null);
// No form, so no antiforgery token to make the response uncacheable: the page itself must say no-store.
Assert.Contains("no-store", response.Headers.CacheControl?.ToString());
Assert.Contains("not a Heimdall account", html);
Assert.DoesNotContain("Link Discord", html);
Assert.Empty(host.Heimdall.StartBodies);
Assert.Null(start.Cookie);
}
[Theory]
[InlineData("Refresh")]
[InlineData("Link")]
[InlineData("Unlink")]
public async Task Every_post_needs_the_antiforgery_token_and_a_get_starts_nothing(string handler)
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
var form = new Dictionary<string, string> { ["provider"] = "discord", ["identityId"] = Guid.NewGuid().ToString() };
var starts = host.Heimdall.StartBodies.Count;
var without = await host.PostLinkedAccountsAsync(session, handler, form, antiforgery: false);
var get = await host.PostLinkedAccountsAsync(session, handler, form, method: HttpMethod.Get);
Assert.Equal(HttpStatusCode.BadRequest, without.Response.StatusCode);
Assert.Null(without.Cookie);
Assert.Null(get.Cookie);
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
}
// ---- the list ----
[Fact]
public async Task The_list_is_a_fresh_ordinary_sign_in_then_GET_identities_with_its_bearer_and_the_page_shows_it()
{
using var host = new HeimdallHost(traceHttp: true, realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
host.Heimdall.AddIdentity("discord", "Discord Dana");
host.Heimdall.AddIdentity("google", "Google Gale");
var signIns = host.Heimdall.StartBodies.Count;
var start = await host.StartListAsync(session);
Assert.Equal(signIns + 1, host.Heimdall.StartBodies.Count);
using (var body = JsonDocument.Parse(host.Heimdall.StartBodies[^1]))
{
Assert.Equal("sign_in", body.RootElement.GetProperty("mode").GetString());
Assert.False(body.RootElement.TryGetProperty("stepUp", out _));
}
Assert.Equal("/v1/oauth/discord/start", host.Heimdall.StartPaths[^1]);
Assert.Empty(host.Heimdall.ListAuthorizations);
var token = host.Token(account);
var done = await Finish(host, session, start, account, token);
Assert.Equal(Page + "?result=listed", Location(done));
Assert.Equal(["Bearer " + token], host.Heimdall.ListAuthorizations);
Assert.Null(HeimdallHost.CookieValue(done, BifrostCookies.Session));
var (_, html) = await host.GetLinkedAccountsAsync(session);
Assert.Contains("Discord Dana", html);
Assert.Contains("Google Gale", html);
Assert.Contains("13 Nov 2026", html);
// Only what the page shows was kept: nothing of the fields a login also carries.
foreach (var canary in new[] { "PUID-CANARY", "username-canary", "scope-canary" })
{
Assert.DoesNotContain(canary, html);
}
}
[Fact]
public async Task No_bearer_reaches_a_cookie_a_log_a_location_or_the_page()
{
using var host = new HeimdallHost(traceHttp: true, realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
host.Heimdall.AddIdentity("discord");
host.Heimdall.AddIdentity("google");
var listStart = await host.StartListAsync(session);
var listToken = host.Token(account);
var listed = await Finish(host, session, listStart, account, listToken);
var unlinkStart = await host.StartUnlinkAsync(session, (string)host.Heimdall.Identities[0]["id"]!);
var stepUpToken = StepUpToken(host, account);
var unlinked = await Finish(host, session, unlinkStart, account, stepUpToken);
Assert.Equal(Page + "?result=unlinked", Location(unlinked));
var (_, html) = await host.GetLinkedAccountsAsync(session);
var logs = string.Join("\n", host.Logs.Lines);
var secrets = new[] { listToken, stepUpToken }
.SelectMany(token => new[] { token, token.Split('.')[2], token.Split('.')[1] })
.ToArray();
Assert.Contains("Bearer", string.Join("\n", host.Heimdall.ListAuthorizations));
foreach (var secret in secrets)
{
Assert.DoesNotContain(secret, logs);
Assert.DoesNotContain(secret, html);
foreach (var response in new[] { listStart.Response, listed, unlinkStart.Response, unlinked })
{
Assert.DoesNotContain(secret, Location(response) ?? string.Empty);
Assert.DoesNotContain(secret, string.Join("\n", response.Headers.SelectMany(x => x.Value)));
}
foreach (var cookie in new[] { listStart.Cookie, unlinkStart.Cookie })
{
var payload = Unprotect(host, cookie!);
Assert.DoesNotContain(secret, payload);
Assert.DoesNotContain("eyJ", payload);
}
}
// The completion itself sets no cookie but the attempt's deletion.
foreach (var response in new[] { listed, unlinked })
{
Assert.All(
response.Headers.TryGetValues("Set-Cookie", out var set) ? set : [],
header => Assert.StartsWith(HeimdallAttemptCookie.Prefix, header, StringComparison.Ordinal));
}
}
[Fact]
public async Task A_list_is_per_account_and_expires_after_five_minutes()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var stranger = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
Assert.Contains("Name of discord", (await host.GetLinkedAccountsAsync(member.Session)).Html);
var (_, other) = await host.GetLinkedAccountsAsync(stranger);
Assert.DoesNotContain("Name of discord", other);
Assert.Contains("Show my logins through", other);
host.Clock.Advance(LinkedAccountsSnapshots.Lifetime + TimeSpan.FromSeconds(1));
var (_, later) = await host.GetLinkedAccountsAsync(member.Session);
Assert.DoesNotContain("Name of discord", later);
Assert.Contains("Show my logins through", later);
}
[Theory]
[InlineData(HttpStatusCode.Unauthorized, "sign_in_required")]
[InlineData(HttpStatusCode.InternalServerError, "error")]
public async Task A_list_Heimdall_refuses_shows_its_fixed_outcome_and_no_list(HttpStatusCode status, string outcome)
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
host.Heimdall.AddIdentity("discord");
host.Heimdall.ListStatus = status;
var start = await host.StartListAsync(session);
var done = await Finish(host, session, start, account);
Assert.Equal($"{Page}?result={outcome}", Location(done));
Assert.DoesNotContain("HEIMDALL FREE TEXT", string.Join("\n", host.Logs.Lines));
Assert.Contains("Show my logins through", (await host.GetLinkedAccountsAsync(session)).Html);
}
[Fact]
public async Task A_Heimdall_that_cannot_be_reached_for_the_list_changes_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
host.Heimdall.AddIdentity("discord");
var start = await host.StartListAsync(session);
host.Heimdall.MemberFailure = new HttpRequestException("connection refused");
var done = await Finish(host, session, start, account);
Assert.Equal(Page + "?result=error", Location(done));
Assert.Contains("Show my logins through", (await host.GetLinkedAccountsAsync(session)).Html);
}
[Fact]
public async Task A_Heimdall_that_is_down_at_the_list_start_is_a_refusal_not_a_server_error()
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
host.Heimdall.StartStatus = HttpStatusCode.ServiceUnavailable;
var start = await host.StartListAsync(session);
Assert.Equal(HttpStatusCode.Redirect, start.Response.StatusCode);
Assert.Equal(Page + "?result=error", Location(start.Response));
Assert.Null(start.Cookie);
}
// ---- unlink ----
[Fact]
public async Task Unlink_starts_a_step_up_sign_in_with_the_app_secret_and_the_unlink_carries_that_sign_ins_bearer()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var discord = (string)host.Heimdall.Identities[0]["id"]!;
var listToken = host.Heimdall.ListAuthorizations.Single();
var starts = host.Heimdall.StartBodies.Count;
var start = await host.StartUnlinkAsync(member.Session, discord);
Assert.Equal(starts + 1, host.Heimdall.StartBodies.Count);
Assert.Equal("/v1/oauth/google/start", host.Heimdall.StartPaths[^1]);
Assert.Equal(HeimdallHost.AppSecret, host.Heimdall.StartSecrets[^1]);
Assert.Null(host.Heimdall.StartAuthorizations[^1]);
using (var body = JsonDocument.Parse(host.Heimdall.StartBodies[^1]))
{
Assert.Equal("sign_in", body.RootElement.GetProperty("mode").GetString());
Assert.True(body.RootElement.GetProperty("stepUp").GetBoolean());
}
Assert.Empty(host.Heimdall.Unlinks);
var token = StepUpToken(host, member.Account);
var done = await Finish(host, member.Session, start, member.Account, token, provider: "google");
Assert.Equal(Page + "?result=unlinked", Location(done));
var unlink = Assert.Single(host.Heimdall.Unlinks);
Assert.Equal(discord, unlink.Id);
Assert.Equal("Bearer " + token, unlink.Authorization);
Assert.NotEqual(listToken, unlink.Authorization);
var (_, html) = await host.GetLinkedAccountsAsync(member.Session);
Assert.DoesNotContain("Name of discord", html);
Assert.Contains("Name of google", html);
Assert.Contains("Heimdall will not remove the last one", html);
Assert.Contains("The login was unlinked.", (await host.GetLinkedAccountsAsync(member.Session, "?result=unlinked")).Html);
}
[Fact]
public async Task The_last_login_is_refused_by_Heimdall_and_the_page_still_shows_it()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "google");
var only = (string)host.Heimdall.Identities[0]["id"]!;
var start = await host.StartUnlinkAsync(member.Session, only);
var done = await Finish(host, member.Session, start, member.Account, StepUpToken(host, member.Account), provider: "google");
Assert.Equal(Page + "?result=last_identity", Location(done));
Assert.Single(host.Heimdall.Unlinks);
Assert.Single(host.Heimdall.Identities);
var (_, html) = await host.GetLinkedAccountsAsync(member.Session);
Assert.Contains("Name of google", html);
Assert.Contains("will not remove it. Nothing was changed.", (await host.GetLinkedAccountsAsync(member.Session, "?result=last_identity")).Html);
}
[Fact]
public async Task A_sign_in_Heimdall_does_not_count_as_fresh_proof_changes_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
// An ordinary token: no step_up_at claim, so Heimdall answers 403 step_up_required.
var done = await Finish(host, member.Session, start, member.Account, host.Token(member.Account), provider: "google");
Assert.Equal(Page + "?result=step_up_required", Location(done));
Assert.Equal(2, host.Heimdall.Identities.Count);
Assert.Contains("Name of discord", (await host.GetLinkedAccountsAsync(member.Session)).Html);
}
[Fact]
public async Task A_completion_that_does_not_say_a_step_up_was_asked_unlinks_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
// The token even carries step_up_at, but the completion is not the answer to a step-up start.
var done = await Finish(host, member.Session, start, member.Account, StepUpToken(host, member.Account), provider: "google",
stepUpRequested: false);
Assert.Equal(Page + "?result=step_up_required", Location(done));
Assert.Empty(host.Heimdall.Unlinks);
Assert.Equal(2, host.Heimdall.Identities.Count);
}
[Fact]
public async Task A_proof_older_than_600_seconds_is_refused_by_Heimdall_and_changes_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
// The sign-in happened 601 seconds before the unlink reaches Heimdall (the attempt itself lives ten minutes).
var stale = host.Token(member.Account, mutate: claims => claims["step_up_at"] = host.Clock.Now.ToUnixTimeSeconds() - 601);
var done = await Finish(host, member.Session, start, member.Account, stale, provider: "google");
Assert.Equal(Page + "?result=step_up_required", Location(done));
Assert.Single(host.Heimdall.Unlinks);
Assert.Equal(2, host.Heimdall.Identities.Count);
}
[Fact]
public async Task Every_completion_answer_is_no_store()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
host.Heimdall.AddIdentity("discord");
var start = await host.StartListAsync(session);
var done = await Finish(host, session, start, account);
var refused = await host.PostCompleteAsync(new Dictionary<string, string> { ["attempt"] = "nope" }, null);
Assert.Contains("no-store", done.Headers.CacheControl?.ToString());
Assert.Contains("no-store", refused.Headers.CacheControl?.ToString());
}
[Theory]
[InlineData(HttpStatusCode.NotFound, "identity_not_found")]
[InlineData(HttpStatusCode.Unauthorized, "sign_in_required")]
[InlineData(HttpStatusCode.InternalServerError, "error")]
public async Task Each_refused_unlink_has_its_own_fixed_outcome_and_leaks_no_Heimdall_text(HttpStatusCode status, string outcome)
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
host.Heimdall.UnlinkStatus = status;
var done = await Finish(host, member.Session, start, member.Account, StepUpToken(host, member.Account), provider: "google");
Assert.Equal($"{Page}?result={outcome}", Location(done));
Assert.DoesNotContain("HEIMDALL FREE TEXT", string.Join("\n", host.Logs.Lines));
var (_, html) = await host.GetLinkedAccountsAsync(member.Session);
Assert.DoesNotContain("HEIMDALL FREE TEXT", html);
// Only a definitive refusal (401 here) leaves the list shown; not found or an unreadable end may have changed the account, so it is dropped.
Assert.Equal(status == HttpStatusCode.Unauthorized, html.Contains("Name of discord"));
}
[Fact]
public async Task A_Heimdall_that_cannot_be_reached_for_the_unlink_changes_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
host.Heimdall.MemberFailure = new HttpRequestException("connection refused");
var done = await Finish(host, member.Session, start, member.Account, StepUpToken(host, member.Account), provider: "google");
Assert.Equal(Page + "?result=error", Location(done));
Assert.DoesNotContain("Name of discord", (await host.GetLinkedAccountsAsync(member.Session)).Html);
}
[Fact]
public async Task Without_a_Google_login_no_proof_can_be_had_and_the_page_says_so_without_asking_Heimdall()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "patreon");
var (_, html) = await host.GetLinkedAccountsAsync(member.Session);
var starts = host.Heimdall.StartBodies.Count;
var post = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
Assert.DoesNotContain(">Unlink<", html);
Assert.Contains("Unlinking needs strong proof", html);
Assert.Contains("Add a passkey below", html);
Assert.Contains("link a Google login", html);
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=proof_unavailable", Location(post.Response));
Assert.Null(post.Cookie);
}
[Fact]
public async Task A_Heimdall_with_no_Google_client_refuses_the_step_up_start_and_the_page_says_proof_is_unavailable_once()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
host.Heimdall.StartStatus = HttpStatusCode.ServiceUnavailable;
host.Heimdall.StartBody = """{"error":"provider_not_configured"}""";
var starts = host.Heimdall.StartBodies.Count;
var post = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
Assert.Equal(starts + 1, host.Heimdall.StartBodies.Count);
Assert.Null(post.Cookie);
Assert.Equal(Page + "?result=proof_unavailable", Location(post.Response));
Assert.Contains("Fresh proof could not be started", (await host.GetLinkedAccountsAsync(member.Session, "?result=proof_unavailable")).Html);
Assert.Equal(2, host.Heimdall.Identities.Count);
}
[Theory]
[InlineData(null)]
[InlineData("not-a-guid")]
[InlineData("00000000-0000-0000-0000-000000000001")]
public async Task An_identity_that_is_not_on_the_list_the_member_was_shown_starts_nothing(string? identityId)
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var starts = host.Heimdall.StartBodies.Count;
var post = await host.PostLinkedAccountsAsync(
member.Session, "Unlink", identityId is null ? null : new Dictionary<string, string> { ["identityId"] = identityId });
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=list_expired", Location(post.Response));
}
[Fact]
public async Task An_unlink_after_the_list_expired_starts_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var id = (string)host.Heimdall.Identities[0]["id"]!;
host.Clock.Advance(LinkedAccountsSnapshots.Lifetime + TimeSpan.FromSeconds(1));
var starts = host.Heimdall.StartBodies.Count;
var post = await host.StartUnlinkAsync(member.Session, id);
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=list_expired", Location(post.Response));
}
// ---- an attempt belongs to the account and browser that began it ----
[Fact]
public async Task An_unlink_attempt_held_by_another_accounts_session_does_nothing_and_asks_Heimdall_for_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
var otherAccount = HeimdallShapes.NewAccountId();
var otherSession = await host.SignInSessionAsync(otherAccount);
var redeems = host.Heimdall.RedeemCalls;
var done = await Finish(host, member.Session, start, member.Account, StepUpToken(host, member.Account), provider: "google",
sessionOverride: otherSession);
Assert.Equal(Page + "?result=error", Location(done));
Assert.Equal(redeems, host.Heimdall.RedeemCalls);
Assert.Empty(host.Heimdall.Unlinks);
Assert.Equal(2, host.Heimdall.Identities.Count);
}
[Fact]
public async Task A_proof_by_another_account_unlinks_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
var stranger = HeimdallShapes.NewAccountId();
var done = await Finish(host, member.Session, start, stranger, StepUpToken(host, stranger), provider: "google");
Assert.Equal(Page + "?result=error", Location(done));
Assert.Empty(host.Heimdall.Unlinks);
}
[Fact]
public async Task A_list_proof_by_another_account_lists_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
host.Heimdall.AddIdentity("discord");
var start = await host.StartListAsync(session);
var done = await Finish(host, session, start, HeimdallShapes.NewAccountId());
Assert.Equal(Page + "?result=error", Location(done));
Assert.Empty(host.Heimdall.ListAuthorizations);
}
[Fact]
public async Task A_consumed_unlink_attempt_cannot_be_replayed_into_a_second_unlink()
{
using var host = new HeimdallHost(realSessions: true);
var member = await ListedMember(host, "discord", "patreon", "google");
var start = await host.StartUnlinkAsync(member.Session, (string)host.Heimdall.Identities[0]["id"]!);
var fields = new Dictionary<string, string>
{
["attempt"] = start.Nonce,
["code"] = host.CodeFor(start, member.Account, StepUpToken(host, member.Account), provider: "google")
};
var first = await host.PostCompleteAsync(fields, Jar(member.Session, start));
Assert.Equal(Page + "?result=unlinked", Location(first));
var replay = await host.PostCompleteAsync(fields, Jar(member.Session, start));
Assert.Equal(Page + "?result=error", Location(replay));
Assert.Single(host.Heimdall.Unlinks);
}
// ---- link another provider ----
[Theory]
[InlineData("discord")]
[InlineData("patreon")]
[InlineData("google")]
public async Task Linking_each_admitted_provider_proves_the_account_then_starts_that_providers_link_with_the_bearer(string provider)
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
var starts = host.Heimdall.StartBodies.Count;
var start = await host.StartLinkAsync(session, provider);
Assert.Equal(starts + 1, host.Heimdall.StartBodies.Count);
Assert.Equal("/v1/oauth/discord/start", host.Heimdall.StartPaths[^1]);
Assert.Null(host.Heimdall.StartAuthorizations[^1]);
var token = host.Token(account);
var step = await Finish(host, session, start, account, token);
Assert.Equal(starts + 2, host.Heimdall.StartBodies.Count);
Assert.Equal($"/v1/oauth/{provider}/start", host.Heimdall.StartPaths[^1]);
Assert.Equal("Bearer " + token, host.Heimdall.StartAuthorizations[^1]);
using var link = JsonDocument.Parse(host.Heimdall.StartBodies[^1]);
Assert.Equal("link", link.RootElement.GetProperty("mode").GetString());
Assert.Equal("bifrost", link.RootElement.GetProperty("appSlug").GetString());
Assert.False(link.RootElement.TryGetProperty("stepUp", out _));
Assert.Equal($"https://heimdall.test/oauth/{provider}/authorize?state=link-fixture", Location(step));
}
[Fact]
public async Task A_proof_sign_in_goes_through_a_provider_the_account_still_holds()
{
using var host = new HeimdallHost(realSessions: true);
// Signed in through Discord, which the account has since unlinked: signing in through it again would mint another account.
var member = await ListedMember(host, "patreon", "google");
var start = await host.StartLinkAsync(member.Session, "discord");
Assert.Equal("/v1/oauth/patreon/start", host.Heimdall.StartPaths[^1]);
Assert.NotNull(start.Cookie);
}
[Theory]
[InlineData("twitch")]
[InlineData("github")]
[InlineData("DISCORD2")]
[InlineData("")]
public async Task A_provider_Heimdalls_bifrost_profile_does_not_admit_starts_nothing(string provider)
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
var starts = host.Heimdall.StartBodies.Count;
var start = await host.StartLinkAsync(session, provider);
Assert.Equal(starts, host.Heimdall.StartBodies.Count);
Assert.Equal(Page + "?result=error", Location(start.Response));
Assert.Null(start.Cookie);
}
[Fact]
public async Task A_provider_that_attaches_in_the_callback_comes_back_with_a_link_completion_and_is_linked_once()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
var start = await host.StartLinkAsync(session, "patreon");
var awaiting = host.AttemptFrom((await ContinueResponse(host, session, start, account)), host.Heimdall.StartBodies.Count - 1);
Assert.Contains("\"Purpose\":6", Unprotect(host, awaiting.Cookie!));
Assert.Contains("\"Target\":\"patreon\"", Unprotect(host, awaiting.Cookie!));
host.Heimdall.AddIdentity("discord");
var redeems = host.Heimdall.RedeemCalls;
var done = await Finish(host, session, awaiting, account, mode: "link", provider: "patreon");
Assert.Equal(Page + "?result=linked", Location(done));
Assert.Equal(redeems + 1, host.Heimdall.RedeemCalls);
Assert.Contains("now linked to your Heimdall account", (await host.GetLinkedAccountsAsync(session, "?result=linked")).Html);
Assert.Null(HeimdallHost.CookieValue(done, BifrostCookies.Session));
var replay = await host.PostCompleteAsync(
new Dictionary<string, string> { ["attempt"] = awaiting.Nonce, ["code"] = "gone" }, Jar(session, awaiting));
Assert.Equal(Page + "?result=error", Location(replay));
}
private static async Task<HttpResponseMessage> ContinueResponse(HeimdallHost host, string session, StartedAttempt start, string account) =>
await Finish(host, session, start, account);
[Theory]
[InlineData("sign_in", "patreon")]
[InlineData("link", "discord")]
public async Task A_direct_link_completion_for_another_mode_or_provider_links_nothing(string mode, string provider)
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
var start = await host.StartLinkAsync(session, "patreon");
var before = host.Heimdall.StartBodies.Count;
var awaiting = host.AttemptFrom(await ContinueResponse(host, session, start, account), before);
var done = await Finish(host, session, awaiting, account, mode: mode, provider: provider);
Assert.Equal(Page + "?result=error", Location(done));
}
[Fact]
public async Task A_direct_link_completion_proven_by_another_account_links_nothing()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
var start = await host.StartLinkAsync(session, "discord");
var before = host.Heimdall.StartBodies.Count;
var awaiting = host.AttemptFrom(await ContinueResponse(host, session, start, account), before);
var done = await Finish(host, session, awaiting, HeimdallShapes.NewAccountId(), mode: "link", provider: "discord");
Assert.Equal(Page + "?result=error", Location(done));
}
[Fact]
public async Task A_link_attempt_cookie_written_before_targets_existed_still_links_Google()
{
using var host = new HeimdallHost(realSessions: true);
var account = HeimdallShapes.NewAccountId();
var session = await host.SignInSessionAsync(account);
var nonce = "legacy-" + Guid.NewGuid().ToString("N");
var protector = host.Services.GetRequiredService<IDataProtectionProvider>().CreateProtector("Bifrost.Heimdall.Attempt.v1");
var legacy = protector.Protect(JsonSerializer.Serialize(new Dictionary<string, object>
{
["Nonce"] = nonce, ["Provider"] = "discord", ["RequiresMemberAccess"] = false, ["ReturnPath"] = "/Membership/Status",
["ExpiresAt"] = host.Clock.Now.AddMinutes(5), ["Purpose"] = 1, ["ExpectedAccountId"] = account
}));
var attempt = new StartedAttempt(
nonce, HeimdallAttemptCookie.SlotNames[0], legacy, $"https://localhost/auth/heimdall/complete?attempt={nonce}", null!);
var step = await Finish(host, session, attempt, account);
Assert.Equal("/v1/oauth/google/start", host.Heimdall.StartPaths[^1]);
Assert.Equal("https://heimdall.test/oauth/google/authorize?state=link-fixture", Location(step));
}
// ---- the page and its neighbours ----
[Fact]
public async Task Status_points_a_Heimdall_member_to_the_page_and_no_longer_starts_a_link_itself()
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
using var client = host.NewClient();
using var request = new HttpRequestMessage(HttpMethod.Get, "/Membership/Status");
request.Headers.Add("Cookie", $"{BifrostCookies.Session}={session}");
var html = await (await client.SendAsync(request)).Content.ReadAsStringAsync();
Assert.Contains(Page, html);
Assert.DoesNotContain("handler=LinkGoogle", html);
Assert.DoesNotContain("LinkGoogle", html);
}
[Theory]
[InlineData("linked")]
[InlineData("identity_linked_elsewhere")]
[InlineData("expired")]
[InlineData("unlinked")]
[InlineData("last_identity")]
[InlineData("step_up_required")]
[InlineData("identity_not_found")]
[InlineData("sign_in_required")]
[InlineData("proof_unavailable")]
[InlineData("list_expired")]
[InlineData("provider_needed")]
[InlineData("error")]
public void Every_outcome_code_has_words_and_nothing_else_does(string code)
{
Assert.False(string.IsNullOrWhiteSpace(HeimdallLinkOutcomes.Wording(code)));
Assert.Null(HeimdallLinkOutcomes.Wording(code + " "));
Assert.Null(HeimdallLinkOutcomes.Wording("<b>" + code));
Assert.Contains(
Enum.GetValues<HeimdallLinkOutcome>(), outcome => HeimdallLinkOutcomes.Code(outcome) == code);
}
[Fact]
public async Task Link_refusals_say_the_login_belongs_to_another_account_without_naming_it()
{
using var host = new HeimdallHost(realSessions: true);
var session = await host.SignInSessionAsync(HeimdallShapes.NewAccountId());
var (_, html) = await host.GetLinkedAccountsAsync(session, "?result=identity_linked_elsewhere");
Assert.Contains("That login belongs to another account. Nothing was linked.", html);
Assert.DoesNotContain("merge", html.Replace("nothing is merged", string.Empty), StringComparison.OrdinalIgnoreCase);
}
}