Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 256d7dbfb1 | |||
|
|
4a0fb44b5b | ||
|
|
2f0dd0c3a7 | ||
| 4fe367ac8d | |||
| d957e5accb | |||
|
|
6ed6d8fa0d | ||
|
|
1259911632 | ||
|
|
2f93809a29 | ||
|
|
33a83c34c4 | ||
| 54e15567c7 | |||
|
|
46e5d5364f | ||
|
|
e9eef09446 | ||
|
|
d8b8d25e81 | ||
|
|
3afc956f92 | ||
|
|
46d5044925 | ||
| c98e019c5d | |||
|
|
4aa9d03c4f | ||
| 96256d2839 | |||
| 74004bf0ef | |||
|
|
673713a015 | ||
|
|
7a69d7567b | ||
| afa1b74318 | |||
|
|
570e930043 | ||
| 5fc626c7ec | |||
| cbc069f02c | |||
|
|
36b02ea135 | ||
|
|
a021b02310 | ||
| b446add144 | |||
|
|
246f2d4f71 | ||
|
|
d4cd112193 | ||
|
|
f2f1dabc06 | ||
|
|
9c7d980165 | ||
|
|
1118f235b0 | ||
|
|
9da4b12bc2 | ||
|
|
a0bd9836b1 | ||
|
|
f5f4b2830f | ||
| 2bd5096d81 | |||
|
|
0ea6691cd3 | ||
| 61671d7fe8 | |||
|
|
b6372e5a4f | ||
|
|
f7a38a7d2a | ||
|
|
af554ca013 | ||
|
|
767852ef96 | ||
|
|
5ce8f1c14c | ||
|
|
d4f7dce098 | ||
|
|
71ce9c16e4 | ||
|
|
48207268d0 | ||
|
|
7ca4e2355f | ||
|
|
aaeb175dc6 | ||
|
|
d6a8d4238c | ||
|
|
cafdc52e5f | ||
|
|
4e99bfa628 | ||
|
|
2364979f0d | ||
|
|
d836f29e3a | ||
|
|
e8edd88efc | ||
|
|
a7cdf0fea7 | ||
| fefd2ddf4a | |||
|
|
575be9cf49 | ||
|
|
70fd6396f4 | ||
| aa2edd3826 | |||
|
|
f1ddc2fffc | ||
|
|
b541e094eb | ||
| fd67d94aa3 | |||
|
|
9123f2def0 | ||
| da70416ebe | |||
|
|
c829429cd5 | ||
|
|
8e870d20a0 | ||
|
|
84c54fbb5e | ||
|
|
0f2e294fcb | ||
|
|
9f5a0e6938 | ||
|
|
5146c722af | ||
|
|
1a36175f3a | ||
|
|
c044155855 | ||
|
|
c0d30e8081 | ||
|
|
4185e657bb | ||
|
|
5076e04950 | ||
|
|
3def0fb426 | ||
|
|
14e0cde26c | ||
|
|
607c2b0a20 | ||
|
|
ece6ba1d62 | ||
|
|
9fd152feff | ||
|
|
ed964201d4 | ||
|
|
7e17a0e952 | ||
|
|
6d43eacd84 |
71 changed files with 10718 additions and 644 deletions
|
|
@ -14,7 +14,7 @@ The point is painfully simple:
|
|||
|
||||
## Front Door
|
||||
|
||||
- **Value:** one shared auth authority: provider OAuth (Discord, Patreon, GitHub, Twitch, YouTube, Spotify), linked identities, grants, entitlements and session issuance, with Ed25519-signed claims that app backends verify locally.
|
||||
- **Value:** one shared auth authority: provider OAuth (Discord, Patreon, GitHub, Twitch, YouTube, Spotify, Google OIDC for linking), linked identities, grants, entitlements and session issuance, with Ed25519-signed claims that app backends verify locally.
|
||||
- **Problem:** every GameCult app was rebuilding Discord/Patreon login glue. Heimdall centralizes identity authority and keeps app-domain data in the apps.
|
||||
- **Entry points:**
|
||||
- `src/index.ts` and `src/app.ts`: the Fastify service. `src/signing.ts` and `src/claims.ts` issue JWTs and serve `/.well-known/jwks.json`; `src/oauth.ts` and `src/providers.ts` own provider flows.
|
||||
|
|
|
|||
|
|
@ -138,11 +138,16 @@ route_required = true
|
|||
optional_environment = [
|
||||
"CULTMESH_URI_ODIN_RUDP",
|
||||
"GC_ACCESS_APP_BIFROST_BACKEND_CALLBACK_URLS",
|
||||
"GC_ACCESS_APP_BIFROST_RUNTIME_IDS",
|
||||
"GC_ACCESS_APP_BIFROST_SHARED_SECRET_FILE",
|
||||
"GC_ACCESS_APP_GHOSTLIGHT_BACKEND_CALLBACK_URLS",
|
||||
"GC_ACCESS_APP_GHOSTLIGHT_RUNTIME_IDS",
|
||||
"GC_ACCESS_APP_GHOSTLIGHT_SHARED_SECRET_FILE",
|
||||
"GC_ACCESS_APP_REPIXELIZER_BACKEND_CALLBACK_URLS",
|
||||
"GC_ACCESS_APP_REPIXELIZER_RUNTIME_IDS",
|
||||
"GC_ACCESS_APP_REPIXELIZER_SHARED_SECRET_FILE",
|
||||
"GC_ACCESS_APP_STREAMPIXELS_BACKEND_CALLBACK_URLS",
|
||||
"GC_ACCESS_APP_STREAMPIXELS_RUNTIME_IDS",
|
||||
"GC_ACCESS_APP_STREAMPIXELS_SHARED_SECRET_FILE",
|
||||
"GC_ACCESS_APPLY_SCHEMA_ON_STARTUP",
|
||||
"GC_ACCESS_BIFROST_PATRON_SUPPORT_ENDPOINT",
|
||||
|
|
@ -156,16 +161,21 @@ optional_environment = [
|
|||
"GC_ACCESS_PRIVATE_COMMAND_PORT",
|
||||
"GC_ACCESS_PROVIDER_DISCORD_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_DISCORD_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_GITHUB_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_GITHUB_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_GOOGLE_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_GOOGLE_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_JOYSTICK_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_JOYSTICK_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_PATREON_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_PATREON_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_SPOTIFY_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_SPOTIFY_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_TWITCH_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_TWITCH_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_PROVIDER_YOUTUBE_CLIENT_ID",
|
||||
"GC_ACCESS_PROVIDER_YOUTUBE_CLIENT_SECRET_FILE",
|
||||
"GC_ACCESS_REFRESH_TTL_SECONDS",
|
||||
"GC_ACCESS_SESSION_TTL_SECONDS",
|
||||
"GC_ACCESS_SIGNING_KEY_ID",
|
||||
"GC_ACCESS_SIGNING_PRIVATE_KEY_BOOTSTRAP",
|
||||
|
|
@ -190,7 +200,7 @@ schema_generation = "heimdall-v1"
|
|||
|
||||
[[state.slots]]
|
||||
id = "service"
|
||||
relative_path = "heimdall.service.cc"
|
||||
relative_path = "cultcache/heimdall.service.cc"
|
||||
kind = "cultcache-file"
|
||||
schema = "heimdall.service_state.v1"
|
||||
writer = "process-bound-single-writer"
|
||||
|
|
|
|||
265
docs/answer-collector-consent.md
Normal file
265
docs/answer-collector-consent.md
Normal file
|
|
@ -0,0 +1,265 @@
|
|||
# Answer Collector: Record and Consent
|
||||
|
||||
Status: specification. Nothing here is implemented. It fixes what an answer
|
||||
record is and what a respondent has agreed to, so that a collector, a tally and
|
||||
a training export can be built against one definition. Field names and types
|
||||
below are the contract for the typed CultCache records.
|
||||
|
||||
Scope: free-text and choice answers that members give to a sample put to them
|
||||
by an experiment. Not identity proof (see `architecture.md`). Personal details
|
||||
(names, contact data, account identifiers, anything that identifies a person) are
|
||||
out of scope: the collector does not ask for them and a sample must not solicit
|
||||
them. The only identifier it keeps is `member_id`, and that stays on the reward
|
||||
path.
|
||||
|
||||
## Notice
|
||||
|
||||
Consent is declared once per room, not per reply. Each experiment room carries
|
||||
one notice that names the scope the room's answers may be used for and the way
|
||||
out. A notice has a `notice_version`; any change to its wording or scope is a new
|
||||
version.
|
||||
|
||||
### Where the notice lives
|
||||
|
||||
A room's notice is a Matrix room state event: type `org.gamecult.notice`, empty
|
||||
`state_key`, content `{version, scope}`.
|
||||
|
||||
- `version` follows the version rule under Representation.
|
||||
- `scope` is `show`, `study` or `train`.
|
||||
- The event is set under the room's power levels. A pinned message is not
|
||||
accepted as a notice: anyone who can pin could forge it.
|
||||
- Absent or malformed (a missing or unknown field, a `version` the version rule
|
||||
does not accept, an unknown `scope`) means no `train`
|
||||
line and the narrowest scope, `show`. Malformed content is never repaired.
|
||||
|
||||
The wording shown to respondents is the room's own business; the collector reads
|
||||
only `version` and `scope`. A change to either is a new state event and so a
|
||||
new `version`.
|
||||
|
||||
| scope | what the notice allows |
|
||||
|---|---|
|
||||
| `show` | display back inside the experiment (to the respondent, and in aggregate to participants). Nothing else. |
|
||||
| `study` | `show`, plus analysis by the experiment's researchers. Quoted in findings only unattributed. |
|
||||
| `train` | `study`, plus use as training or evaluation data for models. |
|
||||
|
||||
`train` is a declared scope: it is used only when the notice for that room says
|
||||
`train` in terms. It is never inferred, never a default, and never raised by a
|
||||
reply.
|
||||
|
||||
The first reply a member posts in the room is their acceptance of the notice
|
||||
version then in force. No separate click, command or form. A later notice version
|
||||
needs a new acceptance: the member's first reply under it.
|
||||
|
||||
### Notice acceptance record
|
||||
|
||||
| field | type | rule |
|
||||
|---|---|---|
|
||||
| `member_id` | Heimdall member id | the accepting member. |
|
||||
| `experiment_id` | string | the room. |
|
||||
| `notice_version` | integer | the `version` of the room's notice state event when the reply was received. |
|
||||
| `scope` | `show` \| `study` \| `train` | the scope that version declared. |
|
||||
| `accepted_at` | UTC timestamp | `origin_server_ts` of the first reply. |
|
||||
| `event_id` | Matrix event id | that reply, as proof. |
|
||||
|
||||
Key: `(experiment_id, member_id, notice_version)`. Written once, never updated.
|
||||
|
||||
## Terms (newcomers only)
|
||||
|
||||
Joining Heimdall is gated by terms. Acceptance is the terms version recorded by
|
||||
the Matrix `m.login.terms` stage at registration: member field `terms_version`
|
||||
(string) and `terms_accepted_at` (UTC timestamp). These fields belong to the
|
||||
Heimdall member record. A typed `MemberTerms` record keyed by `member_id` is the
|
||||
shape of that pair in a typed library; it is not a second store, and the
|
||||
collector does not hold it. This applies to newcomers
|
||||
only. Members who joined before the terms stage existed, and Minds, are not
|
||||
re-asked and have no `terms_version`; the collector does not read it and does not
|
||||
gate on it. The notice above is the only consent the collector itself checks.
|
||||
|
||||
Open gap: the registration checkbox records no version. Void is raising this;
|
||||
nothing here rules it.
|
||||
|
||||
## Answer record
|
||||
|
||||
One record per answer. Fields:
|
||||
|
||||
| field | type | rule |
|
||||
|---|---|---|
|
||||
| `sample_id` | string `<sample>@<version>` | names the thing answered about; `<version>` follows the version rule under Representation. A changed sample is a new version. |
|
||||
| `experiment_id` | string | the experiment that asked. |
|
||||
| `member_id` | Heimdall member id | the respondent. Never a Matrix id, never a display name. |
|
||||
| `notice_version` | integer | the notice version in force when the answer was received; matches an acceptance record by the key above. |
|
||||
| `scope` | `show` \| `study` \| `train` | copied from that notice version at answer time. Never edited afterwards. |
|
||||
| `text` | string, or absent | the answer as given. Non-empty while the answer is live; absent once exited. |
|
||||
| `exited` | boolean, default false | one-way: set by redaction, never cleared. A new answer is a new record. |
|
||||
| `text_hash` | 32 bytes, or absent | the tombstone hash of `text` (see "Tombstone"). Present only once exited, and only when the collector held `text` before the redaction. |
|
||||
| `received_at` | UTC timestamp | assigned by the collector when it receives the reply. Not copied from the reply. |
|
||||
| `event_id` | Matrix event id | the reply; the receipt. |
|
||||
|
||||
Key: `(experiment_id, sample_id, member_id)`. A member's later answer to the
|
||||
same key replaces the earlier one (latest `received_at` wins); the earlier text
|
||||
is not retained. Two replies to one key with equal `received_at` tie-break on
|
||||
`event_id` compared bytewise: the greater `event_id` wins as the later reply.
|
||||
|
||||
Empty text: a live (non-exited) answer must have non-empty `text`, and the
|
||||
collector rejects a reply whose text is empty. Empty text is valid only on an
|
||||
exited answer, where redaction clears `text` and leaves the hash-only tombstone.
|
||||
|
||||
A reply whose `notice_version` or `scope` is missing, unparseable or has no
|
||||
matching acceptance record is stored, with those fields absent. It is excluded
|
||||
from every use: no tally, no display, and from training in particular. It
|
||||
writes no acceptance record. The reply is kept so the member can still exit it
|
||||
and the collector can show what it refused, but no scope was declared, so none
|
||||
is inferred. The notice version of a reply is the one the room's notice state
|
||||
event held at the reply's `origin_server_ts`; if the collector cannot establish
|
||||
what it held then, the reply has no notice version.
|
||||
|
||||
### Representation
|
||||
|
||||
- Timestamps are Unix milliseconds in UTC, stored as a signed 64-bit integer,
|
||||
the unit of Matrix `origin_server_ts`. Every "UTC timestamp" above means this.
|
||||
- `member_id`, `experiment_id` and `event_id` are non-empty strings;
|
||||
`member_id` is opaque and `event_id` is the Matrix event id verbatim.
|
||||
- Version rule. Every version field in the consent system is a positive integer
|
||||
written in decimal with no leading zeros and at most 4294967295 (u32 max):
|
||||
the `<version>` of `sample_id` (`s@<version>`), `notice_version`, the
|
||||
`version` of the room notice `org.gamecult.notice`, and the notice acceptance
|
||||
and terms records (`terms_version`, carried as that decimal string). Anything
|
||||
else (zero, a sign, whitespace, a non-digit, a leading zero such as `s@01`, a
|
||||
value above the maximum) is refused, not normalised: `s@1` is the only
|
||||
spelling of version 1, so one version has exactly one key. A room notice
|
||||
whose `version` fails the rule is malformed: no `train` line, narrowest scope
|
||||
`show`. Nothing is silently rewritten to fit.
|
||||
- Two encodings of the one version rule. In the `org.gamecult.notice` room state
|
||||
event, `version` is a JSON number; a string (including `"01"`) is malformed.
|
||||
In the answer key (`s@<version>`, and the composite keys), the version stays
|
||||
its encoded decimal text, held to the leading-zero refusal. The rule is the
|
||||
same in both: a positive integer, no leading zeros, at most 4294967295.
|
||||
- A composite key is its parts joined with U+001F. A part that is empty or
|
||||
contains U+001F is refused, not escaped.
|
||||
|
||||
## Versions
|
||||
|
||||
Answers never tally across `sample_id` versions. A tally is computed for one
|
||||
full `sample_id` including version; there is no "all versions" aggregate and no
|
||||
API that takes a sample without a version. A version bump starts an empty tally.
|
||||
Replies to an old version are dropped when the tally is for a newer one.
|
||||
|
||||
## Training rule
|
||||
|
||||
A record is training or evaluation data only if all hold:
|
||||
|
||||
1. `scope = train`, copied from a notice version that declared `train`;
|
||||
2. an acceptance record exists for `(experiment_id, member_id, notice_version)`
|
||||
of the answer, its own `scope` is `train` and equals the answer's `scope`,
|
||||
and `accepted_at <= received_at`, i.e. the author had accepted that notice
|
||||
version when they answered;
|
||||
3. `exited = false` at export time.
|
||||
|
||||
Open gap: `accepted_at` is the homeserver's `origin_server_ts` and `received_at` is the collector's own clock, so
|
||||
condition 2 compares two clocks. If the collector's clock is behind the homeserver's, a member's first answer (which is
|
||||
also their acceptance) can fail `accepted_at <= received_at` and is excluded. That fails closed, never opens `train`
|
||||
wrongly. The remedy is to compare on one clock (keep the reply's `origin_server_ts` on the answer); this revision does
|
||||
not rule it.
|
||||
|
||||
No recorded scope, or no recorded acceptance, means excluded. Records wider than
|
||||
`show` are kept apart from `show` records: one store per scope (`show`, `study`,
|
||||
`train`) plus a store for scopeless replies that no read path serves. A record
|
||||
lives in the store its `scope` names, so a read for one level cannot return
|
||||
another. A typed-record library need not model the partition; the collector's
|
||||
store layout owns it.
|
||||
|
||||
## Tombstone
|
||||
|
||||
- Function: HMAC-SHA-256 (RFC 2104 with SHA-256, FIPS 180-4), output the raw 32
|
||||
bytes stored in `text_hash`. No truncation.
|
||||
- Message: the ASCII string `heimdall.tombstone.v1`, U+001F, `event_id`
|
||||
(UTF-8), U+001F, `text` (UTF-8, as received, no normalisation). The `event_id`
|
||||
makes the hash specific to the reply, so equal texts hash differently.
|
||||
- Key (the salt): 32 bytes from a cryptographically secure random source,
|
||||
generated once per member by the member-side service, which is the service that
|
||||
already maps Matrix sender to `member_id`. It is held there, beside the member
|
||||
record, and is never given to the collector, a researcher, an export or a log.
|
||||
The collector cannot compute or check a tombstone hash on its own.
|
||||
- Redaction: when the collector sees a redaction of a reply whose text it holds,
|
||||
it sends `event_id` and `text` to the member-side service, which returns the
|
||||
hash; the collector writes `text_hash`, sets `exited`, and erases `text`. If the
|
||||
service does not answer, `text` is kept, the record is not yet exited, and the
|
||||
run retries. A reply the collector never collected has no text and gets no
|
||||
tombstone.
|
||||
- Verification: only the member-side service can check a claimed text against a
|
||||
tombstone. If a member's salt is destroyed, their tombstones can no longer be
|
||||
tied to any text, and that is the member's erasure.
|
||||
|
||||
## Identity: count once, reward without exposure
|
||||
|
||||
The Matrix sender is mapped to a Heimdall member id by Heimdall's linked
|
||||
identity, at collection time. The collector stores `member_id` only; the Matrix
|
||||
sender is discarded after mapping. A sender with no linked member is dropped,
|
||||
not stored under a placeholder.
|
||||
|
||||
- Count once: the key above makes one member one answer per sample version,
|
||||
however many Matrix accounts or bridges they use.
|
||||
- Reward without exposure: a reward is issued against `member_id` by the
|
||||
rewarding service. Researchers and displays see counts and text under their
|
||||
scope, never `member_id`. The mapping from a record to a person is available
|
||||
to the reward path only.
|
||||
|
||||
## Eureka's shape (Matrix)
|
||||
|
||||
- One room per experiment. The room is `experiment_id`.
|
||||
- The sample is posted as a message; the room's notice is its `org.gamecult.notice` state event. An answer
|
||||
is a thread reply to the sample, the answer text being the body. There is no
|
||||
per-reply scope syntax.
|
||||
- The reply event is the receipt: its event id and timestamp are the proof the
|
||||
answer was received. `received_at` is the collector's own clock at receipt,
|
||||
not the reply's `origin_server_ts`.
|
||||
- Redaction is exit (see below): redacting the reply event sets `exited`.
|
||||
- The collector is on demand (it reads the room when run, it is not a standing
|
||||
listener). It drops:
|
||||
- redacted replies (recorded as exited);
|
||||
- replies from unlinked senders;
|
||||
- replies to an old sample version when the tally is for a newer one.
|
||||
|
||||
## What Matrix cannot guarantee
|
||||
|
||||
- **Receipt outliving a deleted reply.** Redaction removes content, and
|
||||
homeserver retention varies. If the collector holds a receipt for a reply that
|
||||
later disappears, it keeps a tombstone: `event_id`, `sample_id`, `received_at`,
|
||||
and a salted hash of `text`. Hash only, never text, and no `member_id`
|
||||
beyond what the record's key already holds. The count and the exit are
|
||||
provable without the content. The record is marked `exited`; `text` is erased.
|
||||
The tombstone is the exited `Answer` record itself, with `text_hash` set; it is
|
||||
not a separate record.
|
||||
- **Edits.** An edit is a new event, not the receipt. Only the original event
|
||||
counts; edits are ignored, so what was accepted is what was received. To
|
||||
change an answer, redact and reply again.
|
||||
- **Bridge spoofing.** A bridge can post as any ghost user. Only senders whose
|
||||
Matrix id resolves through Heimdall's linked identity to a member count;
|
||||
bridged ghost ids are not linked identities. A bridge cannot raise scope: scope
|
||||
comes only from the room's notice state event.
|
||||
- **Bridged origin.** Events that arrive through a bridge are dropped by origin,
|
||||
not by judging their text.
|
||||
|
||||
## What the respondent sees
|
||||
|
||||
Posted with the sample, in the room:
|
||||
|
||||
- the notice: its scope in one line, that the first reply accepts it, and how to
|
||||
exit;
|
||||
- the notice version.
|
||||
|
||||
After answering, the respondent sees their receipt: the thread reply itself,
|
||||
plus the collector's acknowledgement that names the notice version and scope it
|
||||
recorded.
|
||||
|
||||
The consent and vote controls make no reward sound, animation or other
|
||||
reinforcement. A reward is issued later, by the rewarding service, never as
|
||||
feedback to the act of consenting or voting.
|
||||
|
||||
## How to exit
|
||||
|
||||
Redact your reply. That is all. The next collection run sets `exited`, erases
|
||||
`text`, and excludes the record from every later tally and from training. It
|
||||
cannot undo past use: tallies already shown and anything already exported
|
||||
cannot be recalled by Matrix or by the collector. The experiment's page states
|
||||
the export cadence so the window is known.
|
||||
|
|
@ -77,3 +77,37 @@ patron points locally.
|
|||
This route is a bridge from auth-owned Patreon evidence to Bifrost-owned
|
||||
governance meaning. Heimdall still does not own points, votes, tiers, ledger
|
||||
history, or payout policy.
|
||||
|
||||
## App-asserted step-up
|
||||
|
||||
Bifrost's profile carries `stepUpAssertion: { methods: ["bifrost-passkey",
|
||||
"bifrost-email-code"] }`, the only such grant. With its secret and a member's
|
||||
live Heimdall bearer, Bifrost calls `POST /v1/apps/bifrost/step-up` with
|
||||
`{method, nonce}` after it has checked the factor itself, and receives an access
|
||||
token for the same session whose `step_up_at` and `step_up_method` satisfy
|
||||
Heimdall's unlink check. Bifrost must send a fresh nonce per assertion, keep
|
||||
the returned token only for the action it is for, and never send a method it did
|
||||
not verify: Heimdall cannot tell. Contract, codes, limits and what it does not
|
||||
prove are in `docs/service-contract.md`.
|
||||
|
||||
Precondition and limit: Bifrost can call this only while it holds the member's
|
||||
Heimdall bearer, which it deliberately does not today. Holding it in a cookie
|
||||
ticket would turn cookie theft into bearer theft and, with a passkey or email
|
||||
code, into unlink power. And unlink accepts any method: a `bifrost-email-code`
|
||||
proof can unlink an identity a Google re-authentication would have guarded.
|
||||
Requiring a method per route is the later hardening (identity moves).
|
||||
|
||||
## Identity moves
|
||||
|
||||
Bifrost's profile carries `identityMoves: { accountProofMethods:
|
||||
["bifrost-passkey"] }`, the only such grant (its methods are a subset of
|
||||
`stepUpAssertion.methods`). With its secret, `POST /v1/apps/bifrost/identity-moves`
|
||||
moves logins from one Heimdall account to another when it presents fresh proofs
|
||||
of both: Bifrost's merge saga owns survivor choice, preview and undo timing;
|
||||
Heimdall moves what the proofs cover. A proof through one login moves only that
|
||||
login; an asserted `bifrost-passkey` proof covers the whole source account;
|
||||
`bifrost-email-code` proves an inbox and does not. A multi-login source without a
|
||||
passkey therefore needs one fresh sign-in per login. Until the Google client is
|
||||
live, a member's strong proof is the asserted passkey only; Discord and Patreon
|
||||
give weak (300 s) proofs. Contract, refusal order and idempotency are in
|
||||
`docs/service-contract.md`.
|
||||
|
|
|
|||
|
|
@ -154,7 +154,11 @@ The important split:
|
|||
|
||||
- Heimdall owns provider OAuth, identity linking, entitlement refresh, signed
|
||||
sessions, claims, grants, audit surfaces, and managed provider credential
|
||||
custody
|
||||
custody. It authenticates; it does not issue GameCult identity. Bifrost is
|
||||
the identity provider, and the account id Heimdall mints is an authenticator
|
||||
handle. Remaining scar: Heimdall still creates that account id on first
|
||||
login (`store.createAccount`, `src/app.ts`), which the chat work does not
|
||||
need moved
|
||||
- the host experiment owns its workload, queue, editor, render path, viewer
|
||||
profile model, creator model, or other product-specific machinery
|
||||
- the host experiment also owns which local entity a connection attaches to,
|
||||
|
|
@ -332,6 +336,49 @@ access token (`revoked`) or no refresh is due (`current`; due means a known
|
|||
expiry within 5 minutes, a stored refresh token, and a runtime that refreshes).
|
||||
It never decides that a refresh happens.
|
||||
|
||||
### One writer for `linked_identities` moves
|
||||
|
||||
An identity belongs to the account that holds it. `upsertLinkedIdentity` writes
|
||||
the holder's own row (`ON CONFLICT (provider, provider_user_id) DO UPDATE ...
|
||||
WHERE linked_identities.account_id = EXCLUDED.account_id`; it never sets
|
||||
`account_id`) and throws `IdentityHeldElsewhereError` when another account holds
|
||||
the identity. `unlinkLinkedIdentity` is the only delete: one transaction locks
|
||||
the account row, refuses the account's last identity, and deletes the row only
|
||||
for the account that holds it. The store role therefore holds DELETE on
|
||||
`linked_identities`, checked at startup. The HTTP side (`/v1/me/identities`) is
|
||||
in `service-contract.md`; an unlink needs a step-up proof inside 600 seconds.
|
||||
|
||||
`moveIdentities` is the only statement that sets `linked_identities.account_id`
|
||||
to another account, reached only through `POST /v1/apps/{app}/identity-moves`.
|
||||
One transaction locks both accounts in id order (opposite moves queue, they do
|
||||
not deadlock), answers a repeated `moveId` from its `identity_moves` row,
|
||||
re-checks the proof sessions, applies `decideMove` (one pure function both stores
|
||||
call, so memory and Postgres cannot disagree), moves the rows with credentials
|
||||
stripped, revokes the source's sessions, expires its pending links and unredeemed
|
||||
completions, and appends the row. `identity_moves` is append-only (SELECT and
|
||||
INSERT only, checked at startup). An alias (an account with no login and an
|
||||
unreversed move from it) is derived inside the transaction to refuse moves into
|
||||
or out of it, never stored; nothing resolves an alias to its destination, because
|
||||
no consumer needs it and a chain of moves would make one hop wrong.
|
||||
|
||||
### Step-up proof has two sources
|
||||
|
||||
An access token's `step_up_at` is set in exactly two places: the `sign_in`
|
||||
step-up callback (Heimdall asked the provider to re-authenticate; label
|
||||
`provider:<name>`) and `assertStepUp`, the app-asserted route (the app says it
|
||||
checked a factor; label from the profile's `stepUpAssertion.methods`). Both
|
||||
feed the one reader, `proofTier` in `claims.ts` (unlink and identity moves both
|
||||
read it: `strong` is a step-up inside 600 s, `weak` a sign-in inside 300 s via
|
||||
`auth_at`), and a refresh sets neither. `proofCovers` says what a proof speaks
|
||||
for: only a strong proof whose method the profile lists as an account proof
|
||||
covers the whole account; any other proof covers the one login in
|
||||
`auth_identity_id`. The
|
||||
asserted route trusts the calling app and is bounded by the app secret, a live
|
||||
bearer for that app, the method allowlist, a nonce claimed once per session
|
||||
through `claimOAuthStateUse` (phase `step_up_assert`, no new table or grant;
|
||||
retained to the session expiry as of the claim, which a refresh may slide past),
|
||||
and in-process fixed-window limits (`src/fixed-window.ts`).
|
||||
|
||||
### Three nested guards
|
||||
|
||||
1. **Single flight, per process.** `refreshesInFlight` is keyed by store, then
|
||||
|
|
@ -443,13 +490,12 @@ builder was not used.
|
|||
process, so N Heimdall processes can present one token N times after a
|
||||
transient failure. Needs a failed-attempt marker on the row, read under the
|
||||
lock. Must land before or with Idunn onboarding.
|
||||
- `joystick:follow_up:connect-start-needs-app-auth`: connect starts are
|
||||
unauthenticated, so anyone can name `{creator, targetId}`; the callback
|
||||
re-check proves a binding exists, not that the caller owns it. It also owns
|
||||
the whitespace-only `targetId` that passes both gates and the callback's
|
||||
fail-open `''` fallback for a vanished profile (finding
|
||||
`joystick:finding:cut-h1.s4.whitespace-targetid-passes-custody-gate`). Must
|
||||
land before the public Joystick bot or a second creator.
|
||||
- `joystick:follow_up:connect-start-needs-app-auth` (Heimdall side done): a
|
||||
connect start that names a connection target needs the app's own secret for
|
||||
every managed provider, and a blank target is refused at start and at the
|
||||
callback mint. What StreamPixels must do on its side is in
|
||||
`notes/streampixels-connect-redeem.md`; its redeem must refuse a creator
|
||||
connect whose target it did not start.
|
||||
- `joystick:follow_up:heimdall-idunn-onboarding` (gamecult-ops): live Heimdall
|
||||
is a hand-copied release under `heimdall.service`, not an Idunn-admitted
|
||||
generation; the recipe's Joystick lines are declared but unproven by a
|
||||
|
|
@ -613,8 +659,9 @@ Only the browser-driven OAuth flow:
|
|||
|
||||
| Path | Why it must be public |
|
||||
|---|---|
|
||||
| `/v1/oauth/{provider}/start` | the user's browser goes here |
|
||||
| `/v1/oauth/{provider}/callback` | the provider redirects here; one-shot and not retryable |
|
||||
| `/v1/oauth/{provider}/start` | the app's server calls it, with its app secret where the profile requires one |
|
||||
| `/v1/oauth/{provider}/launch` | the user's browser goes here first; it sets the binding cookie and redirects to the provider, once per state |
|
||||
| `/v1/oauth/{provider}/callback` | the provider redirects here; one-shot: it needs the binding cookie and consumes the state |
|
||||
| `/.well-known/jwks.json` | *nothing external consumes it today* — see below |
|
||||
|
||||
Everything else is internal by the design already written down:
|
||||
|
|
|
|||
237
docs/joystick-consent-flow.md
Normal file
237
docs/joystick-consent-flow.md
Normal file
|
|
@ -0,0 +1,237 @@
|
|||
# Joystick sign-in and consent: what was missing, and the flow that fills it
|
||||
|
||||
Status: built (sections 3-6 describe the code on this branch); sections 1-2 are
|
||||
the state of `fefd2dd` (main) that motivated it. Follow-up
|
||||
`heimdall-body:follow_up:chat-s3124-3129`, built under
|
||||
`heimdall-body:follow_up:chat-mind-20261108T131253147Z-t1`. The steward's rulings
|
||||
on the five open questions are in section 4.
|
||||
|
||||
## 1. What a viewer sees today
|
||||
|
||||
**Joystick viewer sign-in does not exist.** `streampixelsProfile`
|
||||
(`src/app-profiles.ts:109-117`) lists Joystick only in
|
||||
`managedConnectionProviders`. `admitsProviderForMode` (`:243`) admits `sign_in`
|
||||
and `link` only for `identityProviders`, so
|
||||
`POST /v1/oauth/joystick/start` with `mode: sign_in` returns
|
||||
`400 provider_not_supported_for_app` as JSON before any redirect
|
||||
(`startOAuthFlow`, `src/app.ts:598-603`). The viewer sees whatever the app does
|
||||
with a failed start; Heimdall shows them nothing. The architecture doc records
|
||||
this as deliberate until the public bot is registered
|
||||
(`docs/architecture.md:461`, `joystick:follow_up:joystick-viewer-signin-public-bot`).
|
||||
|
||||
**The only live Joystick path is a creator `connect`.** Walking it as the
|
||||
person in the browser:
|
||||
|
||||
1. The app backend starts the flow (authenticated by app secret, `connection`
|
||||
`{kind: creator, targetId}`). The person's browser is sent to
|
||||
`/v1/oauth/joystick/launch?state=...`.
|
||||
2. `launch` (`src/app.ts:1130-1194`) claims the state, sets the binding cookie
|
||||
and answers `302` straight to `joystick.tv/api/oauth/authorize`. **Heimdall
|
||||
renders no page of its own.** Nothing says who is asking, for what, or what
|
||||
will be kept.
|
||||
3. The only ask the person sees is Joystick's own screen, listing the scopes in
|
||||
`providerCatalog.joystick.defaultScopes` (`src/providers.ts:162`):
|
||||
`identity:read stream:read chat:read followers:read subscribers:read`.
|
||||
Joystick words that screen, not us.
|
||||
4. The callback (`:1196`) exchanges the code, stores the credential encrypted
|
||||
(rotating refresh token, managed custody), and returns the generic handoff
|
||||
page (`src/browser-handoff.ts`): title "Authentication Complete", body "You
|
||||
can return to the app now." It does not name the app, the provider, the
|
||||
scopes granted, or that a long-lived refresh token is now held by Heimdall.
|
||||
5. Refusal: if the person clicks Deny at Joystick, the callback gets
|
||||
`error=access_denied`, and the page says "Authentication Failed ... Return to
|
||||
the app to continue." The provider's own text is relayed only in
|
||||
`errorDescription` in the fallback URL fragment / postMessage payload, not
|
||||
shown on the page. Refusing *at Heimdall's step* is impossible: there is no
|
||||
Heimdall step.
|
||||
6. After: the audit rows `oauth_callback_succeeded`, `auth_completion_created`,
|
||||
`managed_credential_revoked` etc. (`createAuditEvent` call sites, e.g.
|
||||
`app.ts:1582`) are written for operators. There is **no route a viewer can
|
||||
call to read them**, and no route a viewer can call to revoke a credential.
|
||||
Revocation exists only inside the app backend plane (`managed-credential.ts:172`).
|
||||
|
||||
## 2. What consent is missing
|
||||
|
||||
| Gap | Today | Why it matters |
|
||||
| --- | --- | --- |
|
||||
| Visible ask | None from Heimdall; provider screen only | The person cannot tell Heimdall custody (refresh token kept, rotated, used for stream/chat/follower reads) from a one-off login. |
|
||||
| Who is asking | Not shown | Two parties act: the app (StreamPixels) and Heimdall as custodian. Neither is named. |
|
||||
| Scope truth | Provider screen lists scopes; Heimdall's `requestedScopes` / `defaultScopes` are not shown or compared with what was granted | Granted scopes can differ from requested; the stored `scopes` (`app.ts:1406`) are never shown. |
|
||||
| Typed refusal | A deny is an untyped `provider_error` | The app and the audit log cannot tell "viewer said no" from "provider broke". |
|
||||
| Receipt | Operator audit rows only | The viewer cannot audit what was agreed, when, or revoke it. |
|
||||
| Viewer vs creator | The `connect` binding proves a binding exists, not that the browser's owner is the creator (`joystick:follow_up:connect-start-needs-app-auth`) | Consent from the wrong person is not consent. |
|
||||
|
||||
## 3. The consent flow
|
||||
|
||||
Applies to every completion `callbackMint` calls `custody_only`: a managed
|
||||
creator connection (Joystick today; Twitch and YouTube on StreamPixels when
|
||||
they are connected rather than signed in). Viewer sign-in through an identity
|
||||
provider is unchanged.
|
||||
|
||||
### 3.1 The ask
|
||||
|
||||
`GET /v1/oauth/:provider/launch` renders a Heimdall page (`src/consent.ts`)
|
||||
instead of answering `302`, after the state verifies and before any use is
|
||||
claimed. The page names the app and the origin the person returns to, the
|
||||
provider and the exact scopes Heimdall will send (`authorizationScopes`, the
|
||||
same function that builds the authorization URL), what Heimdall keeps (an
|
||||
encrypted refresh token and access token, until the person takes it back or the
|
||||
provider ends it), what the app receives, and how to take it back. It carries
|
||||
two POST forms to `/v1/oauth/:provider/consent`, **Continue to Joystick** and
|
||||
**No, return to the app**, and runs no script. It sets the ask's own
|
||||
cookie (`__Host-heimdall-ask-<jti>`), which carries the exact text shown and is
|
||||
accepted only by Continue and No; an answer without it is `state_not_bound` and
|
||||
spends nothing. Viewing the ask claims nothing and binds nothing: the launch
|
||||
binding cookie, which decides who may complete the state, is set only when
|
||||
Continue claims the launch, and it carries the text shown on to the callback.
|
||||
(An earlier cut set the binding on the ask, so anyone holding the launch URL
|
||||
could become the state's owner; review of 2026-11-08 found it.)
|
||||
|
||||
What the app receives, stated as the code does it: not a claim. The app
|
||||
backend can call `managed-credentials/resolve` and receive the current access
|
||||
token; it never receives the refresh token. The earlier draft said the app
|
||||
receives "no token"; that was wrong and the page does not say it.
|
||||
|
||||
### 3.2 Typed refusal
|
||||
|
||||
A decline, and a provider `error=access_denied` on any provider, produce the
|
||||
result `consent_refused` with `by: "viewer" | "provider"`: an audit event
|
||||
`consent_refused` (provider, mode, by; no account, no person), the browser
|
||||
attempt denied with `denialCode consent_refused`, both uses of the state spent,
|
||||
a `backend_callback` app told with the same payload, a "Not Connected" page in
|
||||
the browser, and `400 {error: "consent_refused", by}` as JSON. No credential is
|
||||
stored and no receipt is written. Every other provider error stays
|
||||
`provider_error`. This changes the `access_denied` answer for every provider,
|
||||
including Bifrost's and Repixelizer's sign-in; see the PR for the contract note.
|
||||
|
||||
### 3.3 Receipt
|
||||
|
||||
On a granted `custody_only` completion Heimdall writes one `consent_receipts`
|
||||
row of kind `grant`: id (random), account, app, provider, scopes asked, scopes
|
||||
granted (as the provider returned them), `consentText` (the lines and
|
||||
button labels shown, taken from the ask and never rebuilt, so a deploy between
|
||||
ask and callback cannot change what the receipt says), `consentPageDigest`
|
||||
(sha-256 of that text), `createdAt`. A custody callback with no shown text
|
||||
exchanges no code and stores no credential. The id
|
||||
reaches the app (`consentReceiptId` in the completion and backend payloads) and
|
||||
the person (the handoff page).
|
||||
|
||||
Receipts are append-only: the store role has `SELECT` and `INSERT` on the table
|
||||
and nothing else. A revocation is a second row of kind `revocation` naming the
|
||||
grant it takes back, unique per grant (a partial unique index); a grant is live
|
||||
exactly when no revocation names it, and a concurrent second revoke reports
|
||||
nothing and writes nothing. The
|
||||
draft's `revokedAt` slot is gone for that reason.
|
||||
|
||||
### 3.4 My grants
|
||||
|
||||
Signed in means a live Heimdall access token for any app (`Authorization:
|
||||
Bearer`), or a page link minted from one.
|
||||
|
||||
- `GET /v1/me/grants`: every grant and receipt of the account. `Accept:
|
||||
text/html` gets the page, one **Take this back** form per live grant; anything
|
||||
else gets `{grants, receipts}`.
|
||||
- `POST /v1/me/grants/link` (bearer): `{url}` to the page, valid ten minutes.
|
||||
The token is signed, purpose-bound (`heimdall_grants_page`), stateless, and
|
||||
opens only this page and its revoke forms. The forms on a page opened by a link
|
||||
carry the link's own expiry, so using a link never renews it. This is how a browser that holds no
|
||||
session gets in; Heimdall sets no new cookie and stores nothing for it.
|
||||
- `POST /v1/me/grants/:id/revoke` (bearer, or the page token in the form):
|
||||
strips the stored tokens from the credential, then writes a revocation row
|
||||
for every live grant on that credential. The credential is one row per account
|
||||
and provider, whichever app asked, so taking it back ends every grant resting
|
||||
on it. The next `managed-credentials/resolve` answers `410
|
||||
managed_credential_revoked`; nothing else needs to learn of it. Revoking a
|
||||
revoked grant changes nothing. Another account's grant id is `404`.
|
||||
|
||||
Heimdall can delete its copy; it cannot withdraw the permission at the
|
||||
provider, and the page says so.
|
||||
|
||||
## 4. The steward's rulings
|
||||
|
||||
Each ruling picks the answer that gives the person the most agency and leaves
|
||||
the least stored.
|
||||
|
||||
1. **Who gets the ask: managed custody only.** Where Heimdall holds a credential
|
||||
the person cannot see and an app can use, the person is asked and given a
|
||||
receipt. A login is already asked by the provider's own screen, and a receipt
|
||||
per login would store a row per sign-in for no agency the provider's screen
|
||||
does not give. The line is `callbackMint === "custody_only"`, so it needs no
|
||||
second list to keep in step with the profiles.
|
||||
2. **The receipt is a new typed table, `consent_receipts`.** The audit table is
|
||||
operator-shaped and has no read path for the person; a viewer-readable
|
||||
record in it would make every audit row a potential disclosure. The table
|
||||
holds ids, scopes and a digest: no IP address, no user agent, no page text. A revocation names a
|
||||
receipt of its own account: a composite foreign key `(revokes_receipt_id,
|
||||
account_id)` to `(id, account_id)`, which is why `(id, account_id)` is also a
|
||||
unique key (`checkSchema` counts it). The in-memory store refuses the same. The table is created
|
||||
whole and first-created: no deployed database had an earlier shape, so there
|
||||
is no `ALTER` step.
|
||||
Refusals leave no receipt, only the anonymous audit row.
|
||||
3. **Viewer identity: sign-in, not the cookie.** The binding cookie dies with
|
||||
the state and proves only that a browser launched a flow; it is not an
|
||||
account. The receipt page and revoke require a live access token or a
|
||||
ten-minute link minted from one. The cost is that a first-time creator must
|
||||
hold the session the completion returned to the app; the app mints the link.
|
||||
The alternative, a new long-lived Heimdall cookie, would store a session for
|
||||
every person who merely looked.
|
||||
4. **`consent_refused` reaches a backend callback app.** An app that started the
|
||||
attempt and is waiting must be told, or it polls to expiry and cannot tell
|
||||
a person's no from a fault. The person's no is also not held against them:
|
||||
Heimdall stores nothing and sets no cooldown; whether and when to ask again
|
||||
is the app's rule.
|
||||
5. **Wording: derived, not authored.** The text is generated from facts the code
|
||||
holds and states nothing the code does not do; it is a constant in
|
||||
`src/consent.ts` and its digest rides every receipt. Legal review of the
|
||||
wording (the CultCoin legal thread) may only narrow it, and any change moves
|
||||
the digest. Until that review lands the copy is Heimdall's, signed by the
|
||||
steward.
|
||||
6. **Bounds on what rides the cookies.** The wording is read from a cookie
|
||||
only up to 16 KB inflated, so a compressed bomb is refused, not expanded. An
|
||||
app may request at most 32 scopes of 512 characters (`requested_scopes_too_large`
|
||||
at the ask). A custody callback whose binding carries no wording is refused
|
||||
with `consent_text_missing` before the state is claimed, so nothing is burned.
|
||||
|
||||
### Refusal return contract (for app authors)
|
||||
|
||||
A person's No at the ask, or a provider `access_denied`, is `consent_refused`.
|
||||
No completion code is minted and the state is spent. What each side gets:
|
||||
|
||||
- **Browser.** A 200 HTML page titled "Not Connected" (a non-HTML caller gets a 400
|
||||
JSON `{error, by, provider, returnTo}`). The page does not redirect: by ruling
|
||||
it never navigates on its own. It posts the payload to `window.opener`
|
||||
(target origin = the origin of `returnTo`), tries `window.close()` after 50 ms,
|
||||
and offers a "Return to the app" link. In a plain tab the person clicks it.
|
||||
- **The link** is `returnTo` with a fragment (read `location.hash`; it never
|
||||
reaches a server): `heimdall_status=error`, `heimdall_error=consent_refused`,
|
||||
`heimdall_refused_by=viewer|provider`, `heimdall_provider`,
|
||||
`heimdall_handoff_kind`, `heimdall_app_slug`, `heimdall_mode`, and
|
||||
`heimdall_attempt_id` when the flow carries an attempt. There is no
|
||||
`heimdall_completion_code`; a page with none, and `heimdall_error`, is a refusal.
|
||||
A fault is a different `heimdall_error` (`provider_error` and others).
|
||||
- **postMessage** carries `{source: "heimdall", kind: "oauth_result",
|
||||
status: "error", error: "consent_refused", by, provider, appSlug, mode,
|
||||
returnTo, handoffKind, attemptId?}`.
|
||||
- **Backend callback apps** get the same result POSTed to their callback URL
|
||||
(`status: "error"`, `error: "consent_refused"`, `by`, `attemptId`). An auth
|
||||
attempt is marked `denied` with `denialCode: "consent_refused"`, which
|
||||
`completeAuth` returns as `denied`.
|
||||
|
||||
`tests/joystick-consent.test.ts` ("the refusal return contract") pins the
|
||||
fragment for both refusals and the attempt id.
|
||||
|
||||
## 5. Out of scope
|
||||
|
||||
Enabling Joystick in `identityProviders`; fixing
|
||||
`joystick:follow_up:connect-start-needs-app-auth`; revoking at the provider
|
||||
(Joystick offers no revocation call Heimdall uses); retention or deletion of
|
||||
consent receipts and of the audit rows; consent for the creator's audience.
|
||||
|
||||
## 6. Tests
|
||||
|
||||
`tests/joystick-consent.test.ts` holds one behaviour per rule above. Rules were
|
||||
checked by mutation, each mutant run on its own with a 300 s limit under an 8 GB
|
||||
address-space cap (the PR lists them). The Postgres statements for
|
||||
`consent_receipts` are exercised by `tests/store.test.ts` against the fake pool
|
||||
and, when `HEIMDALL_TEST_PG_ADMIN_URL` is set, against a live database
|
||||
(`scripts/test-live-pg.sh`); the live run was not possible where this was built.
|
||||
|
|
@ -119,6 +119,7 @@ Supported providers in the skeleton:
|
|||
- `youtube`
|
||||
- `spotify`
|
||||
- `joystick`
|
||||
- `google`
|
||||
|
||||
Request body:
|
||||
|
||||
|
|
@ -149,12 +150,29 @@ Response:
|
|||
"appSlug": "repixelizer",
|
||||
"mode": "sign_in",
|
||||
"callbackUrl": "https://heimdall.gamecult.org/v1/oauth/discord/callback",
|
||||
"authorizationUrl": "https://discord.com/oauth2/authorize?...",
|
||||
"stateToken": "<signed-jwt>",
|
||||
"authorizationUrl": "https://heimdall.gamecult.org/v1/oauth/discord/launch?state=<signed-jwt>",
|
||||
"stateExpiresAt": "2026-04-26T12:10:00.000Z"
|
||||
}
|
||||
```
|
||||
|
||||
Send the user's browser to `authorizationUrl` unchanged. It is Heimdall's launch
|
||||
hop, not the provider's URL.
|
||||
|
||||
### `GET /v1/oauth/{provider}/launch?state=<signed-jwt>`
|
||||
|
||||
The first thing the user's browser does with a state. Heimdall verifies the
|
||||
state (signature, issuer, provider, `nbf`/`exp` with 30 s of skew), claims the
|
||||
state's single launch, sets the binding cookie
|
||||
`__Host-heimdall-oauth-<jti>` (`Path=/`, `Secure`, `HttpOnly`, `SameSite=Lax`,
|
||||
`Max-Age` until the state expires; the value is a Heimdall-signed binding for
|
||||
that state) and answers `302` to the provider's authorize URL, with
|
||||
`Cache-Control: no-store` and `Referrer-Policy: no-referrer`. A second launch of
|
||||
the same state is `400 state_already_launched` and sets no cookie. The state is
|
||||
refused with `400 invalid_state`, `state_provider_mismatch` or `state_expired`.
|
||||
|
||||
The binding cookie needs an `https` public base URL (or `localhost`). A browser
|
||||
must finish the flow in the browser that launched it.
|
||||
|
||||
Failure modes:
|
||||
|
||||
- `503 provider_not_configured` when the provider client id is missing
|
||||
|
|
@ -168,7 +186,46 @@ Failure modes:
|
|||
- `401 app_auth_required` when the request body carries `entitlementPolicy` and
|
||||
the caller did not authenticate as that app via `x-heimdall-app-secret`
|
||||
(`resolveAppCaller`, `src/app-caller.ts`) -- this applies regardless of
|
||||
`handoff.kind` or app slug; a caller with no policy to attach needs no secret
|
||||
`handoff.kind` or app slug; a caller with no policy to attach needs no secret,
|
||||
unless the app's profile sets `startRequiresAppCaller` (Bifrost only): then
|
||||
every start for that app, with or without a policy, needs that app's secret.
|
||||
Bifrost binds browser completion to a nonce that rides readable in the signed
|
||||
state's `return_to`, so only Bifrost may mint a Bifrost state; apps whose
|
||||
browser starts are public by design leave the flag unset
|
||||
- `401 app_auth_required` also when `mode` is `connect` and the body carries a
|
||||
`connection` (a creator or account target): a connection target is app-backend
|
||||
authority, so only the authenticated app named by `appSlug` may start it. No
|
||||
secret, or another app's, is refused before any state is signed. `sign_in`
|
||||
starts carrying a `connection` are `400 connection_not_allowed_in_sign_in`
|
||||
|
||||
Step-up (`stepUp: true`, sign_in only, off by default):
|
||||
|
||||
- Asks the provider for a real re-authentication on the authorize URL, so a
|
||||
provider session already open in the browser is not enough to complete the
|
||||
sign-in. The start request field is `stepUp`; the signed state carries it as
|
||||
`step_up`, and the launch hop builds the provider URL from the state alone.
|
||||
Nothing on the callback or redeem side can set or clear it (a `stepUp` in a
|
||||
redeem body is ignored), and a completion reports it as `stepUpRequested: true`
|
||||
when the start asked.
|
||||
- It is the authenticated app's request, like a connection target: no secret or
|
||||
another app's is `401 app_auth_required`; a `link` or `connect` start carrying
|
||||
it is `400 step_up_only_in_sign_in`; `stepUp: false` is the same as absent.
|
||||
- Provider parameters (`stepUpAuthorizationParams`, `src/providers.ts`): Twitch
|
||||
`force_verify=true`, YouTube `prompt=login consent` (consent is kept; the
|
||||
provider always asks it), Google `prompt=login`. **The strengths differ.**
|
||||
Google `prompt=login` forces the person to re-authenticate. Twitch
|
||||
`force_verify` re-shows the authorize page: it proves a person at that browser
|
||||
chose to continue, not that they entered credentials. A consumer that needs
|
||||
credentials re-entered must not rely on Twitch step-up.
|
||||
- A provider with no such parameter (Discord, Patreon, GitHub, Spotify,
|
||||
Joystick) is `400 step_up_not_supported`, with the provider named, before any
|
||||
state is signed. The URL builder throws rather than omit the step.
|
||||
- A `backend_callback` handoff delivery does not carry `stepUpRequested`; only the redeemed completion does.
|
||||
- A state signed by a build with step-up and launched by an older build loses the step
|
||||
silently (the older parser ignores `step_up`): deploy every Heimdall instance on one
|
||||
release, with no mixed window.
|
||||
- Heimdall requests the step; it cannot observe that the provider honoured it.
|
||||
`stepUpRequested` says "asked", not "verified".
|
||||
|
||||
Launch note:
|
||||
|
||||
|
|
@ -179,6 +236,45 @@ Launch note:
|
|||
implemented yet
|
||||
- Repixelizer launch can configure Discord and Patreon on its provider buttons
|
||||
|
||||
### Google (OpenID Connect, link-only)
|
||||
|
||||
`google` is an identity provider that never mints an account. It is a second
|
||||
door into a person who already has one.
|
||||
|
||||
- Callback redirect URI (register exactly this in the Google Cloud OAuth
|
||||
client): `{GC_ACCESS_BASE_URL}/v1/oauth/google/callback`, which is
|
||||
`https://heimdall.gamecult.org/v1/oauth/google/callback` in production.
|
||||
- Scopes `openid email profile`. The authorization request carries `state`
|
||||
(signed, Heimdall's), a `nonce`, and a PKCE `S256` challenge, all built at the
|
||||
launch hop, which is where the browser first meets the provider URL. The verifier
|
||||
and the nonce are derived from the state's `jti` and Heimdall's signing key,
|
||||
so nothing is stored between start and callback.
|
||||
- The callback verifies the `id_token` (RS256 against Google's published
|
||||
keys; `iss` is Google, `aud` is this client, `exp`, `iat`, `nonce`) and
|
||||
requires a `sub` and a verified email. The account key is `sub`; the email
|
||||
is a display and contact field and never a lookup key.
|
||||
- `mode: "link"` needs `Authorization: Bearer <Heimdall access token>` for the
|
||||
same app; the identity attaches to that token's account and to no other.
|
||||
`mode: "sign_in"` signs in an account the `sub` is already linked to.
|
||||
- A `sub` no account holds, arriving with `sign_in`, is refused and mints
|
||||
nothing. A `sub` linked to another account is refused and never moved.
|
||||
Both audit as `oauth_callback_failed` with error class `LinkRefusal`
|
||||
and the code `identity_not_linked` or `link_initiator_mismatch`.
|
||||
- Link is two-phase. The callback verifies the identity and records a pending
|
||||
link (TTL `completionTtlSeconds`), answering `status: "link_pending"` with a
|
||||
`pendingLinkId` and no session; it writes no linked identity. The app calls
|
||||
`POST /v1/apps/:appSlug/links/confirm` with `{ pendingLinkId }` and the
|
||||
Heimdall access token of the account that began the link; only that call
|
||||
attaches the identity. A different account, an expired, used or unknown id
|
||||
answers 410; a `sub` another account holds by then answers 409. A refused
|
||||
confirm does not consume the link.
|
||||
- A sign-in callback evaluates every linked identity of the account with the
|
||||
start-time entitlement policy, so a member returning through Google keeps
|
||||
what Discord or Patreon grant.
|
||||
- Configure with `GC_ACCESS_PROVIDER_GOOGLE_CLIENT_ID` and
|
||||
`GC_ACCESS_PROVIDER_GOOGLE_CLIENT_SECRET_FILE`. Admitted to the `bifrost`
|
||||
app profile only.
|
||||
|
||||
### `GET /v1/oauth/{provider}/callback`
|
||||
|
||||
Purpose:
|
||||
|
|
@ -189,7 +285,11 @@ Purpose:
|
|||
|
||||
Current status:
|
||||
|
||||
- validates signed `state`
|
||||
- validates signed `state` (signature, issuer, provider, expiry), requires the
|
||||
binding cookie the launch hop set, and consumes the state: a second callback
|
||||
is `400 state_already_used`, a missing or foreign cookie `400 state_not_bound`,
|
||||
an expired state `400 state_expired`; the binding is checked before the claim,
|
||||
so a browser without the cookie cannot burn the launching browser's state
|
||||
- returns provider errors cleanly
|
||||
- for Discord, exchanges the authorization code, resolves the provider
|
||||
identity, persists the local account/link/session/audit records, evaluates
|
||||
|
|
@ -334,6 +434,11 @@ Request body:
|
|||
}
|
||||
```
|
||||
|
||||
Binding rules:
|
||||
|
||||
- A completion minted for a connection target (`connection.targetId` in the signed state) is redeemed only with `targetId` equal to it; absent or different answers `403 completion_target_mismatch` and leaves the code unconsumed.
|
||||
- A `link` completion is redeemed only by the authenticated app backend (`x-heimdall-app-secret`); otherwise `401 app_auth_required`, code unconsumed. `link` start itself needs that authentication and `initiatingAccountId`; the callback refuses with `403 link_initiator_mismatch` when the provider identity belongs to a different account, and attaches an unlinked identity to the initiator.
|
||||
|
||||
Response:
|
||||
|
||||
```json
|
||||
|
|
@ -443,6 +548,256 @@ Important behavior:
|
|||
- the endpoint is not a provider OAuth start path and should not produce a
|
||||
provider authorization URL
|
||||
|
||||
### `GET /v1/me/identities`
|
||||
|
||||
The identities the signed-in account holds, for a member's own view.
|
||||
|
||||
Authentication: a live Heimdall access token for any app as
|
||||
`Authorization: Bearer` (the same check as `/v1/me/grants`). `401
|
||||
sign_in_required` otherwise. The answer is `Cache-Control: no-store`.
|
||||
|
||||
```json
|
||||
{
|
||||
"accountId": "uuid",
|
||||
"identities": [
|
||||
{
|
||||
"id": "uuid",
|
||||
"provider": "twitch",
|
||||
"providerUserId": "12345",
|
||||
"username": "name",
|
||||
"displayName": "Name",
|
||||
"linkedAt": "2026-11-13T12:00:00.000Z",
|
||||
"scopes": ["user:read:email"]
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
`username` and `displayName` are present when the provider gave them. The
|
||||
answer never carries a token column, the stored provider profile or the
|
||||
account's email.
|
||||
|
||||
### `POST /v1/me/identities/{identityId}/unlink`
|
||||
|
||||
Takes one identity off the signed-in account. It is the only way a linked
|
||||
identity is deleted, and it never takes the account's last one.
|
||||
|
||||
Authentication: a live Heimdall access token for any app, and fresh proof. The
|
||||
body is empty or `null`.
|
||||
|
||||
- `401 sign_in_required`: no live bearer.
|
||||
- `403 step_up_required`: the access token carries no `step_up_at` claim, or it
|
||||
is in the future, or it is older than 600 seconds
|
||||
(`STEP_UP_PROOF_TTL_SECONDS`, `src/claims.ts`). The remedy is a `sign_in`
|
||||
start with `stepUp: true` (see step-up above) through an identity on the
|
||||
account whose provider has re-authentication parameters, today twitch,
|
||||
youtube and google, then the access token that sign-in returns.
|
||||
- `404 identity_not_found`: no such identity, or one that belongs to another
|
||||
account. The two are not distinguishable.
|
||||
- `409 last_identity`: the account holds no other identity.
|
||||
- `200`: `{"unlinked": {"id", "provider", "providerUserId"}, "identities": [...]}`
|
||||
with the remaining list in the shape above.
|
||||
|
||||
`step_up_at` (epoch seconds) is set on the access claim only when the callback's
|
||||
signed state has `step_up` true and mode `sign_in`, or by an app's `POST
|
||||
/v1/apps/{appSlug}/step-up` assertion (below). A refresh never carries it:
|
||||
tokens a refresh issues cannot unlink, so proof is renewed only by a new step-up
|
||||
sign-in. The unlink writes the audit event `identity_unlinked` (provider and
|
||||
identity id only). When the account then holds no identity of that provider, the
|
||||
revocation receipts for its live grants of that provider are written, as the
|
||||
grants revoke route writes them.
|
||||
|
||||
A Twitch step-up proof is weaker than YouTube's or Google's: `force_verify` does
|
||||
not force credential re-entry (see the step-up note under the OAuth start
|
||||
section, "The strengths differ").
|
||||
|
||||
Limits that stay:
|
||||
|
||||
- Access tokens issued before the unlink keep the unlinked identity in their
|
||||
`identities` claim and its facts until they expire (`sessionTtlSeconds`).
|
||||
- Discord and Patreon identities cannot give proof (no re-authentication
|
||||
parameter); an account holding only those cannot unlink.
|
||||
- A stolen access token minted by a step-up sign-in can unlink more than one
|
||||
identity during its 600 second window.
|
||||
- A sign-in through a provider whose identity is no longer linked mints a new
|
||||
account.
|
||||
|
||||
A link no longer moves an identity: `upsertLinkedIdentity` refuses an identity
|
||||
another account holds (`links/confirm` answers `409 identity_linked_elsewhere`,
|
||||
the callback `link_initiator_mismatch`). An unlinked identity belongs to no
|
||||
account and can be linked by any account through the normal link flow.
|
||||
|
||||
### `POST /v1/apps/{appSlug}/step-up`
|
||||
|
||||
An app asserts that a member just passed a factor the app itself checked (for
|
||||
Bifrost: a passkey assertion or an emailed code), and receives an access token
|
||||
that carries that proof. The unlink route's step-up check then passes unchanged.
|
||||
|
||||
Authentication: both, always.
|
||||
|
||||
- the app's secret in `x-heimdall-app-secret`, as for every app route; and
|
||||
- the member's live Heimdall access token for the same app as
|
||||
`Authorization: Bearer`.
|
||||
|
||||
Body (`additionalProperties` are dropped as on the sibling routes):
|
||||
|
||||
```json
|
||||
{ "method": "bifrost-passkey", "nonce": "16 to 128 characters, fresh per assertion" }
|
||||
```
|
||||
|
||||
Nonce: 16 to 128 characters of the base64url alphabet (`A-Za-z0-9_-`), so a
|
||||
random token fits and spaces, controls and lone surrogates are a 400 schema
|
||||
refusal. `method` is 1 to 64 characters and then must be in the profile's set.
|
||||
|
||||
Schema validation (body shape, `method` length, the nonce pattern and length,
|
||||
the app slug) runs before the secret is checked and answers `400` with
|
||||
Fastify's fixed schema error, the same for every caller whatever the secret and
|
||||
never audited. Then the order of refusals, each a closed `error` code:
|
||||
|
||||
- `401 app_auth_required`: missing, wrong or another app's secret. The first
|
||||
check of the handler; nothing is written.
|
||||
- `403 step_up_assertion_not_permitted`: the app's profile has no
|
||||
`stepUpAssertion` grant. Only `bifrost` has one; every other app is refused
|
||||
with its own secret. This branch has its own small budget (5 per 60 s per
|
||||
app); past it the answer is 429.
|
||||
- `429 step_up_rate_limited` (`retryAfterSeconds`): the per-app budget (120 per
|
||||
60 s, spent by every attempt that passed the secret and the grant, including
|
||||
ones whose bearer then fails) is spent. In-process fixed windows: they reset
|
||||
when the process restarts and are not shared between instances.
|
||||
- `401 sign_in_required`: the bearer is missing, malformed, expired, signed by
|
||||
another key, a refresh token, or rests on a session that is not live (no row,
|
||||
wrong account, revoked or expired, revision moved). One answer for all of
|
||||
them; it does not say whether an account exists.
|
||||
- `403 bearer_app_mismatch`: a live bearer issued to another app. An app cannot
|
||||
assert for a token issued to another app. It tells only a holder of the
|
||||
secret and a valid bearer that the bearer is live and for another app, which
|
||||
that holder already knows.
|
||||
- `429 step_up_rate_limited`: the per-account budget (10 per 600 s) is spent.
|
||||
It is checked after the bearer and its audience, before method and nonce.
|
||||
- `400 unknown_step_up_method`: `method` is not in the profile's closed set
|
||||
(`methods` in the answer lists it). Bifrost: `bifrost-passkey`,
|
||||
`bifrost-email-code`. Provider labels (`provider:*`) cannot be asserted.
|
||||
- `409 step_up_nonce_replayed`: that nonce was already spent for this session.
|
||||
The claim is the store's `oauth_state_uses` single-use primitive with phase
|
||||
`step_up_assert` and the key a SHA-256 of session id and nonce, so it holds
|
||||
across restarts and instances. **Retention is the session's expiry as of the
|
||||
claim plus 10.5 minutes (the 10 minute prune margin and 30 s clock skew), and
|
||||
pruning is lazy: each successful claim deletes at most 50 expired rows.** A refresh slides the session's expiry
|
||||
without bound, so a nonce can be pruned while its session is still live and
|
||||
then be accepted again. Replaying it still needs the secret and a live
|
||||
bearer, which is the power to assert with a fresh nonce; the nonce guards a
|
||||
captured request, not a compromised app. A refused method or a rate-limited
|
||||
attempt does not spend the nonce.
|
||||
- `201`: `{"accessToken", "claimSet", "stepUp": {"at", "method", "validForSeconds"}}`,
|
||||
`Cache-Control: no-store`.
|
||||
|
||||
What the minted token is: a copy of the bearer's claims with a new `jti`,
|
||||
`iat` and `nbf`, `step_up_at` = now and `step_up_method` = the asserted method.
|
||||
It keeps the bearer's `exp`, same `sid` and account. Facts, capabilities and
|
||||
identities are the bearer's and are not recomputed, so the route adds proof and
|
||||
no capability. It mints no refresh token and writes no session row: it cannot
|
||||
extend a lifetime or a session. A later refresh carries neither claim. The proof
|
||||
is good for the usual 600 seconds (`STEP_UP_PROOF_TTL_SECONDS`) and only until
|
||||
the token's own `exp`.
|
||||
|
||||
Receipts: each assertion writes the audit event `step_up_asserted`, and each
|
||||
refusal after the secret verified writes `step_up_assertion_refused`, except
|
||||
that two kinds are not recorded row by row: a rate-limited refusal is recorded
|
||||
once per window per budget (its first; the row's `budget` names `app`,
|
||||
`account` or `notPermitted`), and an app without the grant once per window.
|
||||
Every other refusal under budget still writes a row each, up to about 121 a
|
||||
minute for a holder of the secret, and `audit_events` has no retention: that is
|
||||
an open follow-up. Rows carry the
|
||||
app, the account and session when the bearer resolved, `method` (null when it
|
||||
was not in the allowlist), `outcome`, `code`, `budget` (rate-limit rows) and `nonceDigest`. Never the
|
||||
secret, the bearer, the minted token or the nonce. A request without the secret,
|
||||
or failing schema validation, writes nothing.
|
||||
|
||||
Precondition: the route is usable only once the app holds the member's Heimdall
|
||||
bearer. Bifrost deliberately does not hold it today. Putting the bearer in a
|
||||
cookie ticket would turn cookie theft into bearer theft and, with
|
||||
`bifrost-passkey` or `bifrost-email-code`, into unlink power; whether and how
|
||||
Bifrost keeps the bearer is its own decision and is not made here.
|
||||
|
||||
Unlink accepts any method today. A `bifrost-email-code` proof unlinks an
|
||||
identity a Google re-authentication would have guarded. Identity moves
|
||||
(below) are the first route to require a method for whole-account coverage;
|
||||
unlink is unchanged.
|
||||
|
||||
What this does not prove: Heimdall cannot see the passkey or the code. It trusts
|
||||
the calling app's word, exactly as it trusts `stepUpRequested` (asked, not
|
||||
verified). The word is bounded by the app secret, a live member bearer for that
|
||||
app, the profile's method allowlist, a single-use nonce, the proof window and
|
||||
the rate limits. A compromised Bifrost can assert proofs only for members whose
|
||||
live bearer it holds. `identity_unlinked` records the proof's `stepUpMethod`
|
||||
(`provider:<name>`, an app label, or null), and unlink does not yet require any
|
||||
particular method.
|
||||
|
||||
### `POST /v1/apps/{appSlug}/identity-moves`
|
||||
|
||||
The one sanctioned way a login changes account (`moveIdentities` is the only
|
||||
writer of `linked_identities.account_id`). Bifrost owns the merge: survivor
|
||||
choice, preview, grace and undo timing. Heimdall receives the choice as which
|
||||
proofs fill which side, renders no preview and picks nothing. Only a profile with
|
||||
`identityMoves` may call it (today bifrost).
|
||||
|
||||
Credential: the app's secret. Body (closed; unknown properties are ignored, and
|
||||
no account is ever named by the body):
|
||||
|
||||
- `moveId` (`^[A-Za-z0-9_-]{16,64}$`): the caller's idempotency key.
|
||||
- `fromProofs`: 1 to 8 live Heimdall access tokens for this app, all of the
|
||||
source account.
|
||||
- Forward move: `toProof` (a live token of the destination) and optionally
|
||||
`identityIds` (1 to 32; default every login the source holds).
|
||||
- Reversal: `reversesMoveId` instead of `toProof`/`identityIds`. It moves back
|
||||
exactly the logins the forward move carried, once; `fromProofs` must be of the
|
||||
forward move's destination. A reversal is not itself reversible.
|
||||
|
||||
Each proof must be fresh: a step-up inside 600 s (`strong`) or a sign-in inside
|
||||
300 s (`weak`), by `proofTier`, the same freshness rule the unlink route reads.
|
||||
A token with neither claim (a refresh, a link) is stale.
|
||||
|
||||
Coverage: a proof through login X (`auth_identity_id`) moves X and nothing else
|
||||
from that account. Only a strong proof asserted with a method in the profile's
|
||||
`identityMoves.accountProofMethods` (`bifrost-passkey`; not `bifrost-email-code`,
|
||||
which proves an inbox) speaks for the whole account. Moving several logins takes
|
||||
one proof per login, or the passkey.
|
||||
|
||||
Order of refusals, each a fixed code: `401 app_auth_required`; `403
|
||||
not_allowed_for_app`; a replayed `moveId` is answered next (below); `409
|
||||
not_reversible` (reversal names a missing, foreign or reversal move); `403
|
||||
proof_invalid` `{proof: "from"|"to"}` (not a live bearer of this app, or
|
||||
`fromProofs` naming two accounts); `409 same_account`; `403 proof_stale`
|
||||
`{proof}`; `403 identity_not_proved`; then the store: `403 proof_invalid` (a
|
||||
proof session lapsed under the lock), `409 already_moved` (either side is an
|
||||
alias), `409 provider_conflict` `{provider}`, `409 not_reversible`, `409
|
||||
move_id_conflict`, `404 identity_not_found`, `403 identity_not_proved`. A refusal
|
||||
body is `{error, detail?, proof?, provider?}` and never names an account id, an
|
||||
identity the caller did not send, an email or a name.
|
||||
|
||||
On success, in one transaction: the logins move to the destination with their
|
||||
stored credentials stripped; every live session of the source is revoked and its
|
||||
pending links and unredeemed completions expire; one append-only `identity_moves`
|
||||
row is written. Afterwards, for each moved provider the source no longer holds,
|
||||
its live grants get revocation receipts under the source, and `identity_moved`
|
||||
is audited. Answer `200`, `Cache-Control: no-store`:
|
||||
`{moveId, accountId: <destination>, movedIdentityIds, proof: {from, to}, reversesMoveId?}`,
|
||||
with `proof.from` `strong` if any from-proof was strong and `to` null on a
|
||||
reversal.
|
||||
|
||||
Idempotency: the same `moveId` with the same app, accounts and `reversesMoveId`
|
||||
answers the stored receipt byte for byte, even though the first success revoked
|
||||
the source's sessions: the proofs are then checked for a valid Heimdall
|
||||
signature, issuer, type and audience, and account, not for liveness. The replay
|
||||
re-runs the revocation receipts, so a crash between commit and receipts heals on
|
||||
the caller's retry. Anything else under a used `moveId` is `409 move_id_conflict`.
|
||||
|
||||
What a move leaves: an account holding no login with an unreversed move from it
|
||||
is an alias: derived at move time, never stored, and no route resolves it. A
|
||||
move into or out of an alias is `already_moved`. Bearers of
|
||||
the destination keep their old identity list until they refresh. A sign-in
|
||||
through a moved login lands on the destination because the row moved.
|
||||
|
||||
### `POST /v1/apps/{appSlug}/managed-credentials/resolve`
|
||||
|
||||
Purpose:
|
||||
|
|
@ -491,12 +846,34 @@ Important behavior:
|
|||
identity (`SELECT ... FOR UPDATE`), so a given refresh token is presented to
|
||||
the provider once across concurrent requests and across two Heimdall
|
||||
processes sharing one database. Within one process, concurrent refreshes of
|
||||
one identity share a single attempt and its outcome (success or failure), so
|
||||
nobody re-presents a token behind a failed holder in that burst. Residual
|
||||
risk, tracked as follow-up `joystick:follow_up:cross-process-failed-refresh-marker`:
|
||||
the guard is one presentation per process per burst, so N
|
||||
Heimdall processes can present one token N times after a transient failure.
|
||||
The provider call is bounded at 10 seconds
|
||||
one identity share a single attempt and its outcome (success or failure). A
|
||||
failed or timed-out attempt is recorded on the identity row
|
||||
(`refresh_failed_at`, written in the same transaction as the lock), and no
|
||||
process presents that row's refresh token again for 60 seconds: a process
|
||||
that takes the lock inside the backoff answers the same
|
||||
`managed_credential_refresh_failed` without calling the provider. A stamp
|
||||
more than 60 seconds in the future (a writer whose clock runs ahead) is skew,
|
||||
not a fresh failure, so the wait is capped at twice the backoff. A rotation,
|
||||
a revocation or a re-link clears the marker.
|
||||
The marker is a best-effort write on a second connection, made after the
|
||||
lock's transaction rolled back; it is not part of that transaction. When the
|
||||
rotation or the revocation the provider's answer called for cannot be
|
||||
committed, the fallback write leaves the marker and blanks the refresh token
|
||||
only when that token is spent: on a revoke (a rotating provider answered
|
||||
without a refresh token, or the grant was rejected), or when the provider
|
||||
rotates refresh tokens (Joystick) and so consumed it. A provider that keeps
|
||||
its refresh token valid (Twitch) keeps it, so a transient database failure
|
||||
does not strand the link: the next caller after the backoff presents it again.
|
||||
Residual risk: the provider may consume the refresh token as soon as the
|
||||
request is sent. If a Heimdall process dies after that and before the commit
|
||||
of the marker, the rotation or the revocation, or if the blanking fallback
|
||||
write fails too, nothing is recorded, and the
|
||||
next caller can present the refresh token the provider already consumed; for
|
||||
a provider that rotates (Joystick) that reads as token theft. The Heimdall
|
||||
steward ruled (#minds, 2026-11-08) that an intent log, written on its own
|
||||
connection before the provider call, replaces this marker; it is tracked in
|
||||
`joystick:follow_up:write-ahead-refresh-attempt-record`.
|
||||
The provider call is bounded at 10 seconds.
|
||||
- a provider whose refresh tokens rotate (Joystick) fails closed: a refresh
|
||||
response without a new refresh token revokes the credential instead of
|
||||
keeping the old token
|
||||
|
|
@ -556,6 +933,10 @@ Current claim payload fields:
|
|||
- `typ`
|
||||
- `account_id`
|
||||
- `access_revision`
|
||||
- `step_up_at` optional: epoch seconds of the proof; set only by a `sign_in` step-up callback or `POST /v1/apps/{appSlug}/step-up`, never by a refresh
|
||||
- `step_up_method` optional: present exactly when `step_up_at` is; `provider:<name>` for a provider step-up sign-in, otherwise the method label the app asserted
|
||||
- `auth_at` optional: epoch seconds of the sign-in this token was minted by; set only by a `sign_in` callback (never link, connect or refresh), always with `auth_identity_id`
|
||||
- `auth_identity_id` optional: the `linked_identities.id` that sign-in came through; the only record of which login proved the session. An asserted step-up spreads the bearer's claims, so these pass through unchanged
|
||||
- `display_name` optional
|
||||
- `app.slug`
|
||||
- `app.profile_version`
|
||||
|
|
|
|||
|
|
@ -11,7 +11,8 @@ evidence only.
|
|||
|
||||
## Owner Map
|
||||
|
||||
- Owner: Heimdall owns provider identity/linking, OAuth attempts, signed session and claim
|
||||
- Owner: Heimdall owns provider identity/linking (an authenticator handle, not
|
||||
GameCult identity, which is Bifrost's), OAuth attempts, signed session and claim
|
||||
issuance, entitlement refresh, managed provider token custody, grants,
|
||||
auth-completion handoffs, refresh sessions, and audit events.
|
||||
- Inputs: provider OAuth callbacks, app profile requests, caller-supplied
|
||||
|
|
|
|||
35
notes/streampixels-connect-redeem.md
Normal file
35
notes/streampixels-connect-redeem.md
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
# For Kiko: what StreamPixels must do for a creator connect
|
||||
|
||||
Heimdall's side is done (this PR). A connect start that carries a `connection`
|
||||
target is accepted only with StreamPixels' own `x-heimdall-app-secret`, so only
|
||||
the StreamPixels backend can mint a state naming `{kind: "creator", targetId}`.
|
||||
Heimdall cannot see StreamPixels' session; the secret proves the caller is the
|
||||
backend, and the backend must have proved the creator-manage session itself
|
||||
before it starts the connect.
|
||||
|
||||
What StreamPixels has to change (not done here; this repo does not touch it):
|
||||
|
||||
1. **Start the connect only after the creator-manage check.** The route that
|
||||
calls `POST /v1/oauth/:provider/start` with `mode: "connect"` must have
|
||||
verified, for the signed-in StreamPixels user, that they may manage creator
|
||||
`targetId`. Never take `targetId` from the browser unchecked.
|
||||
2. **Remember what you started.** Store, server-side and bound to the attempt
|
||||
(the `attemptId` or browser session), the `targetId` StreamPixels asked
|
||||
Heimdall to bind.
|
||||
3. **Redeem with that stored target, never one read back from the request or
|
||||
the completion.** `POST /v1/apps/streampixels/auth/redeem` takes `targetId`;
|
||||
Heimdall answers `403 completion_target_mismatch` (code left unconsumed) when
|
||||
it differs from the signed state's. That only protects you if the value you
|
||||
send is the one you stored at step 2. A redeem with no stored target for this
|
||||
attempt must be refused by StreamPixels before it calls Heimdall.
|
||||
4. **Refuse a creator connect you did not start.** If a connect completion
|
||||
arrives for a `targetId` with no matching started attempt, do not rebind that
|
||||
creator's connector, whatever Heimdall's completion says.
|
||||
5. **A connect completion with no creator target is not a creator connect and
|
||||
not a sign-in.** Joystick is managed-connection only: a non-creator Joystick
|
||||
completion is an error. (Twitch/YouTube `connect` without a `connection` is
|
||||
Heimdall's viewer-session path; treat it as that, never as a connector rebind.)
|
||||
6. Blank targets (`" "`, zero-width characters) are refused by Heimdall at
|
||||
start with `400 invalid_connection_target`; send real ids only.
|
||||
|
||||
Tracked as `joystick:follow_up:connect-start-needs-app-auth`.
|
||||
|
|
@ -17,6 +17,7 @@
|
|||
"bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node24 --outfile=dist/heimdall --external:pg-native --banner:js=\"#!/usr/bin/env node\nimport{createRequire}from'node:module';const require=createRequire(import.meta.url);\""
|
||||
},
|
||||
"dependencies": {
|
||||
"@fastify/cookie": "^11.1.3",
|
||||
"@fastify/cors": "^11.2.0",
|
||||
"@msgpack/msgpack": "^3.1.3",
|
||||
"@gamecult/cultcache-ts": "file:vendor/CultLib/packages/cultcache-ts",
|
||||
|
|
|
|||
22
pnpm-lock.yaml
generated
22
pnpm-lock.yaml
generated
|
|
@ -12,6 +12,9 @@ importers:
|
|||
|
||||
.:
|
||||
dependencies:
|
||||
'@fastify/cookie':
|
||||
specifier: ^11.1.3
|
||||
version: 11.1.5
|
||||
'@fastify/cors':
|
||||
specifier: ^11.2.0
|
||||
version: 11.2.0
|
||||
|
|
@ -229,6 +232,9 @@ packages:
|
|||
'@fastify/ajv-compiler@4.0.5':
|
||||
resolution: {integrity: sha512-KoWKW+MhvfTRWL4qrhUwAAZoaChluo0m0vbiJlGMt2GXvL4LVPQEjt8kSpHI3IBq5Rez8fg+XeH3cneztq+C7A==}
|
||||
|
||||
'@fastify/cookie@11.1.5':
|
||||
resolution: {integrity: sha512-hs7e0otf7n/lJMpt63EFdQb5/u8kO6DeexEtLPVTybSdItC6SwJ1O0vtTyWvKNR70LZcHLlsUr/y3jFpqtyWRA==}
|
||||
|
||||
'@fastify/cors@11.2.0':
|
||||
resolution: {integrity: sha512-LbLHBuSAdGdSFZYTLVA3+Ch2t+sA6nq3Ejc6XLAKiQ6ViS2qFnvicpj0htsx03FyYeLs04HfRNBsz/a8SvbcUw==}
|
||||
|
||||
|
|
@ -469,6 +475,10 @@ packages:
|
|||
resolution: {integrity: sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==}
|
||||
engines: {node: '>=18'}
|
||||
|
||||
cookie@2.0.1:
|
||||
resolution: {integrity: sha512-yuToqVvRrj6pfDXREyQAAv8SkAEk/8GS3jQRTiUMm66TVtBYmqQeoEjL2Lmq8Rpo6271vH76InTChTitEAm65w==}
|
||||
engines: {node: '>=22'}
|
||||
|
||||
cultmesh-ts@file:vendor/CultLib/packages/cultmesh-ts:
|
||||
resolution: {directory: vendor/CultLib/packages/cultmesh-ts, type: directory}
|
||||
engines: {node: '>=18'}
|
||||
|
|
@ -547,6 +557,9 @@ packages:
|
|||
fastify-plugin@5.1.0:
|
||||
resolution: {integrity: sha512-FAIDA8eovSt5qcDgcBvDuX/v0Cjz0ohGhENZ/wpc3y+oZCY2afZ9Baqql3g/lC+OHRnciQol4ww7tuthOb9idw==}
|
||||
|
||||
fastify-plugin@6.0.1:
|
||||
resolution: {integrity: sha512-4wW4RxSmvPXLrh5mgQEiu43qU3bw44N2ss4FTkTkQIbprUhE+/s43QX0j/ttcztdWK7PEkHqVthdc5GdEGDvjA==}
|
||||
|
||||
fastify@5.12.7:
|
||||
resolution: {integrity: sha512-v4pEPsTRPuqlDIYiQFB+BHjVN4SdHX9u0ABk0ZDUKbbdY1vsNryUd1j4Z+jQEZajvYIVk047Kimva9/AJ79GYw==}
|
||||
|
||||
|
|
@ -1186,6 +1199,11 @@ snapshots:
|
|||
ajv-formats: 3.0.1(ajv@8.20.0)
|
||||
fast-uri: 3.1.0
|
||||
|
||||
'@fastify/cookie@11.1.5':
|
||||
dependencies:
|
||||
cookie: 2.0.1
|
||||
fastify-plugin: 6.0.1
|
||||
|
||||
'@fastify/cors@11.2.0':
|
||||
dependencies:
|
||||
fastify-plugin: 5.1.0
|
||||
|
|
@ -1393,6 +1411,8 @@ snapshots:
|
|||
|
||||
cookie@1.1.1: {}
|
||||
|
||||
cookie@2.0.1: {}
|
||||
|
||||
cultmesh-ts@file:vendor/CultLib/packages/cultmesh-ts:
|
||||
dependencies:
|
||||
'@gamecult/cultcache-ts': file:vendor/CultLib/packages/cultcache-ts
|
||||
|
|
@ -1500,6 +1520,8 @@ snapshots:
|
|||
|
||||
fastify-plugin@5.1.0: {}
|
||||
|
||||
fastify-plugin@6.0.1: {}
|
||||
|
||||
fastify@5.12.7:
|
||||
dependencies:
|
||||
'@fastify/ajv-compiler': 4.0.5
|
||||
|
|
|
|||
28
scripts/test-live-pg.sh
Executable file
28
scripts/test-live-pg.sh
Executable file
|
|
@ -0,0 +1,28 @@
|
|||
#!/usr/bin/env bash
|
||||
# Runs the whole vitest suite with the live-Postgres files enabled, against a
|
||||
# throwaway local cluster that this script starts and removes. Needs the
|
||||
# Postgres server binaries (initdb, pg_ctl) on PATH or in PG_BIN.
|
||||
# SOUL_PG_URL's test drops and recreates schema public, so it only ever sees
|
||||
# this disposable cluster.
|
||||
set -euo pipefail
|
||||
# Prerequisites, done here when missing (each step is skipped once it holds):
|
||||
# 1. the vendor/CultLib submodule checked out,
|
||||
# 2. its npm dependencies installed (the vendor packages build with its tsc),
|
||||
# 3. dist/ built for cultcache-ts, cultnet-ts and cultmesh-ts (package.json
|
||||
# points main at dist/index.js),
|
||||
# 4. this repo's pnpm install (npm install if pnpm fails with EACCES).
|
||||
cd "$(dirname "$0")/.."
|
||||
[ -f vendor/CultLib/package.json ] || git submodule update --init vendor/CultLib
|
||||
[ -d vendor/CultLib/node_modules/typescript ] || (cd vendor/CultLib && npm ci)
|
||||
for pkg in cultcache-ts cultnet-ts cultmesh-ts; do
|
||||
[ -f "vendor/CultLib/packages/$pkg/dist/index.js" ] || (cd "vendor/CultLib/packages/$pkg" && npm run build)
|
||||
done
|
||||
[ -d node_modules/vitest ] || pnpm install --frozen-lockfile || npm install # pnpm can fail with EACCES on its store; npm does not need it
|
||||
export PATH="${PG_BIN:-/usr/lib/postgresql/16/bin}:$PATH"
|
||||
dir="$(mktemp -d)"
|
||||
port="${PG_PORT:-54329}"
|
||||
trap 'pg_ctl -D "$dir" -m immediate stop >/dev/null 2>&1 || true; rm -rf "$dir"' EXIT
|
||||
initdb -D "$dir" -U pgadmin --auth=trust >/dev/null
|
||||
pg_ctl -D "$dir" -o "-p $port -k $dir -c listen_addresses=127.0.0.1" -l "$dir/log" -w start >/dev/null
|
||||
url="postgres://pgadmin@127.0.0.1:$port/postgres"
|
||||
HEIMDALL_TEST_PG_ADMIN_URL="$url" SOUL_PG_URL="$url" npx vitest run --config vitest.config.ts "$@"
|
||||
|
|
@ -45,6 +45,33 @@ export interface AppProfile {
|
|||
* plane; absent for apps with no such requirement.
|
||||
*/
|
||||
requiredEntitlementPolicyKind?: OAuthEntitlementPolicy["kind"];
|
||||
/**
|
||||
* The app binds browser completion to its own pending attempt, and the
|
||||
* binding is the secrecy of the attempt nonce, which rides readable in the
|
||||
* signed (not encrypted) state's return_to. If anyone could start a flow for
|
||||
* this app, whoever learned a victim's nonce could mint a completion bound
|
||||
* to it and sign the victim's browser in as themselves (login CSRF, finding
|
||||
* known-nonce-login-csrf). So a start for this app is refused unless the
|
||||
* caller is this app's authenticated caller: only the app can mint its own
|
||||
* state. Absent for apps whose browser starts are public by design.
|
||||
*/
|
||||
startRequiresAppCaller?: boolean;
|
||||
/**
|
||||
* The app may assert, with its secret and a member's live bearer, that the
|
||||
* member just passed a factor the app itself checked (POST
|
||||
* /v1/apps/{app}/step-up). Heimdall cannot see that factor and trusts the
|
||||
* app, so the grant is explicit per app and closed per method: only these
|
||||
* labels may be asserted, and they end up in the claim's step_up_method.
|
||||
* Absent for every app that may not assert.
|
||||
*/
|
||||
stepUpAssertion?: { methods: readonly string[] };
|
||||
/**
|
||||
* The app may move linked identities between two accounts it holds proofs
|
||||
* for (POST /v1/apps/{app}/identity-moves). `accountProofMethods` are the
|
||||
* asserted step_up_method labels that prove a whole account rather than one
|
||||
* login; each must be one of stepUpAssertion.methods. Absent: the app may not move.
|
||||
*/
|
||||
identityMoves?: { accountProofMethods: readonly string[] };
|
||||
}
|
||||
|
||||
/** The membership signal shared by every app that gates on GameCult membership. */
|
||||
|
|
@ -137,11 +164,15 @@ const streampixelsProfile: AppProfile = {
|
|||
const bifrostProfile: AppProfile = {
|
||||
slug: "bifrost",
|
||||
displayName: "Bifrost",
|
||||
profileVersion: "2026-06-08",
|
||||
identityProviders: ["discord", "patreon"],
|
||||
profileVersion: "2026-11-04",
|
||||
identityProviders: ["discord", "patreon", "google"],
|
||||
entitlementSources: ["discord", "patreon"],
|
||||
managedConnectionProviders: [],
|
||||
allowedReturnOrigins: ["https://bifrost.gamecult.org"],
|
||||
startRequiresAppCaller: true,
|
||||
stepUpAssertion: { methods: ["bifrost-passkey", "bifrost-email-code"] },
|
||||
// A passkey proves the account; an email code proves an inbox, which is one login's worth at most.
|
||||
identityMoves: { accountProofMethods: ["bifrost-passkey"] },
|
||||
capabilities: [
|
||||
{
|
||||
key: "member_access",
|
||||
|
|
@ -251,6 +282,17 @@ export function isAllowedReturnOrigin(profile: AppProfile, returnTo: string): bo
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A connection target names something: at least one letter or number that is
|
||||
* not a default-ignorable code point (the Hangul and Khmer fillers are letters
|
||||
* that render as nothing). An allowlist, so marks, private-use, unassigned and
|
||||
* surrogate code points and symbols cannot stand in for a name. The one
|
||||
* definition the start gate and the callback mint both use.
|
||||
*/
|
||||
export function isUsableConnectionTarget(targetId: string): boolean {
|
||||
return /(?![\p{Default_Ignorable_Code_Point}])[\p{L}\p{N}]/u.test(targetId);
|
||||
}
|
||||
|
||||
/**
|
||||
* What a completed OAuth callback may mint, decided at the callback from the
|
||||
* signed state's mode and the provider's role in the profile (the start gate
|
||||
|
|
@ -277,7 +319,7 @@ export function callbackMint(
|
|||
return mode === "connect" &&
|
||||
profile.managedConnectionProviders.includes(provider) &&
|
||||
connection?.kind === "creator" &&
|
||||
connection.targetId !== ""
|
||||
isUsableConnectionTarget(connection.targetId)
|
||||
? "custody_only"
|
||||
: "refused";
|
||||
}
|
||||
|
|
|
|||
1633
src/app.ts
1633
src/app.ts
File diff suppressed because it is too large
Load diff
|
|
@ -30,6 +30,8 @@ export interface BackendHandoffSuccessPayload
|
|||
mode: OAuthMode;
|
||||
account: AccountSummary;
|
||||
entitlements: EntitlementEvaluation;
|
||||
/** The receipt of the consent a managed connection rests on. */
|
||||
consentReceiptId?: string;
|
||||
}
|
||||
|
||||
export interface BackendHandoffErrorPayload extends BackendHandoffBase {
|
||||
|
|
@ -37,9 +39,20 @@ export interface BackendHandoffErrorPayload extends BackendHandoffBase {
|
|||
mode?: OAuthMode;
|
||||
error: string;
|
||||
errorDescription?: string;
|
||||
/** Who said no, when `error` is consent_refused. */
|
||||
by?: "viewer" | "provider";
|
||||
}
|
||||
|
||||
export type BackendHandoffPayload = BackendHandoffSuccessPayload | BackendHandoffErrorPayload;
|
||||
/** A verified link that waits for the initiating account's confirm: no session, no tokens. */
|
||||
export interface BackendHandoffLinkPendingPayload extends BackendHandoffBase {
|
||||
status: "link_pending";
|
||||
mode: OAuthMode;
|
||||
pendingLinkId: string;
|
||||
expiresAt: string;
|
||||
confirmEndpoint: string;
|
||||
}
|
||||
|
||||
export type BackendHandoffPayload = BackendHandoffSuccessPayload | BackendHandoffErrorPayload | BackendHandoffLinkPendingPayload;
|
||||
|
||||
export async function deliverBackendHandoff(callbackUrl: string, payload: BackendHandoffPayload): Promise<void> {
|
||||
const response = await fetch(callbackUrl, {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,11 @@ export interface BrowserHandoffSuccess extends BrowserHandoffBase {
|
|||
status: "success";
|
||||
mode: OAuthMode;
|
||||
completionCode?: string;
|
||||
/** A verified link waiting for its initiator's confirm; carries no session. */
|
||||
pendingLinkId?: string;
|
||||
attemptId?: string;
|
||||
/** The receipt of the consent a managed connection rests on. */
|
||||
consentReceiptId?: string;
|
||||
}
|
||||
|
||||
export interface BrowserHandoffError extends BrowserHandoffBase {
|
||||
|
|
@ -20,6 +24,8 @@ export interface BrowserHandoffError extends BrowserHandoffBase {
|
|||
error: string;
|
||||
errorDescription?: string;
|
||||
attemptId?: string;
|
||||
/** Who said no, when `error` is consent_refused. */
|
||||
by?: "viewer" | "provider";
|
||||
}
|
||||
|
||||
export type BrowserHandoffPayload = BrowserHandoffSuccess | BrowserHandoffError;
|
||||
|
|
@ -45,11 +51,19 @@ function buildBrowserFallbackUrl(payload: BrowserHandoffPayload): string {
|
|||
fragment.set("heimdall_attempt_id", payload.attemptId);
|
||||
}
|
||||
|
||||
if (payload.status === "success" && payload.consentReceiptId) {
|
||||
fragment.set("heimdall_consent_receipt_id", payload.consentReceiptId);
|
||||
}
|
||||
if (payload.status === "success" && payload.completionCode) {
|
||||
fragment.set("heimdall_completion_code", payload.completionCode);
|
||||
} else if (payload.status === "success" && payload.pendingLinkId) {
|
||||
fragment.set("heimdall_pending_link_id", payload.pendingLinkId);
|
||||
} else {
|
||||
if (payload.status === "error") {
|
||||
fragment.set("heimdall_error", payload.error);
|
||||
if (payload.by) {
|
||||
fragment.set("heimdall_refused_by", payload.by);
|
||||
}
|
||||
if (payload.errorDescription) {
|
||||
fragment.set("heimdall_error_description", payload.errorDescription);
|
||||
}
|
||||
|
|
@ -73,14 +87,19 @@ export function renderBrowserHandoffPage(payload: BrowserHandoffPayload): string
|
|||
});
|
||||
const scriptOrigin = serializeForScript(targetOrigin);
|
||||
const scriptFallbackUrl = serializeForScript(fallbackUrl);
|
||||
const scriptTitle = serializeForScript(
|
||||
payload.status === "success" ? "Authentication Complete" : "Authentication Failed"
|
||||
);
|
||||
const refused = payload.status === "error" && payload.error === "consent_refused";
|
||||
const pageTitle = refused ? "Not Connected" : payload.status === "success" ? "Authentication Complete" : "Authentication Failed";
|
||||
const scriptTitle = serializeForScript(pageTitle);
|
||||
const scriptBody = serializeForScript(
|
||||
payload.status === "success"
|
||||
? payload.handoffKind === "backend_callback"
|
||||
? "The app backend has the auth result already. You can return to the app now."
|
||||
: "You can return to the app now."
|
||||
refused
|
||||
? "Nothing was connected and nothing was kept. You can return to the app."
|
||||
: payload.status === "success"
|
||||
? (payload.handoffKind === "backend_callback"
|
||||
? "The app backend has the auth result already. You can return to the app now."
|
||||
: "You can return to the app now.") +
|
||||
(payload.consentReceiptId
|
||||
? ` Your consent is recorded as receipt ${payload.consentReceiptId}; you can review it and take it back from your Heimdall connections page.`
|
||||
: "")
|
||||
: "The authentication flow failed. Return to the app to continue."
|
||||
);
|
||||
|
||||
|
|
@ -89,7 +108,7 @@ export function renderBrowserHandoffPage(payload: BrowserHandoffPayload): string
|
|||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>${payload.status === "success" ? "Authentication Complete" : "Authentication Failed"}</title>
|
||||
<title>${pageTitle}</title>
|
||||
<style>
|
||||
:root {
|
||||
color-scheme: light dark;
|
||||
|
|
|
|||
|
|
@ -11,6 +11,12 @@ import { identityFacts } from "./facts.js";
|
|||
import { signJwt, type RuntimeKeyMaterial } from "./signing.js";
|
||||
import { type CreateSessionInput, type HeimdallStore } from "./store/types.js";
|
||||
|
||||
/** How long a step-up sign-in's proof stays good for an action that demands it (identity unlink). */
|
||||
export const STEP_UP_PROOF_TTL_SECONDS = 600;
|
||||
|
||||
/** How long a plain sign-in's proof stays good for an action that accepts a weak proof (an identity move). */
|
||||
export const AUTH_PROOF_TTL_SECONDS = 300;
|
||||
|
||||
function nowEpochSeconds(): number {
|
||||
return Math.floor(Date.now() / 1000);
|
||||
}
|
||||
|
|
@ -48,6 +54,14 @@ export interface IssueAccessClaimInput {
|
|||
sessionId?: string;
|
||||
accessRevision?: number;
|
||||
ttlSeconds?: number;
|
||||
/** Epoch seconds of a step-up sign-in completing; only that callback sets it, a refresh never does. */
|
||||
stepUpAt?: number;
|
||||
/** Required with stepUpAt (`provider:<name>`); the claim never carries one without the other. */
|
||||
stepUpMethod?: string;
|
||||
/** Epoch seconds of the sign-in that minted this token, with authIdentityId (both or neither). Only a sign_in callback sets them; a refresh, link or connect never does. */
|
||||
authAt?: number;
|
||||
/** The linked_identities.id the sign-in came through. */
|
||||
authIdentityId?: string;
|
||||
}
|
||||
|
||||
export interface IssuedAccessClaimResult {
|
||||
|
|
@ -130,6 +144,18 @@ export async function issueAccessClaim(options: {
|
|||
identities: options.input.linkedIdentities,
|
||||
};
|
||||
|
||||
if (options.input.stepUpAt !== undefined) {
|
||||
claimSet.step_up_at = options.input.stepUpAt;
|
||||
if (options.input.stepUpMethod !== undefined) {
|
||||
claimSet.step_up_method = options.input.stepUpMethod;
|
||||
}
|
||||
}
|
||||
|
||||
if (options.input.authAt !== undefined && options.input.authIdentityId !== undefined) {
|
||||
claimSet.auth_at = options.input.authAt;
|
||||
claimSet.auth_identity_id = options.input.authIdentityId;
|
||||
}
|
||||
|
||||
if (options.input.displayName) {
|
||||
claimSet.display_name = options.input.displayName;
|
||||
}
|
||||
|
|
@ -191,3 +217,62 @@ export async function issueAccessClaim(options: {
|
|||
: profile.capabilities.filter((capability) => capability.mode === "hybrid"),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* A new access token for the session the bearer already holds, carrying proof
|
||||
* the calling app asserted. Everything the bearer claimed is copied and
|
||||
* nothing is recomputed, so the route can add proof and no capability; `exp`
|
||||
* stays the bearer's, so it cannot extend a lifetime; no refresh token is
|
||||
* minted and no session row is written, so it cannot extend the session.
|
||||
*/
|
||||
export function signAssertedStepUpClaim(options: {
|
||||
keys: RuntimeKeyMaterial;
|
||||
bearerClaims: Record<string, unknown>;
|
||||
method: string;
|
||||
}): { accessToken: string; claimSet: Record<string, unknown>; stepUpAt: number } {
|
||||
const stepUpAt = nowEpochSeconds();
|
||||
const claimSet = {
|
||||
...options.bearerClaims,
|
||||
jti: randomUUID(),
|
||||
iat: stepUpAt,
|
||||
nbf: stepUpAt,
|
||||
step_up_at: stepUpAt,
|
||||
step_up_method: options.method,
|
||||
};
|
||||
return { accessToken: signJwt(claimSet, options.keys), claimSet, stepUpAt };
|
||||
}
|
||||
|
||||
/**
|
||||
* How fresh a bearer's proof of the member is, from its claims alone:
|
||||
* `strong` when a step-up (Heimdall's or the app's asserted one) happened in
|
||||
* the last STEP_UP_PROOF_TTL_SECONDS, else `weak` when the sign-in did in the
|
||||
* last AUTH_PROOF_TTL_SECONDS, else null. The one freshness rule: identity
|
||||
* unlink and identity moves both read it.
|
||||
*/
|
||||
export function proofTier(claims: Record<string, unknown>, nowS: number): "strong" | "weak" | null {
|
||||
const within = (at: unknown, window: number) => typeof at === "number" && at <= nowS && nowS - at <= window;
|
||||
if (within(claims.step_up_at, STEP_UP_PROOF_TTL_SECONDS)) return "strong";
|
||||
if (within(claims.auth_at, AUTH_PROOF_TTL_SECONDS)) return "weak";
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* What a fresh proof covers of its account: `account` (every login) only for a
|
||||
* strong proof whose step_up_method the app's profile lists as an account
|
||||
* proof; otherwise the one login the sign-in came through (its id); otherwise
|
||||
* nothing. A proof through login X never speaks for the account's other logins.
|
||||
*/
|
||||
export function proofCovers(
|
||||
claims: Record<string, unknown>,
|
||||
accountProofMethods: readonly string[],
|
||||
nowS: number
|
||||
): "account" | string | null {
|
||||
if (
|
||||
proofTier(claims, nowS) === "strong" &&
|
||||
typeof claims.step_up_method === "string" &&
|
||||
accountProofMethods.includes(claims.step_up_method)
|
||||
) {
|
||||
return "account";
|
||||
}
|
||||
return typeof claims.auth_identity_id === "string" ? claims.auth_identity_id : null;
|
||||
}
|
||||
|
|
|
|||
191
src/consent.ts
Normal file
191
src/consent.ts
Normal file
|
|
@ -0,0 +1,191 @@
|
|||
import { createHash } from "node:crypto";
|
||||
import { type AppSlug, type Provider } from "./contracts.js";
|
||||
import { getAppProfile } from "./app-profiles.js";
|
||||
import { providerCatalog } from "./providers.js";
|
||||
import { type StoredConsentReceipt } from "./store/index.js";
|
||||
|
||||
/**
|
||||
* What Heimdall tells a person before it holds a provider credential for an
|
||||
* app, and the page that lists what they agreed to. The wording is built from
|
||||
* the facts the code holds (the app, the provider, the scopes sent), never
|
||||
* from a promise the code does not keep. Any change to a line changes the
|
||||
* digest every later receipt carries, so a reader can tell which wording a
|
||||
* person saw.
|
||||
*/
|
||||
|
||||
export interface ConsentAsk {
|
||||
appSlug: AppSlug;
|
||||
provider: Provider;
|
||||
/** The scopes Heimdall will send the provider. */
|
||||
scopes: readonly string[];
|
||||
/** The origin the person returns to afterwards. */
|
||||
returnOrigin: string;
|
||||
}
|
||||
|
||||
export const GRANTS_PATH = "/v1/me/grants";
|
||||
|
||||
function appName(slug: AppSlug): string {
|
||||
return getAppProfile(slug)?.displayName ?? slug;
|
||||
}
|
||||
|
||||
/** The exact lines shown on the ask, apart from the two buttons. The digest is over these. */
|
||||
export function consentLines(ask: ConsentAsk): string[] {
|
||||
const app = appName(ask.appSlug);
|
||||
const provider = providerCatalog[ask.provider].displayName;
|
||||
return [
|
||||
`${app} asks Heimdall to hold a connection to your ${provider} account.`,
|
||||
`Heimdall will ask ${provider} for these permissions: ${ask.scopes.join(", ")}.`,
|
||||
`Heimdall keeps an encrypted refresh token and access token for this connection until you take it back or ${provider} ends it.`,
|
||||
`${app}'s server can ask Heimdall for a current access token and use it for those permissions. It never receives the refresh token.`,
|
||||
`If you say no, nothing is kept.`,
|
||||
`You can take this back at any time. Heimdall then deletes its copy of the tokens and stops handing out access tokens. The permission stays with ${provider} until you remove it in your ${provider} settings.`,
|
||||
`Afterwards you are returned to ${ask.returnOrigin}.`,
|
||||
];
|
||||
}
|
||||
|
||||
/** The labels on the two buttons. They are wording the person agrees to, so they are part of the text. */
|
||||
export function consentButtons(ask: ConsentAsk): { go: string; no: string } {
|
||||
return { go: `Continue to ${providerCatalog[ask.provider].displayName}`, no: "No, return to the app" };
|
||||
}
|
||||
|
||||
/**
|
||||
* Everything the person reads before answering, as one text: the lines and the
|
||||
* button labels. It is built once, when the ask is rendered, and that exact
|
||||
* text travels with the flow to the receipt; nothing rebuilds it later.
|
||||
*/
|
||||
export function consentText(ask: ConsentAsk): string {
|
||||
const { go, no } = consentButtons(ask);
|
||||
return [...consentLines(ask), go, no].join("\n");
|
||||
}
|
||||
|
||||
export function digestOfText(text: string): string {
|
||||
return createHash("sha256").update(text, "utf8").digest("hex");
|
||||
}
|
||||
|
||||
export function consentDigest(ask: ConsentAsk): string {
|
||||
return digestOfText(consentText(ask));
|
||||
}
|
||||
|
||||
export function escapeHtml(value: string): string {
|
||||
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """).replace(/'/g, "'");
|
||||
}
|
||||
|
||||
const pageStyle = `
|
||||
:root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, sans-serif; }
|
||||
body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: #11161d; color: #f4f7fb; }
|
||||
main { width: min(38rem, calc(100vw - 2rem)); border-radius: 1rem; padding: 1.5rem; background: rgba(20, 27, 36, 0.96); box-shadow: 0 24px 60px rgba(0, 0, 0, 0.3); }
|
||||
h1 { margin: 0 0 0.75rem; font-size: 1.35rem; }
|
||||
p, li { line-height: 1.5; color: #d5dce6; }
|
||||
ul { padding-left: 1.2rem; }
|
||||
code { color: #d8eefe; }
|
||||
button { font: inherit; font-weight: 600; border: 0; border-radius: 999px; padding: 0.75rem 1rem; margin: 0.25rem 0.5rem 0.25rem 0; cursor: pointer; }
|
||||
button.go { color: #11161d; background: #d8eefe; }
|
||||
button.no { color: #f4f7fb; background: #2c3745; }
|
||||
section { border-top: 1px solid #2c3745; padding: 0.75rem 0; }
|
||||
small { color: #9aacbe; }`;
|
||||
|
||||
function page(title: string, body: string): string {
|
||||
return `<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>${escapeHtml(title)}</title>
|
||||
<style>${pageStyle}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<main>
|
||||
${body}
|
||||
</main>
|
||||
</body>
|
||||
</html>`;
|
||||
}
|
||||
|
||||
/** The ask. Two POST forms carry the signed state; the page runs no script. */
|
||||
export function renderConsentPage(ask: ConsentAsk, state: string): string {
|
||||
const lines = consentLines(ask);
|
||||
const provider = providerCatalog[ask.provider].displayName;
|
||||
const [headline, ...rest] = lines;
|
||||
const form = (decision: "continue" | "decline", label: string) =>
|
||||
`<button class="${decision === "continue" ? "go" : "no"}" type="submit" name="decision" value="${decision}">${escapeHtml(label)}</button>`;
|
||||
return page(
|
||||
`${appName(ask.appSlug)} wants to connect ${provider}`,
|
||||
` <h1>${escapeHtml(headline!)}</h1>
|
||||
<ul>
|
||||
${rest.map((line) => ` <li>${escapeHtml(line)}</li>`).join("\n")}
|
||||
</ul>
|
||||
<form method="post" action="/v1/oauth/${ask.provider}/consent">
|
||||
<input type="hidden" name="state" value="${escapeHtml(state)}">
|
||||
${form("continue", consentButtons(ask).go)}
|
||||
${form("decline", consentButtons(ask).no)}
|
||||
</form>`
|
||||
);
|
||||
}
|
||||
|
||||
export interface GrantView {
|
||||
consentText: string;
|
||||
id: string;
|
||||
appSlug: AppSlug;
|
||||
provider: Provider;
|
||||
scopesAsked: string[];
|
||||
scopesGranted: string[];
|
||||
grantedAt: string;
|
||||
consentPageDigest: string;
|
||||
status: "active" | "revoked";
|
||||
revokedAt?: string;
|
||||
revocationReceiptId?: string;
|
||||
}
|
||||
|
||||
/** Every grant the receipts hold, each live unless a revocation names it. */
|
||||
export function grantViews(receipts: readonly StoredConsentReceipt[]): GrantView[] {
|
||||
const revocations = new Map<string, StoredConsentReceipt & { kind: "revocation" }>();
|
||||
for (const receipt of receipts) {
|
||||
if (receipt.kind === "revocation") revocations.set(receipt.revokesReceiptId, receipt);
|
||||
}
|
||||
const views: GrantView[] = [];
|
||||
for (const receipt of receipts) {
|
||||
if (receipt.kind !== "grant") continue;
|
||||
const revocation = revocations.get(receipt.id);
|
||||
views.push({
|
||||
id: receipt.id,
|
||||
appSlug: receipt.appSlug,
|
||||
provider: receipt.provider,
|
||||
scopesAsked: receipt.scopesAsked,
|
||||
scopesGranted: receipt.scopesGranted,
|
||||
grantedAt: receipt.createdAt,
|
||||
consentPageDigest: receipt.consentPageDigest,
|
||||
consentText: receipt.consentText,
|
||||
status: revocation ? "revoked" : "active",
|
||||
...(revocation ? { revokedAt: revocation.createdAt, revocationReceiptId: revocation.id } : {}),
|
||||
});
|
||||
}
|
||||
return views;
|
||||
}
|
||||
|
||||
/** The signed-in page: every grant with its receipt, one button each to take it back. */
|
||||
export function renderGrantsPage(grants: readonly GrantView[], pageToken: string, notice?: string): string {
|
||||
const cards = grants.length
|
||||
? grants
|
||||
.map((grant) => {
|
||||
const provider = providerCatalog[grant.provider].displayName;
|
||||
const header = `${escapeHtml(appName(grant.appSlug))} → ${escapeHtml(provider)}`;
|
||||
const detail = `granted ${escapeHtml(grant.grantedAt)}; permissions ${escapeHtml(grant.scopesGranted.join(", ") || "none returned")}; receipt <code>${escapeHtml(grant.id)}</code>; wording <code>${escapeHtml(grant.consentPageDigest.slice(0, 12))}</code>`;
|
||||
if (grant.status === "revoked") {
|
||||
return ` <section><strong>${header}</strong> <small>taken back ${escapeHtml(grant.revokedAt ?? "")}; receipt <code>${escapeHtml(grant.revocationReceiptId ?? "")}</code></small><br><small>${detail}</small></section>`;
|
||||
}
|
||||
return ` <section><strong>${header}</strong> <small>active</small><br><small>${detail}</small>
|
||||
<form method="post" action="${GRANTS_PATH}/${escapeHtml(grant.id)}/revoke">
|
||||
<input type="hidden" name="t" value="${escapeHtml(pageToken)}">
|
||||
<button class="no" type="submit">Take this back</button>
|
||||
</form></section>`;
|
||||
})
|
||||
.join("\n")
|
||||
: ` <p>You have not connected anything through Heimdall.</p>`;
|
||||
return page(
|
||||
"Your connections",
|
||||
` <h1>Your connections</h1>
|
||||
${notice ? ` <p><strong>${escapeHtml(notice)}</strong></p>\n` : ""}${cards}
|
||||
<p><small>Taking a connection back deletes Heimdall's copy of the tokens. The app's next request for a token is refused. The permission stays with the provider until you remove it in the provider's settings.</small></p>`
|
||||
);
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
export const providers = ["discord", "patreon", "github", "twitch", "youtube", "spotify", "joystick"] as const;
|
||||
export const providers = ["discord", "patreon", "github", "twitch", "youtube", "spotify", "joystick", "google"] as const;
|
||||
|
||||
export type Provider = (typeof providers)[number];
|
||||
|
||||
|
|
@ -73,9 +73,13 @@ export interface OAuthStartRequest {
|
|||
mode: OAuthMode;
|
||||
returnTo: string;
|
||||
connection?: OAuthConnectionBinding;
|
||||
/** Link mode only: the account the authenticated app says is linking. Carried in the signed state. */
|
||||
initiatingAccountId?: string;
|
||||
handoff?: OAuthHandoff;
|
||||
requestedScopes?: string[];
|
||||
entitlementPolicy?: OAuthEntitlementPolicy;
|
||||
/** Sign_in only, app-authenticated: ask the provider for a real re-authentication. Off when absent. */
|
||||
stepUp?: boolean;
|
||||
}
|
||||
|
||||
export interface OAuthStatePayload {
|
||||
|
|
@ -92,8 +96,13 @@ export interface OAuthStatePayload {
|
|||
mode: OAuthMode;
|
||||
return_to: string;
|
||||
connection: OAuthConnectionBinding | null;
|
||||
initiator_account_id: string | null;
|
||||
handoff: OAuthHandoff | null;
|
||||
entitlement_policy: OAuthEntitlementPolicy | null;
|
||||
/** The start's requestedScopes, carried so the launch hop can build the provider URL from the signed state alone. */
|
||||
requested_scopes: string[] | null;
|
||||
/** The start's step-up request. Signed, so the launch hop reads it here and nowhere else; null when not asked. */
|
||||
step_up: true | null;
|
||||
}
|
||||
|
||||
export interface LinkedIdentityInput {
|
||||
|
|
@ -105,6 +114,8 @@ export interface LinkedIdentityInput {
|
|||
|
||||
export interface RedeemAuthCompletionRequest {
|
||||
completionCode: string;
|
||||
/** Required when the completion was minted for a connection target; must equal it. */
|
||||
targetId?: string;
|
||||
}
|
||||
|
||||
export type HeimdallAuthAttemptStatus = "pending" | "completed" | "denied" | "consumed" | "expired";
|
||||
|
|
@ -142,6 +153,19 @@ export interface AccessClaimPayload {
|
|||
typ: "heimdall_access";
|
||||
account_id: string;
|
||||
access_revision: number;
|
||||
/** Epoch seconds of the step-up sign-in this access token was minted by; absent on every other token, and never carried by a refresh. */
|
||||
step_up_at?: number;
|
||||
/**
|
||||
* How the proof in step_up_at was made: `provider:<name>` for a step-up
|
||||
* sign-in Heimdall ran, or one of the calling app's allowlisted method
|
||||
* labels when the app asserted it (POST /v1/apps/{app}/step-up). Present
|
||||
* exactly when step_up_at is; never carried by a refresh.
|
||||
*/
|
||||
step_up_method?: string;
|
||||
/** Epoch seconds of the sign-in this access token was minted by, with auth_identity_id; absent unless a sign_in callback minted it, and never carried by a refresh. */
|
||||
auth_at?: number;
|
||||
/** The linked_identities.id the sign-in came through; present exactly when auth_at is. It is the only record of which login proved the session, and it describes the sign-in, not an asserted factor. */
|
||||
auth_identity_id?: string;
|
||||
display_name?: string;
|
||||
app: {
|
||||
slug: AppSlug;
|
||||
|
|
|
|||
49
src/fixed-window.ts
Normal file
49
src/fixed-window.ts
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
// A fixed-window attempt budget per key, held in memory by the process that
|
||||
// serves the route. It bounds a credentialed caller's rate; it is not a
|
||||
// security boundary on its own and resets on restart. The clock is injected
|
||||
// so tests can move it.
|
||||
|
||||
export interface FixedWindowLimit {
|
||||
max: number;
|
||||
windowMs: number;
|
||||
}
|
||||
|
||||
export class FixedWindowBudget {
|
||||
private readonly windows = new Map<string, { startedAt: number; used: number }>();
|
||||
|
||||
constructor(
|
||||
private readonly limit: FixedWindowLimit,
|
||||
private readonly now: () => number = Date.now,
|
||||
private readonly maxKeys = 4096,
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Spend one attempt for `key`. `n` counts attempts in the window, denied ones
|
||||
* included, so a caller can act on the first denial (`n === max + 1`) and not
|
||||
* on the flood behind it. `retryAfterSeconds` is 0 when allowed.
|
||||
*/
|
||||
spend(key: string): { n: number; retryAfterSeconds: number } {
|
||||
const at = this.now();
|
||||
let current = this.windows.get(key);
|
||||
if (!current || at - current.startedAt >= this.limit.windowMs) {
|
||||
this.sweep(at);
|
||||
current = { startedAt: at, used: 0 };
|
||||
this.windows.set(key, current);
|
||||
}
|
||||
current.used += 1;
|
||||
if (current.used <= this.limit.max) return { n: current.used, retryAfterSeconds: 0 };
|
||||
return { n: current.used, retryAfterSeconds: Math.max(1, Math.ceil((current.startedAt + this.limit.windowMs - at) / 1000)) };
|
||||
}
|
||||
|
||||
/** Drop turned-over windows once the table is full; if it is still full, the oldest key goes. */
|
||||
private sweep(at: number): void {
|
||||
if (this.windows.size < this.maxKeys) return;
|
||||
for (const [key, window] of this.windows) {
|
||||
if (at - window.startedAt >= this.limit.windowMs) this.windows.delete(key);
|
||||
}
|
||||
if (this.windows.size >= this.maxKeys) {
|
||||
const oldest = this.windows.keys().next().value;
|
||||
if (oldest !== undefined) this.windows.delete(oldest);
|
||||
}
|
||||
}
|
||||
}
|
||||
228
src/google-oidc.ts
Normal file
228
src/google-oidc.ts
Normal file
|
|
@ -0,0 +1,228 @@
|
|||
import { createHash, createPublicKey, sign, verify, type KeyObject } from "node:crypto";
|
||||
|
||||
/**
|
||||
* Google sign-in as OpenID Connect: the id_token is the identity, and this
|
||||
* file is the one place that decides whether to believe it. The subject
|
||||
* (`sub`) is the account key; the email is a claim about the subject, never
|
||||
* its key.
|
||||
*/
|
||||
|
||||
export const GOOGLE_ISSUERS = ["https://accounts.google.com", "accounts.google.com"] as const;
|
||||
export const GOOGLE_JWKS_URI = "https://www.googleapis.com/oauth2/v3/certs";
|
||||
|
||||
const CLOCK_LEEWAY_SECONDS = 60;
|
||||
const DEFAULT_JWKS_TTL_SECONDS = 3600;
|
||||
const MAX_JWKS_TTL_SECONDS = 24 * 3600;
|
||||
/** An unknown `kid` refetches the key set at most this often. */
|
||||
const MIN_JWKS_REFETCH_MS = 60_000;
|
||||
|
||||
export type GoogleIdTokenFailure =
|
||||
| "malformed"
|
||||
| "unsupported_algorithm"
|
||||
| "unknown_key"
|
||||
| "bad_signature"
|
||||
| "bad_issuer"
|
||||
| "bad_audience"
|
||||
| "expired"
|
||||
| "not_yet_valid"
|
||||
| "bad_nonce"
|
||||
| "missing_subject"
|
||||
| "email_missing"
|
||||
| "email_not_verified"
|
||||
| "jwks_unavailable";
|
||||
|
||||
/** A refusal that names the rule that failed and quotes nothing from the token. */
|
||||
export class GoogleIdTokenError extends Error {
|
||||
readonly code: GoogleIdTokenFailure;
|
||||
|
||||
constructor(code: GoogleIdTokenFailure) {
|
||||
super(`Google id_token refused (${code}).`);
|
||||
this.name = "GoogleIdTokenError";
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
|
||||
export interface GoogleIdentityClaims {
|
||||
sub: string;
|
||||
email: string;
|
||||
name?: string;
|
||||
picture?: string;
|
||||
hd?: string;
|
||||
}
|
||||
|
||||
interface Jwk {
|
||||
kid?: string;
|
||||
kty?: string;
|
||||
alg?: string;
|
||||
n?: string;
|
||||
e?: string;
|
||||
}
|
||||
|
||||
let cachedKeys: { keys: Map<string, KeyObject>; expiresAt: number; fetchedAt: number } | null = null;
|
||||
|
||||
export function resetGoogleJwksCache(): void {
|
||||
cachedKeys = null;
|
||||
}
|
||||
|
||||
async function fetchGoogleKeys(now: number): Promise<{ keys: Map<string, KeyObject>; expiresAt: number; fetchedAt: number }> {
|
||||
let response: Response;
|
||||
try {
|
||||
response = await fetch(GOOGLE_JWKS_URI, { headers: { Accept: "application/json" } });
|
||||
} catch {
|
||||
throw new GoogleIdTokenError("jwks_unavailable");
|
||||
}
|
||||
if (!response.ok) {
|
||||
throw new GoogleIdTokenError("jwks_unavailable");
|
||||
}
|
||||
let body: { keys?: Jwk[] };
|
||||
try {
|
||||
body = (await response.json()) as { keys?: Jwk[] };
|
||||
} catch {
|
||||
throw new GoogleIdTokenError("jwks_unavailable");
|
||||
}
|
||||
const keys = new Map<string, KeyObject>();
|
||||
for (const jwk of body.keys ?? []) {
|
||||
if (jwk.kty !== "RSA" || !jwk.kid || (jwk.alg !== undefined && jwk.alg !== "RS256")) continue;
|
||||
try {
|
||||
keys.set(jwk.kid, createPublicKey({ key: jwk as never, format: "jwk" }));
|
||||
} catch {
|
||||
// A key Node cannot read verifies nothing; the others stand.
|
||||
}
|
||||
}
|
||||
const maxAge = /max-age=(\d+)/.exec(response.headers.get("cache-control") ?? "");
|
||||
const ttl = Math.min(maxAge ? Number(maxAge[1]) : DEFAULT_JWKS_TTL_SECONDS, MAX_JWKS_TTL_SECONDS);
|
||||
return { keys, expiresAt: now + ttl * 1000, fetchedAt: now };
|
||||
}
|
||||
|
||||
async function keyForKid(kid: string, now: number): Promise<KeyObject> {
|
||||
if (cachedKeys && cachedKeys.expiresAt > now) {
|
||||
const hit = cachedKeys.keys.get(kid);
|
||||
if (hit) return hit;
|
||||
// Unknown kid in a live cache: Google may have rotated. Refetch, but not on every bad token.
|
||||
if (now - cachedKeys.fetchedAt < MIN_JWKS_REFETCH_MS) {
|
||||
throw new GoogleIdTokenError("unknown_key");
|
||||
}
|
||||
}
|
||||
cachedKeys = await fetchGoogleKeys(now);
|
||||
const key = cachedKeys.keys.get(kid);
|
||||
if (!key) throw new GoogleIdTokenError("unknown_key");
|
||||
return key;
|
||||
}
|
||||
|
||||
function decodeSegment(segment: string): Record<string, unknown> {
|
||||
try {
|
||||
const value = JSON.parse(Buffer.from(segment, "base64url").toString("utf8")) as unknown;
|
||||
if (typeof value === "object" && value !== null && !Array.isArray(value)) {
|
||||
return value as Record<string, unknown>;
|
||||
}
|
||||
} catch {
|
||||
// fallthrough
|
||||
}
|
||||
throw new GoogleIdTokenError("malformed");
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies a Google id_token for this client. Order is signature first, then
|
||||
* claims, so no claim of an unauthenticated token decides anything. Refuses
|
||||
* on: algorithm other than RS256, unknown key, bad signature, `iss` not
|
||||
* Google, `aud` not this client (an array `aud` also needs `azp` to be this
|
||||
* client), `exp` passed, `iat` or `nbf` in the future, `nonce` not the one
|
||||
* this authorization request carried, no `sub`, no `email`, and an email
|
||||
* Google has not verified.
|
||||
*/
|
||||
export async function verifyGoogleIdToken(
|
||||
idToken: string,
|
||||
expected: { clientId: string; nonce: string },
|
||||
nowMs: number = Date.now()
|
||||
): Promise<GoogleIdentityClaims> {
|
||||
const parts = idToken.split(".");
|
||||
if (parts.length !== 3 || parts.some((part) => part === "")) {
|
||||
throw new GoogleIdTokenError("malformed");
|
||||
}
|
||||
const [encodedHeader, encodedPayload, encodedSignature] = parts as [string, string, string];
|
||||
const header = decodeSegment(encodedHeader);
|
||||
if (header.alg !== "RS256") {
|
||||
throw new GoogleIdTokenError("unsupported_algorithm");
|
||||
}
|
||||
if (typeof header.kid !== "string" || header.kid === "") {
|
||||
throw new GoogleIdTokenError("unknown_key");
|
||||
}
|
||||
|
||||
const key = await keyForKid(header.kid, nowMs);
|
||||
const signatureValid = verify(
|
||||
"RSA-SHA256",
|
||||
Buffer.from(`${encodedHeader}.${encodedPayload}`, "utf8"),
|
||||
key,
|
||||
Buffer.from(encodedSignature, "base64url")
|
||||
);
|
||||
if (!signatureValid) {
|
||||
throw new GoogleIdTokenError("bad_signature");
|
||||
}
|
||||
|
||||
const claims = decodeSegment(encodedPayload);
|
||||
const nowSeconds = Math.floor(nowMs / 1000);
|
||||
|
||||
if (typeof claims.iss !== "string" || !(GOOGLE_ISSUERS as readonly string[]).includes(claims.iss)) {
|
||||
throw new GoogleIdTokenError("bad_issuer");
|
||||
}
|
||||
const aud = claims.aud;
|
||||
const audienceOk =
|
||||
typeof aud === "string"
|
||||
? aud === expected.clientId
|
||||
: Array.isArray(aud) && aud.includes(expected.clientId) && claims.azp === expected.clientId;
|
||||
if (!audienceOk) {
|
||||
throw new GoogleIdTokenError("bad_audience");
|
||||
}
|
||||
if (typeof claims.exp !== "number" || claims.exp + CLOCK_LEEWAY_SECONDS <= nowSeconds) {
|
||||
throw new GoogleIdTokenError("expired");
|
||||
}
|
||||
if (typeof claims.iat !== "number" || claims.iat - CLOCK_LEEWAY_SECONDS > nowSeconds) {
|
||||
throw new GoogleIdTokenError("not_yet_valid");
|
||||
}
|
||||
if (claims.nbf !== undefined && (typeof claims.nbf !== "number" || claims.nbf - CLOCK_LEEWAY_SECONDS > nowSeconds)) {
|
||||
throw new GoogleIdTokenError("not_yet_valid");
|
||||
}
|
||||
if (typeof claims.nonce !== "string" || claims.nonce !== expected.nonce) {
|
||||
throw new GoogleIdTokenError("bad_nonce");
|
||||
}
|
||||
if (typeof claims.sub !== "string" || claims.sub === "" || claims.sub.length > 255) {
|
||||
throw new GoogleIdTokenError("missing_subject");
|
||||
}
|
||||
if (typeof claims.email !== "string" || claims.email === "") {
|
||||
throw new GoogleIdTokenError("email_missing");
|
||||
}
|
||||
if (claims.email_verified !== true && claims.email_verified !== "true") {
|
||||
throw new GoogleIdTokenError("email_not_verified");
|
||||
}
|
||||
|
||||
const identity: GoogleIdentityClaims = { sub: claims.sub, email: claims.email };
|
||||
if (typeof claims.name === "string" && claims.name !== "") identity.name = claims.name;
|
||||
if (typeof claims.picture === "string" && claims.picture !== "") identity.picture = claims.picture;
|
||||
if (typeof claims.hd === "string" && claims.hd !== "") identity.hd = claims.hd;
|
||||
return identity;
|
||||
}
|
||||
|
||||
/**
|
||||
* The PKCE verifier and the nonce of one authorization request, derived from
|
||||
* the request's state `jti` and Heimdall's signing key instead of stored. The
|
||||
* state token travels through the browser and carries the `jti`, so whoever
|
||||
* can read the redirect can read the `jti`; they cannot compute an Ed25519
|
||||
* signature over it. The signature is deterministic, so start and callback
|
||||
* derive the same pair, and nothing is persisted between them.
|
||||
*/
|
||||
export function deriveOidcSecrets(stateJti: string, signingKey: KeyObject): {
|
||||
codeVerifier: string;
|
||||
codeChallenge: string;
|
||||
nonce: string;
|
||||
} {
|
||||
const derive = (label: string): string =>
|
||||
createHash("sha256")
|
||||
.update(sign(null, Buffer.from(`heimdall:oidc:${label}:${stateJti}`, "utf8"), signingKey))
|
||||
.digest("base64url");
|
||||
const codeVerifier = derive("pkce-verifier");
|
||||
return {
|
||||
codeVerifier,
|
||||
codeChallenge: createHash("sha256").update(codeVerifier, "ascii").digest("base64url"),
|
||||
nonce: derive("nonce"),
|
||||
};
|
||||
}
|
||||
43
src/index.ts
43
src/index.ts
|
|
@ -6,14 +6,16 @@ import { publishHeimdallOdinState } from "./odin-publication.js";
|
|||
import { startHeimdallPrivateCommandPlane } from "./private-command-plane.js";
|
||||
import type { CultNetOperationServer } from "cultnet-ts";
|
||||
import { createHeimdallRuntimePulse, buildHeimdallHealthDetail, publishHeimdallVerseState } from "./verse-state.js";
|
||||
import {
|
||||
buildPresenceStatement,
|
||||
PublisherSequence,
|
||||
readRuntimeBundleFacts,
|
||||
type RuntimeBundleFacts,
|
||||
} from "./runtime-presence.js";
|
||||
import { openPresenceAuthority } from "./runtime-presence.js";
|
||||
|
||||
const config = loadConfig();
|
||||
// Under Idunn the launch's presence keys, bundle facts and publisher sequence
|
||||
// open here, before anything listens. A launch-contract fault throws, uncaught,
|
||||
// and the process exits non-zero with no listener: Idunn fails Warming in
|
||||
// seconds rather than waiting on a candidate that can never sign.
|
||||
const presenceAuthority = config.idunnRuntimeBundlePath
|
||||
? await openPresenceAuthority(config)
|
||||
: undefined;
|
||||
const app = await buildApp({ config });
|
||||
const versePulseIntervalMs = 60_000;
|
||||
const healthPulseIntervalMs = 10_000;
|
||||
|
|
@ -69,14 +71,6 @@ async function publishVerseState(): Promise<void> {
|
|||
await publishHeimdallOdinState(config, pulse);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read once and keep: the bundle is Idunn's immutable record of this launch and
|
||||
* cannot change while the process lives, so re-reading it every pulse would be
|
||||
* work that can only ever return the same answer or fail.
|
||||
*/
|
||||
let runtimeBundleFacts: RuntimeBundleFacts | undefined;
|
||||
const presenceSequence = new PublisherSequence();
|
||||
|
||||
async function publishHealthState(): Promise<void> {
|
||||
const pulse = createHeimdallRuntimePulse(config);
|
||||
|
||||
|
|
@ -94,30 +88,17 @@ async function publishHealthState(): Promise<void> {
|
|||
? buildHeimdallHealthDetail(config, pulse)
|
||||
: `Heimdall candidate warming; ${lease.reason}`;
|
||||
|
||||
if (!config.idunnRuntimeBundlePath) {
|
||||
if (!presenceAuthority) {
|
||||
// Outside Idunn there is no launch to attest and nothing that admits the
|
||||
// statement; publishing is simply not part of that world.
|
||||
return;
|
||||
}
|
||||
runtimeBundleFacts ??= await readRuntimeBundleFacts(config.idunnRuntimeBundlePath);
|
||||
|
||||
const observedAtUnixMillis = Date.parse(pulse.updatedAt);
|
||||
const presence = await buildPresenceStatement({
|
||||
bundle: runtimeBundleFacts,
|
||||
state: lease.mayWrite ? "active" : "warming",
|
||||
detail,
|
||||
boundEndpoint: `http://${config.host}:${config.port}`,
|
||||
// A warming candidate holds no lease and must not claim one; the contract
|
||||
// refuses the pair, and Idunn needs the warming statement to promote it.
|
||||
writeLeaseSha256: null,
|
||||
observedAtUnixMillis,
|
||||
publisherSequence: presenceSequence.next(observedAtUnixMillis),
|
||||
providerHealthIdentityPath: config.providerHealthIdentityPath,
|
||||
});
|
||||
const state = lease.mayWrite ? "active" : "warming";
|
||||
const presence = presenceAuthority.sign(state, detail, Date.parse(pulse.updatedAt));
|
||||
|
||||
await publishIdunnRudpHealth(config, {
|
||||
daemonId: config.daemonId,
|
||||
state: lease.mayWrite ? "active" : "warming",
|
||||
state,
|
||||
detail,
|
||||
observedAt: pulse.updatedAt,
|
||||
presence,
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
import { type HeimdallConfig } from "./config.js";
|
||||
import { type Provider } from "./contracts.js";
|
||||
import { type TokenCustody } from "./custody.js";
|
||||
import { type OAuthProviderRuntime, type OAuthRuntimeRegistry, ProviderResponseError } from "./oauth.js";
|
||||
import { type ExpiringTokenSet, type OAuthProviderRuntime, type OAuthRuntimeRegistry, ProviderResponseError } from "./oauth.js";
|
||||
import { providerCatalog } from "./providers.js";
|
||||
import { type HeimdallStore } from "./store/index.js";
|
||||
import { type CredentialDecision, type StoredLinkedIdentity } from "./store/types.js";
|
||||
|
|
@ -16,6 +16,14 @@ export const MANAGED_CREDENTIAL_REFRESH_SKEW_MS = 5 * 60 * 1000;
|
|||
*/
|
||||
export const MANAGED_CREDENTIAL_REFRESH_TIMEOUT_MS = 10_000;
|
||||
|
||||
/**
|
||||
* After a refresh attempt fails or times out, no process presents the row's
|
||||
* refresh token again until this long has passed (the failure is recorded on
|
||||
* the row, read under the lock). A provider that rotates may have consumed the
|
||||
* token before the attempt was aborted, and presenting it again reads as theft.
|
||||
*/
|
||||
export const MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS = 60 * 1000;
|
||||
|
||||
export interface ManagedCredentialContext {
|
||||
config: HeimdallConfig;
|
||||
store: HeimdallStore;
|
||||
|
|
@ -55,6 +63,17 @@ function dueForRefresh(identity: StoredLinkedIdentity, runtime: OAuthProviderRun
|
|||
return Date.parse(identity.tokenExpiresAt) - now <= MANAGED_CREDENTIAL_REFRESH_SKEW_MS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether a failure stamped `failedAt` still holds this clock off. A stamp from
|
||||
* a writer whose clock runs ahead reads as the future; one this far ahead or
|
||||
* more is skew, not a fresh failure, so the wait stays bounded at twice the
|
||||
* backoff.
|
||||
*/
|
||||
function withinBackoff(failedAt: string, now: number): boolean {
|
||||
const elapsed = now - Date.parse(failedAt);
|
||||
return elapsed > -MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS && elapsed < MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS;
|
||||
}
|
||||
|
||||
function withoutTokens(identity: StoredLinkedIdentity): StoredLinkedIdentity {
|
||||
const { accessTokenEncrypted: _a, refreshTokenEncrypted: _r, tokenExpiresAt: _e, ...rest } = identity;
|
||||
return rest;
|
||||
|
|
@ -68,10 +87,8 @@ function withoutTokens(identity: StoredLinkedIdentity): StoredLinkedIdentity {
|
|||
* attempt is in flight join it and receive its outcome, success or failure.
|
||||
* The entry lives exactly as long as the attempt: a later request retries.
|
||||
*
|
||||
* Known residual risk (docs/service-contract.md): one presentation per
|
||||
* process per burst, so N processes may present one token N times. The
|
||||
* cross-process failed-refresh marker that would close it is
|
||||
* joystick:follow_up:cross-process-failed-refresh-marker.
|
||||
* Across processes the row owns it: a failed attempt leaves a marker on the
|
||||
* row, and a process that takes the lock inside the backoff presents nothing.
|
||||
*/
|
||||
const refreshesInFlight = new WeakMap<HeimdallStore, Map<string, Promise<ManagedCredentialOutcome>>>();
|
||||
|
||||
|
|
@ -120,28 +137,8 @@ async function refreshUnderLock(
|
|||
const runtime = ctx.oauthRuntimes[provider];
|
||||
|
||||
let revocation: ManagedCredentialRevocationReason | undefined;
|
||||
const decide = async (locked: StoredLinkedIdentity): Promise<CredentialDecision> => {
|
||||
if (!locked.accessTokenEncrypted || !dueForRefresh(locked, runtime, clock())) {
|
||||
return { kind: "keep" };
|
||||
}
|
||||
const updatedAt = new Date(clock()).toISOString();
|
||||
const refreshToken = ctx.tokenCustody.decrypt(locked.refreshTokenEncrypted!);
|
||||
|
||||
let refreshed;
|
||||
try {
|
||||
refreshed = await runtime.refreshAccessToken!({
|
||||
config: ctx.config,
|
||||
refreshToken,
|
||||
signal: AbortSignal.timeout(ctx.timeoutMs ?? MANAGED_CREDENTIAL_REFRESH_TIMEOUT_MS),
|
||||
});
|
||||
} catch (error) {
|
||||
if (error instanceof ProviderResponseError && error.oauthError === "invalid_grant") {
|
||||
revocation = "provider_revoked";
|
||||
return { kind: "revoke", updatedAt };
|
||||
}
|
||||
throw new ManagedCredentialRefreshFailed(provider);
|
||||
}
|
||||
|
||||
let failed = false;
|
||||
const rotation = (locked: StoredLinkedIdentity, refreshed: ExpiringTokenSet, updatedAt: string): CredentialDecision => {
|
||||
let refreshTokenEncrypted: string;
|
||||
if (refreshed.refreshToken) {
|
||||
refreshTokenEncrypted = ctx.tokenCustody.encrypt(refreshed.refreshToken);
|
||||
|
|
@ -162,9 +159,47 @@ async function refreshUnderLock(
|
|||
tokenExpiresAt: refreshed.expiresAt,
|
||||
scopes: refreshed.scope.length ? refreshed.scope : locked.scopes,
|
||||
updatedAt,
|
||||
consumedRefreshToken: providerCatalog[provider].rotatesRefreshTokens,
|
||||
};
|
||||
};
|
||||
|
||||
const decide = async (locked: StoredLinkedIdentity): Promise<CredentialDecision> => {
|
||||
if (!locked.accessTokenEncrypted || !dueForRefresh(locked, runtime, clock())) {
|
||||
return { kind: "keep" };
|
||||
}
|
||||
if (locked.refreshFailedAt && withinBackoff(locked.refreshFailedAt, clock())) {
|
||||
failed = true;
|
||||
return { kind: "keep" };
|
||||
}
|
||||
const refreshToken = ctx.tokenCustody.decrypt(locked.refreshTokenEncrypted!);
|
||||
|
||||
let refreshed;
|
||||
try {
|
||||
refreshed = await runtime.refreshAccessToken!({
|
||||
config: ctx.config,
|
||||
refreshToken,
|
||||
signal: AbortSignal.timeout(ctx.timeoutMs ?? MANAGED_CREDENTIAL_REFRESH_TIMEOUT_MS),
|
||||
});
|
||||
} catch (error) {
|
||||
if (error instanceof ProviderResponseError && error.oauthError === "invalid_grant") {
|
||||
revocation = "provider_revoked";
|
||||
return { kind: "revoke", updatedAt: new Date(clock()).toISOString() };
|
||||
}
|
||||
failed = true;
|
||||
return { kind: "failed", failedAt: new Date(clock()).toISOString() };
|
||||
}
|
||||
|
||||
// The provider has answered, and may have consumed the token: from here a throw must still leave the marker, which
|
||||
// a rolled-back transaction would not (the store writes it on its own for a rotation it could not commit).
|
||||
const answeredAt = new Date(clock()).toISOString();
|
||||
try {
|
||||
return rotation(locked, refreshed, answeredAt);
|
||||
} catch {
|
||||
failed = true;
|
||||
return { kind: "failed", failedAt: new Date(clock()).toISOString() };
|
||||
}
|
||||
};
|
||||
|
||||
const committed = await ctx.store.updateLinkedIdentityCredential(snapshot.id, decide);
|
||||
if (revocation) {
|
||||
await ctx.store.createAuditEvent({
|
||||
|
|
@ -174,6 +209,9 @@ async function refreshUnderLock(
|
|||
createdAt: new Date(clock()).toISOString(),
|
||||
});
|
||||
}
|
||||
if (failed) {
|
||||
throw new ManagedCredentialRefreshFailed(provider);
|
||||
}
|
||||
if (!committed) {
|
||||
return { kind: "revoked", identity: withoutTokens(snapshot) };
|
||||
}
|
||||
|
|
|
|||
50
src/oauth.ts
50
src/oauth.ts
|
|
@ -7,6 +7,7 @@ import {
|
|||
} from "./contracts.js";
|
||||
import { type HeimdallConfig } from "./config.js";
|
||||
import { entitlementFacts } from "./facts.js";
|
||||
import { verifyGoogleIdToken } from "./google-oidc.js";
|
||||
import { providerCatalog } from "./providers.js";
|
||||
import { type CreateEntitlementSnapshotInput } from "./store/types.js";
|
||||
|
||||
|
|
@ -49,13 +50,22 @@ export interface OAuthProviderRuntime {
|
|||
config: HeimdallConfig;
|
||||
code: string;
|
||||
redirectUri: string;
|
||||
/** PKCE verifier of an OIDC provider's request (RFC 7636). */
|
||||
codeVerifier?: string;
|
||||
}): Promise<OAuthTokenSet>;
|
||||
refreshAccessToken?(options: {
|
||||
config: HeimdallConfig;
|
||||
refreshToken: string;
|
||||
signal?: AbortSignal;
|
||||
}): Promise<ExpiringTokenSet>;
|
||||
resolveIdentity(options: { config: HeimdallConfig; accessToken: string }): Promise<ResolvedIdentity>;
|
||||
resolveIdentity(options: {
|
||||
config: HeimdallConfig;
|
||||
accessToken: string;
|
||||
/** The exchange's answer: an OIDC provider's identity is its id_token, not a lookup with the access token. */
|
||||
tokenSet?: OAuthTokenSet;
|
||||
/** The nonce this authorization request carried; an OIDC provider's id_token must echo it. */
|
||||
oidcNonce?: string;
|
||||
}): Promise<ResolvedIdentity>;
|
||||
evaluateEntitlements(options: {
|
||||
config: HeimdallConfig;
|
||||
callback: OAuthCallbackContext;
|
||||
|
|
@ -144,7 +154,7 @@ function normalizeScopes(scope: string | string[] | undefined): string[] {
|
|||
}
|
||||
|
||||
export type TokenGrant =
|
||||
| { grant_type: "authorization_code"; code: string; redirect_uri: string }
|
||||
| { grant_type: "authorization_code"; code: string; redirect_uri: string; code_verifier?: string }
|
||||
| { grant_type: "refresh_token"; refresh_token: string };
|
||||
|
||||
/**
|
||||
|
|
@ -249,6 +259,7 @@ function sharedRuntimeExchange(provider: Provider): OAuthProviderRuntime["exchan
|
|||
grant_type: "authorization_code",
|
||||
code: options.code,
|
||||
redirect_uri: options.redirectUri,
|
||||
...(options.codeVerifier !== undefined ? { code_verifier: options.codeVerifier } : {}),
|
||||
});
|
||||
// A rotating provider's refresh token is the only way back to the
|
||||
// credential: a grant that arrives without one would be stored as a row
|
||||
|
|
@ -527,6 +538,31 @@ async function resolveYouTubeIdentity(options: { accessToken: string }): Promise
|
|||
return identity;
|
||||
}
|
||||
|
||||
async function resolveGoogleIdentity(options: {
|
||||
config: HeimdallConfig;
|
||||
tokenSet?: OAuthTokenSet;
|
||||
oidcNonce?: string;
|
||||
}): Promise<ResolvedIdentity> {
|
||||
const clientId = options.config.providers.google.clientId;
|
||||
const idToken = options.tokenSet?.raw.id_token;
|
||||
if (!clientId || typeof idToken !== "string" || !options.oidcNonce) {
|
||||
throw new Error("Google sign-in needs a client id, an id_token and the request's nonce.");
|
||||
}
|
||||
const claims = await verifyGoogleIdToken(idToken, { clientId, nonce: options.oidcNonce });
|
||||
const identity: ResolvedIdentity = {
|
||||
provider: "google",
|
||||
providerUserId: claims.sub,
|
||||
username: claims.email,
|
||||
displayName: claims.name ?? claims.email,
|
||||
primaryEmail: claims.email,
|
||||
profile: { sub: claims.sub, email: claims.email, email_verified: true, name: claims.name, picture: claims.picture, hd: claims.hd },
|
||||
};
|
||||
if (claims.picture) {
|
||||
identity.avatarUrl = claims.picture;
|
||||
}
|
||||
return identity;
|
||||
}
|
||||
|
||||
async function resolveSpotifyIdentity(options: { accessToken: string }): Promise<ResolvedIdentity> {
|
||||
const profile = await fetchJson<{
|
||||
id?: string;
|
||||
|
|
@ -945,6 +981,15 @@ const youtubeRuntime: OAuthProviderRuntime = {
|
|||
},
|
||||
};
|
||||
|
||||
const googleRuntime: OAuthProviderRuntime = {
|
||||
exchangeAuthorizationCode: sharedRuntimeExchange("google"),
|
||||
refreshAccessToken: sharedRuntimeRefresh("google"),
|
||||
resolveIdentity: resolveGoogleIdentity,
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
|
||||
const spotifyRuntime: OAuthProviderRuntime = {
|
||||
exchangeAuthorizationCode: sharedRuntimeExchange("spotify"),
|
||||
refreshAccessToken: sharedRuntimeRefresh("spotify"),
|
||||
|
|
@ -986,5 +1031,6 @@ export function createOAuthRuntimeRegistry(): OAuthRuntimeRegistry {
|
|||
youtube: youtubeRuntime,
|
||||
spotify: spotifyRuntime,
|
||||
joystick: joystickRuntime,
|
||||
google: googleRuntime,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -305,7 +305,6 @@ async function beginAuth(
|
|||
throw new Error(String(startPayload.detail ?? startPayload.error ?? "OAuth start was denied."));
|
||||
}
|
||||
const authorizationUrl = String(startPayload.authorizationUrl ?? "");
|
||||
const authorizationOrigin = new URL(authorizationUrl).origin;
|
||||
return {
|
||||
status: "accepted",
|
||||
payloadSchema: "heimdall.auth_begin_receipt.v1",
|
||||
|
|
@ -316,7 +315,7 @@ async function beginAuth(
|
|||
expiresAt: attempt.expiresAt,
|
||||
navigation: {
|
||||
url: authorizationUrl,
|
||||
allowedOrigins: [authorizationOrigin, new URL(config.publicBaseUrl).origin],
|
||||
allowedOrigins: [new URL(config.publicBaseUrl).origin],
|
||||
},
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import {
|
|||
sign,
|
||||
type KeyObject,
|
||||
} from "node:crypto";
|
||||
import { readFileSync } from "node:fs";
|
||||
import { closeSync, fstatSync, readSync } from "node:fs";
|
||||
import { chmod, readFile } from "node:fs/promises";
|
||||
import { SingleFileMessagePackBackingStore, type CultCacheEnvelope } from "@gamecult/cultcache-ts";
|
||||
import { readPrivateStoreRecord } from "./idunn-store.js";
|
||||
|
|
@ -71,7 +71,7 @@ export async function openOrEnrollProviderHealthIdentity(path: string): Promise<
|
|||
if (existing.length !== 1) {
|
||||
throw new Error("Provider-health identity store must contain exactly one record.");
|
||||
}
|
||||
return decodePrivateIdentity(existing[0]!.payload, await readMachineId());
|
||||
return decodePrivateIdentity(existing[0]!.payload, await readMachineId(), "bin");
|
||||
}
|
||||
|
||||
const PRESENCE_IDENTITY_FD_NAME = "gamecult-runtime-presence-identity";
|
||||
|
|
@ -124,7 +124,8 @@ export function passedDescriptor(
|
|||
*/
|
||||
export async function openProviderHealthIdentity(
|
||||
path: string,
|
||||
env: NodeJS.ProcessEnv = process.env
|
||||
env: NodeJS.ProcessEnv = process.env,
|
||||
machineId: () => Promise<string> = readMachineId
|
||||
): Promise<PrivateIdentity> {
|
||||
const descriptor = passedDescriptor(PRESENCE_IDENTITY_FD_NAME, env);
|
||||
if (descriptor === undefined) {
|
||||
|
|
@ -140,11 +141,33 @@ export async function openProviderHealthIdentity(
|
|||
}
|
||||
|
||||
const payload = readPrivateStoreRecord(
|
||||
readFileSync(descriptor),
|
||||
readPassedDescriptor(descriptor),
|
||||
"Idunn runtime presence identity"
|
||||
);
|
||||
|
||||
return decodePrivateIdentity(payload, await readMachineId());
|
||||
// The descriptor's writer is the Rust owner, whose key fields are integer arrays.
|
||||
return decodePrivateIdentity(payload, await machineId(), "int-array");
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a passed descriptor whole, from offset 0, and close it. A descriptor is
|
||||
* a one-shot input: reading it again starts at the offset the last read left,
|
||||
* which is the end, so the owner reads once at open and keeps what it decoded.
|
||||
*/
|
||||
export function readPassedDescriptor(descriptor: number): Buffer {
|
||||
try {
|
||||
const size = fstatSync(descriptor).size;
|
||||
const bytes = Buffer.alloc(size);
|
||||
let read = 0;
|
||||
while (read < size) {
|
||||
const count = readSync(descriptor, bytes, read, size - read, read);
|
||||
if (count === 0) break;
|
||||
read += count;
|
||||
}
|
||||
return bytes.subarray(0, read);
|
||||
} finally {
|
||||
closeSync(descriptor);
|
||||
}
|
||||
}
|
||||
|
||||
export function signProviderHealthPayload(identity: PrivateIdentity, payload: Uint8Array): Uint8Array {
|
||||
|
|
@ -176,23 +199,58 @@ export function providerHealthPublicIdentity(identity: PrivateIdentity): {
|
|||
return { identityId: identity.identityId, publicKeyHex: Buffer.from(identity.publicKey).toString("hex") };
|
||||
}
|
||||
|
||||
function decodePrivateIdentity(payload: Uint8Array, machineId: string): PrivateIdentity {
|
||||
/**
|
||||
* Which writer produced the record. The self-enrolling store this process
|
||||
* writes keeps key fields as MessagePack bin; the Rust owner (cultnet-rs
|
||||
* service_identity.rs) serialises a Vec<u8> without serde_bytes, so its key
|
||||
* fields are arrays of integers. Each source is read in its own shape and the
|
||||
* other is refused.
|
||||
*/
|
||||
type KeyShape = "bin" | "int-array";
|
||||
|
||||
function keyBytes(value: unknown, shape: KeyShape, field: string): Uint8Array {
|
||||
const bytes =
|
||||
shape === "bin"
|
||||
? value instanceof Uint8Array
|
||||
? value
|
||||
: undefined
|
||||
: Array.isArray(value) &&
|
||||
value.every((byte) => typeof byte === "number" && Number.isInteger(byte) && byte >= 0 && byte <= 255)
|
||||
? Uint8Array.from(value as number[])
|
||||
: undefined;
|
||||
if (bytes === undefined || bytes.length !== 32) {
|
||||
throw new Error(
|
||||
`Provider-health identity key shape check failed: ${field} is not a 32-byte ${shape === "bin" ? "binary" : "integer-array"} key field.`
|
||||
);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
|
||||
function decodePrivateIdentity(payload: Uint8Array, machineId: string, shape: KeyShape): PrivateIdentity {
|
||||
const value = decode(payload);
|
||||
if (!Array.isArray(value) || value.length !== 10) {
|
||||
throw new Error("Provider-health identity payload is malformed.");
|
||||
throw new Error("Provider-health identity schema check failed: payload is not a 10-field record.");
|
||||
}
|
||||
const [schema, identityId, publicKey, protectedSeed, protector, binding, version] = value;
|
||||
if (
|
||||
schema !== PRIVATE_SCHEMA ||
|
||||
typeof identityId !== "string" ||
|
||||
!(publicKey instanceof Uint8Array) || publicKey.length !== 32 ||
|
||||
!(protectedSeed instanceof Uint8Array) || protectedSeed.length !== 32 ||
|
||||
protector !== "linux_file_mode_machine_id_binding" ||
|
||||
binding !== protectorBinding(machineId) ||
|
||||
version !== "v1" ||
|
||||
identityId !== deriveIdentityId(publicKey)
|
||||
) {
|
||||
throw new Error("Provider-health identity does not belong to this host or profile.");
|
||||
const [schema, identityId, publicKeyField, protectedSeedField, protector, binding, version] = value;
|
||||
if (schema !== PRIVATE_SCHEMA) {
|
||||
throw new Error("Provider-health identity schema check failed: unexpected schema id.");
|
||||
}
|
||||
if (typeof identityId !== "string") {
|
||||
throw new Error("Provider-health identity id check failed: id is not a string.");
|
||||
}
|
||||
const publicKey = keyBytes(publicKeyField, shape, "public key");
|
||||
const protectedSeed = keyBytes(protectedSeedField, shape, "protected seed");
|
||||
if (protector !== "linux_file_mode_machine_id_binding") {
|
||||
throw new Error("Provider-health identity protector check failed: unexpected protector.");
|
||||
}
|
||||
if (binding !== protectorBinding(machineId)) {
|
||||
throw new Error("Provider-health identity binding check failed: not bound to this host's machine id.");
|
||||
}
|
||||
if (version !== "v1") {
|
||||
throw new Error("Provider-health identity version check failed: unexpected version.");
|
||||
}
|
||||
if (identityId !== deriveIdentityId(publicKey)) {
|
||||
throw new Error("Provider-health identity id check failed: id does not derive from the public key.");
|
||||
}
|
||||
const seed = xorSeed(protectedSeed, binding);
|
||||
const privateKey = privateKeyFromSeed(seed);
|
||||
|
|
|
|||
|
|
@ -22,6 +22,24 @@ export interface ProviderDescriptor {
|
|||
clientIdEnv: string;
|
||||
clientSecretEnv: string;
|
||||
additionalAuthorizationParams?: Record<string, string>;
|
||||
/**
|
||||
* The authorize parameters that make this provider ask the person again
|
||||
* (a sign_in step-up). Absent means the provider has no such parameter, and
|
||||
* a step-up start for it is refused rather than passed without the step.
|
||||
*/
|
||||
stepUpAuthorizationParams?: Record<string, string>;
|
||||
/**
|
||||
* What a callback does with a (provider, subject) no account holds yet.
|
||||
* `mints_account` is every provider's behaviour before Google: the first
|
||||
* login makes an account. `requires_link` never mints: the identity
|
||||
* attaches only to the account a verified link start bound
|
||||
* (`initiator_account_id`), otherwise the callback refuses. Google is a second
|
||||
* door into a person who already has an account, so a first Google login
|
||||
* must not make a stranger of them.
|
||||
*/
|
||||
firstLogin: "mints_account" | "requires_link";
|
||||
/** OpenID Connect: the callback verifies an id_token and uses PKCE (S256) and a nonce. */
|
||||
oidc?: true;
|
||||
}
|
||||
|
||||
export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
||||
|
|
@ -35,6 +53,7 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
defaultAccessTokenLifetimeSeconds: 3600,
|
||||
defaultScopes: ["identify", "guilds.members.read"],
|
||||
roles: ["identity", "entitlement"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_DISCORD_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_DISCORD_CLIENT_SECRET_FILE",
|
||||
},
|
||||
|
|
@ -48,6 +67,7 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
defaultAccessTokenLifetimeSeconds: 3600,
|
||||
defaultScopes: ["identity", "identity[email]"],
|
||||
roles: ["identity", "entitlement"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_PATREON_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_PATREON_CLIENT_SECRET_FILE",
|
||||
},
|
||||
|
|
@ -61,6 +81,7 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
defaultAccessTokenLifetimeSeconds: 3600,
|
||||
defaultScopes: ["read:user", "user:email"],
|
||||
roles: ["identity", "managed_credential"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_GITHUB_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_GITHUB_CLIENT_SECRET_FILE",
|
||||
},
|
||||
|
|
@ -74,8 +95,11 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
defaultAccessTokenLifetimeSeconds: 3600,
|
||||
defaultScopes: ["user:read:email"],
|
||||
roles: ["identity", "managed_credential"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_TWITCH_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_TWITCH_CLIENT_SECRET_FILE",
|
||||
// Twitch force_verify re-shows the authorize page; it is not a password prompt.
|
||||
stepUpAuthorizationParams: { force_verify: "true" },
|
||||
},
|
||||
youtube: {
|
||||
key: "youtube",
|
||||
|
|
@ -92,6 +116,7 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
"https://www.googleapis.com/auth/youtube.readonly",
|
||||
],
|
||||
roles: ["identity", "managed_credential"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_YOUTUBE_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_YOUTUBE_CLIENT_SECRET_FILE",
|
||||
additionalAuthorizationParams: {
|
||||
|
|
@ -99,6 +124,8 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
include_granted_scopes: "true",
|
||||
prompt: "consent",
|
||||
},
|
||||
// login forces re-authentication; consent is kept because this provider always asks for it.
|
||||
stepUpAuthorizationParams: { prompt: "login consent" },
|
||||
},
|
||||
spotify: {
|
||||
key: "spotify",
|
||||
|
|
@ -114,9 +141,27 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
"user-modify-playback-state",
|
||||
],
|
||||
roles: ["identity", "managed_credential"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_SPOTIFY_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_SPOTIFY_CLIENT_SECRET_FILE",
|
||||
},
|
||||
google: {
|
||||
key: "google",
|
||||
displayName: "Google",
|
||||
authorizationEndpoint: "https://accounts.google.com/o/oauth2/v2/auth",
|
||||
tokenEndpoint: "https://oauth2.googleapis.com/token",
|
||||
tokenEndpointAuthMethod: "client_secret_post",
|
||||
rotatesRefreshTokens: false,
|
||||
defaultAccessTokenLifetimeSeconds: 3600,
|
||||
defaultScopes: ["openid", "email", "profile"],
|
||||
roles: ["identity"],
|
||||
firstLogin: "requires_link",
|
||||
oidc: true,
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_GOOGLE_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_GOOGLE_CLIENT_SECRET_FILE",
|
||||
additionalAuthorizationParams: { prompt: "select_account" },
|
||||
stepUpAuthorizationParams: { prompt: "login" },
|
||||
},
|
||||
joystick: {
|
||||
key: "joystick",
|
||||
displayName: "Joystick",
|
||||
|
|
@ -127,32 +172,59 @@ export const providerCatalog: Record<Provider, ProviderDescriptor> = {
|
|||
defaultAccessTokenLifetimeSeconds: 3600,
|
||||
defaultScopes: ["identity:read", "stream:read", "chat:read", "followers:read", "subscribers:read"],
|
||||
roles: ["identity", "managed_credential"],
|
||||
firstLogin: "mints_account",
|
||||
clientIdEnv: "GC_ACCESS_PROVIDER_JOYSTICK_CLIENT_ID",
|
||||
clientSecretEnv: "GC_ACCESS_PROVIDER_JOYSTICK_CLIENT_SECRET_FILE",
|
||||
},
|
||||
};
|
||||
|
||||
/** The scopes an authorization request carries: the caller's, or the provider's defaults. */
|
||||
export function authorizationScopes(provider: Provider, requested: readonly string[] | undefined): string[] {
|
||||
return requested?.length ? [...requested] : [...providerCatalog[provider].defaultScopes];
|
||||
}
|
||||
|
||||
export function buildAuthorizationUrl(options: {
|
||||
provider: Provider;
|
||||
clientId: string;
|
||||
redirectUri: string;
|
||||
state: string;
|
||||
requestedScopes: string[] | undefined;
|
||||
/** For an OIDC provider: the nonce, and the S256 challenge of the PKCE verifier. */
|
||||
oidc?: { nonce: string; codeChallenge: string };
|
||||
/** Ask the provider for a real re-authentication. Throws for a provider with no such parameter: never a silent pass. */
|
||||
stepUp?: boolean;
|
||||
}): string {
|
||||
const descriptor = providerCatalog[options.provider];
|
||||
const url = new URL(descriptor.authorizationEndpoint);
|
||||
const scopes = options.requestedScopes?.length ? options.requestedScopes : descriptor.defaultScopes;
|
||||
const scopes = authorizationScopes(options.provider, options.requestedScopes);
|
||||
|
||||
url.searchParams.set("client_id", options.clientId);
|
||||
url.searchParams.set("redirect_uri", options.redirectUri);
|
||||
url.searchParams.set("response_type", "code");
|
||||
url.searchParams.set("scope", scopes.join(" "));
|
||||
url.searchParams.set("state", options.state);
|
||||
if (descriptor.oidc) {
|
||||
if (!options.oidc) {
|
||||
throw new Error(`${descriptor.displayName} is an OIDC provider: its authorization URL needs a nonce and a PKCE challenge.`);
|
||||
}
|
||||
url.searchParams.set("nonce", options.oidc.nonce);
|
||||
url.searchParams.set("code_challenge", options.oidc.codeChallenge);
|
||||
url.searchParams.set("code_challenge_method", "S256");
|
||||
}
|
||||
|
||||
for (const [key, value] of Object.entries(descriptor.additionalAuthorizationParams ?? {})) {
|
||||
url.searchParams.set(key, value);
|
||||
}
|
||||
|
||||
if (options.stepUp) {
|
||||
if (!descriptor.stepUpAuthorizationParams) {
|
||||
throw new Error(`${descriptor.displayName} has no re-authentication parameter: a step-up cannot be honoured.`);
|
||||
}
|
||||
for (const [key, value] of Object.entries(descriptor.stepUpAuthorizationParams)) {
|
||||
url.searchParams.set(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
return url.toString();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@
|
|||
|
||||
import path from "node:path";
|
||||
import { createHash, createPrivateKey, type KeyObject } from "node:crypto";
|
||||
import { readFileSync } from "node:fs";
|
||||
|
||||
import { decode } from "@msgpack/msgpack";
|
||||
import {
|
||||
|
|
@ -33,11 +32,14 @@ import {
|
|||
type RuntimePresenceState,
|
||||
} from "cultnet-ts";
|
||||
|
||||
import type { HeimdallConfig } from "./config.js";
|
||||
import { readIdunnStoreRecord } from "./idunn-store.js";
|
||||
import {
|
||||
openProviderHealthIdentity,
|
||||
passedDescriptor,
|
||||
readPassedDescriptor,
|
||||
signWithIdentity,
|
||||
type PrivateIdentity,
|
||||
} from "./provider-health-identity.js";
|
||||
|
||||
const PKCS8_ED25519_SEED_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
|
||||
|
|
@ -176,29 +178,6 @@ export async function readRuntimeBundleFacts(bundlePath: string): Promise<Runtim
|
|||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Open the activation signing key Idunn passed as a descriptor.
|
||||
*
|
||||
* The credential is exactly 32 bytes: the raw Ed25519 seed. It is passed as a
|
||||
* parent-only descriptor and not as a path, so only the process Idunn launched
|
||||
* can produce this half of the proof.
|
||||
*/
|
||||
export function openActivationSigner(env: NodeJS.ProcessEnv = process.env): KeyObject | undefined {
|
||||
const descriptor = passedDescriptor(IDUNN_RUNTIME_ACTIVATION_CREDENTIAL_NAME, env);
|
||||
if (descriptor === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
const seed = readFileSync(descriptor);
|
||||
if (seed.length !== 32) {
|
||||
throw new Error("Idunn runtime activation credential is not a 32-byte seed");
|
||||
}
|
||||
return createPrivateKey({
|
||||
key: Buffer.concat([PKCS8_ED25519_SEED_PREFIX, seed]),
|
||||
format: "der",
|
||||
type: "pkcs8",
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The publisher sequence a process stamps on its presence statements.
|
||||
*
|
||||
|
|
@ -223,14 +202,14 @@ export class PublisherSequence {
|
|||
|
||||
export interface PresenceStatementInputs {
|
||||
bundle: RuntimeBundleFacts;
|
||||
identity: PrivateIdentity;
|
||||
activationKey: KeyObject;
|
||||
state: RuntimePresenceState;
|
||||
detail: string;
|
||||
boundEndpoint: string | null;
|
||||
writeLeaseSha256: string | null;
|
||||
observedAtUnixMillis: number;
|
||||
publisherSequence: number;
|
||||
providerHealthIdentityPath: string;
|
||||
env?: NodeJS.ProcessEnv;
|
||||
}
|
||||
|
||||
export interface PresenceStatement {
|
||||
|
|
@ -239,24 +218,14 @@ export interface PresenceStatement {
|
|||
}
|
||||
|
||||
/**
|
||||
* Build and dual-sign one presence statement.
|
||||
* Build and dual-sign one presence statement from keys and facts already open.
|
||||
*
|
||||
* Returns the target alongside the bytes because the document key must equal
|
||||
* the signed target; Odin refuses the pair when they differ, and that is the
|
||||
* one part of the envelope the transport cannot infer.
|
||||
*/
|
||||
export async function buildPresenceStatement(
|
||||
inputs: PresenceStatementInputs,
|
||||
): Promise<PresenceStatement> {
|
||||
const env = inputs.env ?? process.env;
|
||||
const activationKey = openActivationSigner(env);
|
||||
if (activationKey === undefined) {
|
||||
throw new Error(
|
||||
"Idunn passed no runtime activation credential, so this process cannot prove it is the " +
|
||||
"incarnation Idunn started",
|
||||
);
|
||||
}
|
||||
const identity = await openProviderHealthIdentity(inputs.providerHealthIdentityPath, env);
|
||||
export function buildPresenceStatement(inputs: PresenceStatementInputs): PresenceStatement {
|
||||
const { identity } = inputs;
|
||||
|
||||
const presence: RuntimePresenceHealth = {
|
||||
target: inputs.bundle.target,
|
||||
|
|
@ -284,7 +253,7 @@ export async function buildPresenceStatement(
|
|||
const proof = runtimePresenceProofPayload(presence);
|
||||
const signature = signWithIdentity(identity, runtimePresenceProviderSigningMessage(proof));
|
||||
const activationSignature = signWithIdentity(
|
||||
{ ...identity, privateKey: activationKey },
|
||||
{ ...identity, privateKey: inputs.activationKey },
|
||||
runtimePresenceActivationSigningMessage(proof),
|
||||
);
|
||||
|
||||
|
|
@ -293,3 +262,72 @@ export async function buildPresenceStatement(
|
|||
payload: encodeRuntimePresenceHealth(presence, signature, activationSignature),
|
||||
};
|
||||
}
|
||||
|
||||
export interface PresenceAuthority {
|
||||
sign(
|
||||
state: RuntimePresenceState,
|
||||
detail: string,
|
||||
observedAtUnixMillis: number,
|
||||
): PresenceStatement;
|
||||
}
|
||||
|
||||
/**
|
||||
* Open everything this launch's presence statements stand on, once, before the
|
||||
* process listens: Idunn's bundle facts, the activation seed and the presence
|
||||
* identity (each descriptor is read whole and closed), and the one publisher
|
||||
* sequence. It owns them for the life of the process; a pulse supplies only its
|
||||
* state, detail and observation time.
|
||||
*
|
||||
* A launch-contract fault (a missing or malformed bundle, descriptor or
|
||||
* identity) throws here, so the process exits before it accepts a request and
|
||||
* Idunn fails Warming at once, instead of a listener that can never sign.
|
||||
*/
|
||||
export async function openPresenceAuthority(
|
||||
config: Pick<HeimdallConfig, "idunnRuntimeBundlePath" | "host" | "port" | "providerHealthIdentityPath">,
|
||||
env: NodeJS.ProcessEnv = process.env,
|
||||
machineId?: () => Promise<string>,
|
||||
): Promise<PresenceAuthority> {
|
||||
if (!config.idunnRuntimeBundlePath) {
|
||||
throw new Error("no Idunn runtime bundle path: presence has no launch to attest");
|
||||
}
|
||||
const bundle = await readRuntimeBundleFacts(config.idunnRuntimeBundlePath);
|
||||
|
||||
const activationDescriptor = passedDescriptor(IDUNN_RUNTIME_ACTIVATION_CREDENTIAL_NAME, env);
|
||||
if (activationDescriptor === undefined) {
|
||||
throw new Error(
|
||||
"Idunn passed no runtime activation credential, so this process cannot prove it is the " +
|
||||
"incarnation Idunn started",
|
||||
);
|
||||
}
|
||||
const seed = readPassedDescriptor(activationDescriptor);
|
||||
if (seed.length !== 32) {
|
||||
throw new Error("Idunn runtime activation credential is not a 32-byte seed");
|
||||
}
|
||||
const activationKey = createPrivateKey({
|
||||
key: Buffer.concat([PKCS8_ED25519_SEED_PREFIX, seed]),
|
||||
format: "der",
|
||||
type: "pkcs8",
|
||||
});
|
||||
|
||||
const identity = await openProviderHealthIdentity(config.providerHealthIdentityPath, env, machineId);
|
||||
const boundEndpoint = `http://${config.host}:${config.port}`;
|
||||
const sequence = new PublisherSequence();
|
||||
|
||||
return {
|
||||
sign: (state, detail, observedAtUnixMillis) =>
|
||||
buildPresenceStatement({
|
||||
bundle,
|
||||
identity,
|
||||
activationKey,
|
||||
state,
|
||||
detail,
|
||||
boundEndpoint,
|
||||
// A warming candidate holds no lease and must not claim one; the
|
||||
// contract refuses the pair, and Idunn needs the warming statement to
|
||||
// promote it.
|
||||
writeLeaseSha256: null,
|
||||
observedAtUnixMillis,
|
||||
publisherSequence: sequence.next(observedAtUnixMillis),
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
|
|
|||
88
src/store/identity-move.ts
Normal file
88
src/store/identity-move.ts
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
import { type Provider } from "../contracts.js";
|
||||
import { type MoveIdentitiesInput, type StoredIdentityMove, type StoredLinkedIdentity } from "./types.js";
|
||||
|
||||
/** Everything a store read under its locks that the move rules decide on. */
|
||||
export interface MoveFacts {
|
||||
/** The identity_moves row already holding input.moveId. */
|
||||
existing: StoredIdentityMove | null;
|
||||
/** The move input.reversesMoveId names, and whether a reversal of it already exists. */
|
||||
forward: { move: StoredIdentityMove; reversed: boolean } | null;
|
||||
/** Every proof session still carries its sid, app, account and access revision and has not expired. */
|
||||
proofSessionsLive: boolean;
|
||||
sourceIdentities: readonly StoredLinkedIdentity[];
|
||||
destinationProviders: ReadonlySet<Provider>;
|
||||
/** An account with no identity and an unreversed move from it. */
|
||||
sourceIsAlias: boolean;
|
||||
destinationIsAlias: boolean;
|
||||
}
|
||||
|
||||
export type MoveDecision =
|
||||
| { kind: "replayed"; move: StoredIdentityMove }
|
||||
| { kind: "refused"; result: { kind: "move_id_conflict" | "proof_lapsed" | "already_moved" | "identity_not_found" | "identity_not_proved" | "not_reversible" } | { kind: "provider_conflict"; provider: Provider } }
|
||||
| { kind: "move"; identities: StoredLinkedIdentity[] };
|
||||
|
||||
/**
|
||||
* The one statement of the move rules, in the order they are decided. Both
|
||||
* stores gather MoveFacts under their locks and apply the answer, so memory
|
||||
* and Postgres cannot disagree about what a move refuses.
|
||||
*/
|
||||
export function decideMove(input: MoveIdentitiesInput, facts: MoveFacts): MoveDecision {
|
||||
const refuse = (kind: "move_id_conflict" | "proof_lapsed" | "already_moved" | "identity_not_found" | "identity_not_proved" | "not_reversible"): MoveDecision => ({ kind: "refused", result: { kind } });
|
||||
|
||||
const { existing } = facts;
|
||||
if (existing) {
|
||||
return existing.appSlug === input.appSlug &&
|
||||
existing.fromAccountId === input.fromAccountId &&
|
||||
existing.toAccountId === input.toAccountId &&
|
||||
existing.reversesMoveId === input.reversesMoveId
|
||||
? { kind: "replayed", move: existing }
|
||||
: refuse("move_id_conflict");
|
||||
}
|
||||
if (!facts.proofSessionsLive) return refuse("proof_lapsed");
|
||||
|
||||
const held = new Set(facts.sourceIdentities.map((identity) => identity.id));
|
||||
if (input.reversesMoveId !== undefined) {
|
||||
const forward = facts.forward;
|
||||
if (
|
||||
!forward ||
|
||||
forward.reversed ||
|
||||
forward.move.appSlug !== input.appSlug ||
|
||||
forward.move.reversesMoveId !== undefined ||
|
||||
forward.move.toAccountId !== input.fromAccountId ||
|
||||
forward.move.fromAccountId !== input.toAccountId ||
|
||||
!forward.move.moved.every((moved) => held.has(moved.id))
|
||||
) {
|
||||
return refuse("not_reversible");
|
||||
}
|
||||
} else if (facts.sourceIsAlias || facts.destinationIsAlias) {
|
||||
return refuse("already_moved");
|
||||
}
|
||||
|
||||
let chosen: StoredLinkedIdentity[];
|
||||
if (input.identityIds === "all") {
|
||||
chosen = [...facts.sourceIdentities];
|
||||
} else {
|
||||
if (!input.identityIds.every((id) => held.has(id))) return refuse("identity_not_found");
|
||||
const wanted = new Set(input.identityIds);
|
||||
chosen = facts.sourceIdentities.filter((identity) => wanted.has(identity.id));
|
||||
}
|
||||
if (chosen.length === 0) return refuse("identity_not_found");
|
||||
|
||||
if (input.covers !== "account") {
|
||||
const covered = new Set(input.covers);
|
||||
if (!chosen.every((identity) => covered.has(identity.id))) return refuse("identity_not_proved");
|
||||
}
|
||||
const clash = chosen.find((identity) => facts.destinationProviders.has(identity.provider));
|
||||
if (clash) return { kind: "refused", result: { kind: "provider_conflict", provider: clash.provider } };
|
||||
return { kind: "move", identities: chosen };
|
||||
}
|
||||
|
||||
/** The history a move writes about what it carried. */
|
||||
export function movedRecord(identities: readonly StoredLinkedIdentity[]): StoredIdentityMove["moved"] {
|
||||
return identities.map((identity) => ({
|
||||
id: identity.id,
|
||||
provider: identity.provider,
|
||||
providerUserId: identity.providerUserId,
|
||||
credentialStripped: identity.accessTokenEncrypted !== undefined || identity.refreshTokenEncrypted !== undefined,
|
||||
}));
|
||||
}
|
||||
|
|
@ -3,7 +3,14 @@ import { type AppSlug, type LinkedIdentityInput, type Provider } from "../contra
|
|||
import {
|
||||
type CreateAccountInput,
|
||||
type CreateAuthAttemptInput,
|
||||
type ClaimOAuthStateUseInput,
|
||||
OAUTH_STATE_PRUNE_BATCH,
|
||||
oauthStatePruneCutoffMs,
|
||||
type CreateAuthCompletionInput,
|
||||
type CreateConsentReceiptInput,
|
||||
type CreatePendingLinkInput,
|
||||
type StoredConsentReceipt,
|
||||
type StoredPendingLink,
|
||||
type CreateAuditEventInput,
|
||||
type CreateCapabilityGrantInput,
|
||||
type CredentialDecision,
|
||||
|
|
@ -11,6 +18,7 @@ import {
|
|||
type CreateSessionInput,
|
||||
type CreatePrivateCommandReceiptInput,
|
||||
type HeimdallStore,
|
||||
IdentityHeldElsewhereError,
|
||||
type StoredAccount,
|
||||
type StoredAuthAttempt,
|
||||
type StoredAuthCompletion,
|
||||
|
|
@ -18,8 +26,13 @@ import {
|
|||
type StoredLinkedIdentity,
|
||||
type StoredSession,
|
||||
type StoredPrivateCommandReceipt,
|
||||
type MoveIdentitiesInput,
|
||||
type MoveResult,
|
||||
type StoredIdentityMove,
|
||||
type UnlinkResult,
|
||||
type UpsertLinkedIdentityInput,
|
||||
} from "./types.js";
|
||||
import { decideMove, movedRecord } from "./identity-move.js";
|
||||
|
||||
function clone<T>(value: T): T {
|
||||
return JSON.parse(JSON.stringify(value)) as T;
|
||||
|
|
@ -47,9 +60,14 @@ export class InMemoryStore implements HeimdallStore {
|
|||
private readonly authAttempts = new Map<string, StoredAuthAttempt>();
|
||||
private readonly privateCommandReceipts = new Map<string, StoredPrivateCommandReceipt>();
|
||||
private readonly authCompletions = new Map<string, StoredAuthCompletion>();
|
||||
private readonly pendingLinks = new Map<string, StoredPendingLink>();
|
||||
private readonly authCompletionsByAttempt = new Map<string, string>();
|
||||
/** `${jti}:${phase}` -> the state's expiresAt. */
|
||||
private readonly oauthStateUses = new Map<string, string>();
|
||||
private readonly entitlementSnapshots = new Map<string, CreateEntitlementSnapshotInput>();
|
||||
private readonly auditEvents = new Map<string, CreateAuditEventInput>();
|
||||
private readonly consentReceipts: StoredConsentReceipt[] = [];
|
||||
private readonly identityMoves = new Map<string, StoredIdentityMove>();
|
||||
|
||||
async ensureSchema(): Promise<void> {
|
||||
return;
|
||||
|
|
@ -137,6 +155,9 @@ export class InMemoryStore implements HeimdallStore {
|
|||
const existing = [...this.linkedIdentities.values()].find(
|
||||
(identity) => identity.provider === input.provider && identity.providerUserId === input.providerUserId
|
||||
);
|
||||
if (existing && existing.accountId !== input.accountId) {
|
||||
throw new IdentityHeldElsewhereError();
|
||||
}
|
||||
const id = existing?.id ?? input.id ?? randomUUID();
|
||||
const linkedIdentity: StoredLinkedIdentity = {
|
||||
id,
|
||||
|
|
@ -177,6 +198,87 @@ export class InMemoryStore implements HeimdallStore {
|
|||
return clone(linkedIdentity);
|
||||
}
|
||||
|
||||
async unlinkLinkedIdentity(accountId: string, identityId: string): Promise<UnlinkResult> {
|
||||
const target = this.linkedIdentities.get(identityId);
|
||||
if (!target || target.accountId !== accountId) return { kind: "not_found" };
|
||||
const held = [...this.linkedIdentities.values()].filter((identity) => identity.accountId === accountId).length;
|
||||
if (held <= 1) return { kind: "last_identity" };
|
||||
this.linkedIdentities.delete(identityId);
|
||||
return { kind: "unlinked", identity: clone(target) };
|
||||
}
|
||||
|
||||
/** No await between the reads and the writes: the event loop is the lock. */
|
||||
async moveIdentities(input: MoveIdentitiesInput): Promise<MoveResult> {
|
||||
const at = Date.parse(input.at);
|
||||
const forwardMove = input.reversesMoveId !== undefined ? this.identityMoves.get(input.reversesMoveId) : undefined;
|
||||
const sourceIdentities = [...this.linkedIdentities.values()].filter((identity) => identity.accountId === input.fromAccountId);
|
||||
const destinationIdentities = [...this.linkedIdentities.values()].filter((identity) => identity.accountId === input.toAccountId);
|
||||
const decision = decideMove(input, {
|
||||
existing: this.identityMoves.get(input.moveId) ?? null,
|
||||
forward: forwardMove ? { move: forwardMove, reversed: this.isReversed(forwardMove.id) } : null,
|
||||
proofSessionsLive: input.proofSessions.every((proof) => {
|
||||
const session = this.sessions.get(proof.sessionId);
|
||||
return (
|
||||
session !== undefined &&
|
||||
session.appSlug === proof.appSlug &&
|
||||
session.accountId === proof.accountId &&
|
||||
session.accessRevision === proof.accessRevision &&
|
||||
Date.parse(session.expiresAt) > at
|
||||
);
|
||||
}),
|
||||
sourceIdentities: clone(sourceIdentities),
|
||||
destinationProviders: new Set(destinationIdentities.map((identity) => identity.provider)),
|
||||
sourceIsAlias: sourceIdentities.length === 0 && this.hasUnreversedMoveFrom(input.fromAccountId),
|
||||
destinationIsAlias: destinationIdentities.length === 0 && this.hasUnreversedMoveFrom(input.toAccountId),
|
||||
});
|
||||
if (decision.kind === "replayed") return { kind: "replayed", move: clone(decision.move) };
|
||||
if (decision.kind === "refused") return decision.result;
|
||||
|
||||
for (const identity of decision.identities) {
|
||||
const row = this.linkedIdentities.get(identity.id)!;
|
||||
row.accountId = input.toAccountId;
|
||||
row.updatedAt = input.at;
|
||||
delete row.accessTokenEncrypted;
|
||||
delete row.refreshTokenEncrypted;
|
||||
delete row.tokenExpiresAt;
|
||||
delete row.refreshFailedAt;
|
||||
}
|
||||
for (const session of this.sessions.values()) {
|
||||
if (session.accountId === input.fromAccountId && Date.parse(session.expiresAt) > at) {
|
||||
session.expiresAt = input.at;
|
||||
session.lastSeenAt = input.at;
|
||||
session.accessRevision += 1;
|
||||
}
|
||||
}
|
||||
for (const row of [...this.pendingLinks.values(), ...this.authCompletions.values()]) {
|
||||
if (row.accountId === input.fromAccountId && !row.consumedAt && Date.parse(row.expiresAt) > at) row.expiresAt = input.at;
|
||||
}
|
||||
const move: StoredIdentityMove = {
|
||||
id: input.moveId,
|
||||
appSlug: input.appSlug,
|
||||
fromAccountId: input.fromAccountId,
|
||||
toAccountId: input.toAccountId,
|
||||
...(input.reversesMoveId !== undefined ? { reversesMoveId: input.reversesMoveId } : {}),
|
||||
moved: movedRecord(decision.identities),
|
||||
proof: clone(input.proof),
|
||||
createdAt: input.at,
|
||||
};
|
||||
this.identityMoves.set(move.id, clone(move));
|
||||
return { kind: "moved", move };
|
||||
}
|
||||
|
||||
async findIdentityMove(moveId: string): Promise<StoredIdentityMove | null> {
|
||||
return clone(this.identityMoves.get(moveId) ?? null);
|
||||
}
|
||||
|
||||
private isReversed(moveId: string): boolean {
|
||||
return [...this.identityMoves.values()].some((move) => move.reversesMoveId === moveId);
|
||||
}
|
||||
|
||||
private hasUnreversedMoveFrom(accountId: string): boolean {
|
||||
return [...this.identityMoves.values()].some((move) => move.fromAccountId === accountId && !this.isReversed(move.id));
|
||||
}
|
||||
|
||||
async updateLinkedIdentityCredential(
|
||||
id: string,
|
||||
decide: (locked: StoredLinkedIdentity) => Promise<CredentialDecision>,
|
||||
|
|
@ -191,7 +293,13 @@ export class InMemoryStore implements HeimdallStore {
|
|||
if (decision.kind === "keep") {
|
||||
return clone(current);
|
||||
}
|
||||
if (decision.kind === "failed") {
|
||||
const marked: StoredLinkedIdentity = { ...current, refreshFailedAt: decision.failedAt };
|
||||
this.linkedIdentities.set(id, clone(marked));
|
||||
return clone(marked);
|
||||
}
|
||||
const next: StoredLinkedIdentity = { ...current, updatedAt: decision.updatedAt };
|
||||
delete next.refreshFailedAt;
|
||||
delete next.accessTokenEncrypted;
|
||||
delete next.refreshTokenEncrypted;
|
||||
delete next.tokenExpiresAt;
|
||||
|
|
@ -390,6 +498,7 @@ export class InMemoryStore implements HeimdallStore {
|
|||
accountId: input.accountId,
|
||||
sessionId: input.sessionId,
|
||||
returnTo: input.returnTo,
|
||||
...(input.targetId ? { targetId: input.targetId } : {}),
|
||||
createdAt: input.createdAt,
|
||||
expiresAt: input.expiresAt,
|
||||
payloadJson: clone(input.payloadJson),
|
||||
|
|
@ -402,6 +511,11 @@ export class InMemoryStore implements HeimdallStore {
|
|||
return clone(completion);
|
||||
}
|
||||
|
||||
async findAuthCompletion(appSlug: AppSlug, code: string): Promise<StoredAuthCompletion | null> {
|
||||
const completion = this.authCompletions.get(code);
|
||||
return completion && completion.appSlug === appSlug ? clone(completion) : null;
|
||||
}
|
||||
|
||||
async consumeAuthCompletion(appSlug: AppSlug, code: string, at: string): Promise<StoredAuthCompletion | null> {
|
||||
const completion = this.authCompletions.get(code);
|
||||
if (!completion) {
|
||||
|
|
@ -424,6 +538,42 @@ export class InMemoryStore implements HeimdallStore {
|
|||
return this.consumeAuthCompletion(appSlug, code, at);
|
||||
}
|
||||
|
||||
async createPendingLink(input: CreatePendingLinkInput): Promise<StoredPendingLink> {
|
||||
const link: StoredPendingLink = { id: randomUUID(), ...clone(input) };
|
||||
this.pendingLinks.set(link.id, clone(link));
|
||||
return clone(link);
|
||||
}
|
||||
|
||||
async consumePendingLink(appSlug: AppSlug, id: string, accountId: string, at: string): Promise<StoredPendingLink | null> {
|
||||
const link = this.pendingLinks.get(id);
|
||||
if (!link || link.appSlug !== appSlug || link.accountId !== accountId || link.expiresAt <= at || link.consumedAt) {
|
||||
return null;
|
||||
}
|
||||
link.consumedAt = at;
|
||||
return clone(link);
|
||||
}
|
||||
|
||||
async claimOAuthStateUse(input: ClaimOAuthStateUseInput): Promise<boolean> {
|
||||
const key = `${input.jti}:${input.phase}`;
|
||||
if (this.oauthStateUses.has(key)) {
|
||||
return false;
|
||||
}
|
||||
this.oauthStateUses.set(key, input.expiresAt);
|
||||
// A state is still accepted until its exp + skew; a record is kept a margin longer, and each
|
||||
// successful claim removes at most a batch of what is past that (oauthStatePruneCutoffMs), as
|
||||
// the Postgres store does.
|
||||
const cutoff = oauthStatePruneCutoffMs(Date.parse(input.usedAt));
|
||||
let pruned = 0;
|
||||
for (const [oldKey, expiresAt] of this.oauthStateUses) {
|
||||
if (pruned >= OAUTH_STATE_PRUNE_BATCH) break;
|
||||
if (Date.parse(expiresAt) <= cutoff) {
|
||||
this.oauthStateUses.delete(oldKey);
|
||||
pruned += 1;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
async upsertEntitlementSnapshot(input: CreateEntitlementSnapshotInput): Promise<void> {
|
||||
const key = `${input.accountId}:${input.provider}:${input.scope}`;
|
||||
this.entitlementSnapshots.set(key, clone(input));
|
||||
|
|
@ -436,4 +586,22 @@ export class InMemoryStore implements HeimdallStore {
|
|||
});
|
||||
this.auditEvents.set(event.id ?? randomUUID(), event);
|
||||
}
|
||||
|
||||
async createConsentReceipt(input: CreateConsentReceiptInput): Promise<{ receipt: StoredConsentReceipt; created: boolean }> {
|
||||
if (input.kind === "revocation") {
|
||||
// The table's foreign key: a revocation names a receipt of the same account.
|
||||
if (!this.consentReceipts.some((r) => r.id === input.revokesReceiptId && r.accountId === input.accountId)) {
|
||||
throw new Error("A revocation must name a receipt of its own account.");
|
||||
}
|
||||
const existing = this.consentReceipts.find((r) => r.kind === "revocation" && r.revokesReceiptId === input.revokesReceiptId);
|
||||
if (existing) return { receipt: clone(existing), created: false };
|
||||
}
|
||||
const receipt = { id: randomUUID(), ...clone(input) } as StoredConsentReceipt;
|
||||
this.consentReceipts.push(clone(receipt));
|
||||
return { receipt: clone(receipt), created: true };
|
||||
}
|
||||
|
||||
async listConsentReceipts(accountId: string): Promise<StoredConsentReceipt[]> {
|
||||
return this.consentReceipts.filter((receipt) => receipt.accountId === accountId).map(clone);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,11 +1,17 @@
|
|||
import { randomUUID } from "node:crypto";
|
||||
import { Pool, type PoolClient, type QueryResultRow } from "pg";
|
||||
import { type AppSlug, type HeimdallAuthAttemptStatus, type LinkedIdentityInput, type Provider } from "../contracts.js";
|
||||
import { decideMove, movedRecord, type MoveFacts } from "./identity-move.js";
|
||||
import { CREATE_SCHEMA_SQL, REQUIRED_COLUMNS, REQUIRED_KEYS, REQUIRED_TABLES } from "./schema.js";
|
||||
import {
|
||||
type CreateAccountInput,
|
||||
type CreateAuthAttemptInput,
|
||||
type ClaimOAuthStateUseInput,
|
||||
type CreateAuthCompletionInput,
|
||||
type CreateConsentReceiptInput,
|
||||
type CreatePendingLinkInput,
|
||||
type StoredConsentReceipt,
|
||||
type StoredPendingLink,
|
||||
type CreateAuditEventInput,
|
||||
type CreateCapabilityGrantInput,
|
||||
type CredentialDecision,
|
||||
|
|
@ -13,6 +19,12 @@ import {
|
|||
type CreateSessionInput,
|
||||
type CreatePrivateCommandReceiptInput,
|
||||
type HeimdallStore,
|
||||
IdentityHeldElsewhereError,
|
||||
type MoveIdentitiesInput,
|
||||
type MoveResult,
|
||||
type StoredIdentityMove,
|
||||
OAUTH_STATE_PRUNE_BATCH,
|
||||
oauthStatePruneCutoffMs,
|
||||
type StoredAccount,
|
||||
type StoredAuthAttempt,
|
||||
type StoredAuthCompletion,
|
||||
|
|
@ -20,6 +32,7 @@ import {
|
|||
type StoredLinkedIdentity,
|
||||
type StoredSession,
|
||||
type StoredPrivateCommandReceipt,
|
||||
type UnlinkResult,
|
||||
type UpsertLinkedIdentityInput,
|
||||
} from "./types.js";
|
||||
|
||||
|
|
@ -42,6 +55,7 @@ interface LinkedIdentityRow extends QueryResultRow {
|
|||
access_token_encrypted: string | null;
|
||||
refresh_token_encrypted: string | null;
|
||||
token_expires_at: string | null;
|
||||
refresh_failed_at: string | null;
|
||||
scopes: string;
|
||||
profile_json: Record<string, unknown>;
|
||||
created_at: string;
|
||||
|
|
@ -82,12 +96,26 @@ interface AuthCompletionRow extends QueryResultRow {
|
|||
account_id: string;
|
||||
session_id: string;
|
||||
return_to: string;
|
||||
target_id: string | null;
|
||||
payload_json: Record<string, unknown>;
|
||||
created_at: string | Date;
|
||||
expires_at: string | Date;
|
||||
consumed_at: string | Date | null;
|
||||
}
|
||||
|
||||
interface PendingLinkRow extends QueryResultRow {
|
||||
id: string;
|
||||
app_slug: AppSlug;
|
||||
account_id: string;
|
||||
provider: Provider;
|
||||
provider_user_id: string;
|
||||
identity_json: StoredPendingLink["identity"];
|
||||
return_to: string;
|
||||
created_at: string | Date;
|
||||
expires_at: string | Date;
|
||||
consumed_at: string | Date | null;
|
||||
}
|
||||
|
||||
interface AuthAttemptRow extends QueryResultRow {
|
||||
handle: string;
|
||||
app_slug: AppSlug;
|
||||
|
|
@ -151,6 +179,42 @@ function mapAccountRow(row: AccountRow): StoredAccount {
|
|||
return account;
|
||||
}
|
||||
|
||||
interface IdentityMoveRow extends QueryResultRow {
|
||||
id: string;
|
||||
app_slug: AppSlug;
|
||||
from_account_id: string;
|
||||
to_account_id: string;
|
||||
reverses_move_id: string | null;
|
||||
moved_json: StoredIdentityMove["moved"];
|
||||
proof_json: StoredIdentityMove["proof"];
|
||||
created_at: string;
|
||||
}
|
||||
|
||||
async function selectIdentityMove(db: Pick<Pool, "query">, moveId: string): Promise<StoredIdentityMove | null> {
|
||||
const result = await db.query<IdentityMoveRow>("SELECT * FROM identity_moves WHERE id = $1", [moveId]);
|
||||
const row = result.rows[0];
|
||||
if (!row) return null;
|
||||
return {
|
||||
id: row.id,
|
||||
appSlug: row.app_slug,
|
||||
fromAccountId: row.from_account_id,
|
||||
toAccountId: row.to_account_id,
|
||||
...(row.reverses_move_id ? { reversesMoveId: row.reverses_move_id } : {}),
|
||||
moved: row.moved_json,
|
||||
proof: row.proof_json,
|
||||
createdAt: new Date(row.created_at).toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
/** A move from this account that no reversal names: the account's identities went elsewhere. */
|
||||
async function hasUnreversedMoveFrom(db: Pick<Pool, "query">, accountId: string): Promise<boolean> {
|
||||
const result = await db.query(
|
||||
"SELECT 1 FROM identity_moves m WHERE m.from_account_id = $1 AND NOT EXISTS (SELECT 1 FROM identity_moves r WHERE r.reverses_move_id = m.id) LIMIT 1",
|
||||
[accountId]
|
||||
);
|
||||
return (result.rowCount ?? 0) > 0;
|
||||
}
|
||||
|
||||
function mapLinkedIdentityRow(row: LinkedIdentityRow): StoredLinkedIdentity {
|
||||
const identity: StoredLinkedIdentity = {
|
||||
id: row.id,
|
||||
|
|
@ -188,6 +252,10 @@ function mapLinkedIdentityRow(row: LinkedIdentityRow): StoredLinkedIdentity {
|
|||
identity.tokenExpiresAt = new Date(row.token_expires_at).toISOString();
|
||||
}
|
||||
|
||||
if (row.refresh_failed_at) {
|
||||
identity.refreshFailedAt = new Date(row.refresh_failed_at).toISOString();
|
||||
}
|
||||
|
||||
return identity;
|
||||
}
|
||||
|
||||
|
|
@ -231,6 +299,59 @@ function mapSessionRow(row: SessionRow): StoredSession {
|
|||
};
|
||||
}
|
||||
|
||||
interface ConsentReceiptRow {
|
||||
id: string;
|
||||
kind: "grant" | "revocation";
|
||||
account_id: string;
|
||||
app_slug: AppSlug;
|
||||
provider: Provider;
|
||||
created_at: Date | string;
|
||||
scopes_asked: string | null;
|
||||
scopes_granted: string | null;
|
||||
consent_page_digest: string | null;
|
||||
consent_text: string | null;
|
||||
revokes_receipt_id: string | null;
|
||||
}
|
||||
|
||||
function mapConsentReceiptRow(row: ConsentReceiptRow): StoredConsentReceipt {
|
||||
const base = {
|
||||
id: row.id,
|
||||
accountId: row.account_id,
|
||||
appSlug: row.app_slug,
|
||||
provider: row.provider,
|
||||
createdAt: normalizeTimestamp(row.created_at),
|
||||
};
|
||||
if (row.kind === "revocation") {
|
||||
return { ...base, kind: "revocation", revokesReceiptId: row.revokes_receipt_id ?? "" };
|
||||
}
|
||||
return {
|
||||
...base,
|
||||
kind: "grant",
|
||||
scopesAsked: parseScopes(row.scopes_asked ?? ""),
|
||||
scopesGranted: parseScopes(row.scopes_granted ?? ""),
|
||||
consentPageDigest: row.consent_page_digest ?? "",
|
||||
consentText: row.consent_text ?? "",
|
||||
};
|
||||
}
|
||||
|
||||
function mapPendingLinkRow(row: PendingLinkRow): StoredPendingLink {
|
||||
const link: StoredPendingLink = {
|
||||
id: row.id,
|
||||
appSlug: row.app_slug,
|
||||
accountId: row.account_id,
|
||||
provider: row.provider,
|
||||
providerUserId: row.provider_user_id,
|
||||
identity: row.identity_json,
|
||||
returnTo: row.return_to,
|
||||
createdAt: normalizeTimestamp(row.created_at),
|
||||
expiresAt: normalizeTimestamp(row.expires_at),
|
||||
};
|
||||
if (row.consumed_at) {
|
||||
link.consumedAt = normalizeTimestamp(row.consumed_at);
|
||||
}
|
||||
return link;
|
||||
}
|
||||
|
||||
function mapAuthCompletionRow(row: AuthCompletionRow): StoredAuthCompletion {
|
||||
const completion: StoredAuthCompletion = {
|
||||
code: row.code,
|
||||
|
|
@ -249,6 +370,10 @@ function mapAuthCompletionRow(row: AuthCompletionRow): StoredAuthCompletion {
|
|||
completion.attemptId = row.attempt_id;
|
||||
}
|
||||
|
||||
if (row.target_id) {
|
||||
completion.targetId = row.target_id;
|
||||
}
|
||||
|
||||
if (row.consumed_at) {
|
||||
completion.consumedAt = normalizeTimestamp(row.consumed_at);
|
||||
}
|
||||
|
|
@ -368,18 +493,28 @@ export function samePredicate(declared: string, actual: string, keyColumns: stri
|
|||
/**
|
||||
* What the store's statements do to each table, and so the privileges its
|
||||
* database role needs: it reads what it returns or looks up, inserts what it
|
||||
* creates, updates what it changes or upserts, and deletes nothing.
|
||||
* creates, updates what it changes or upserts, and deletes two things:
|
||||
* expired oauth_state_uses rows (which needs SELECT for its WHERE), and the one
|
||||
* linked_identities row an unlink names (unlinkLinkedIdentity, the only
|
||||
* delete there; it needs SELECT for its WHERE and for the account's count).
|
||||
* identity_moves is append-only. moveIdentities is the statement that updates
|
||||
* linked_identities.account_id (its one writer), sessions, pending_links and
|
||||
* auth_completions, all of which already hold UPDATE.
|
||||
* audit_events is written and never read back.
|
||||
*/
|
||||
export const STORE_TABLE_PRIVILEGES: Readonly<Record<string, readonly ("SELECT" | "INSERT" | "UPDATE")[]>> = {
|
||||
export const STORE_TABLE_PRIVILEGES: Readonly<Record<string, readonly ("SELECT" | "INSERT" | "UPDATE" | "DELETE")[]>> = {
|
||||
accounts: ["SELECT", "INSERT", "UPDATE"],
|
||||
linked_identities: ["SELECT", "INSERT", "UPDATE"],
|
||||
linked_identities: ["SELECT", "INSERT", "UPDATE", "DELETE"],
|
||||
sessions: ["SELECT", "INSERT", "UPDATE"],
|
||||
auth_attempts: ["SELECT", "INSERT", "UPDATE"],
|
||||
private_command_receipts: ["SELECT", "INSERT"],
|
||||
auth_completions: ["SELECT", "INSERT", "UPDATE"],
|
||||
pending_links: ["SELECT", "INSERT", "UPDATE"],
|
||||
oauth_state_uses: ["SELECT", "INSERT", "DELETE"],
|
||||
capability_grants: ["SELECT", "INSERT"],
|
||||
entitlement_snapshots: ["SELECT", "INSERT", "UPDATE"],
|
||||
consent_receipts: ["SELECT", "INSERT"],
|
||||
identity_moves: ["SELECT", "INSERT"],
|
||||
audit_events: ["INSERT"],
|
||||
};
|
||||
|
||||
|
|
@ -514,7 +649,9 @@ export async function checkSchemaRequirements(pool: Pick<Pool, "query">, require
|
|||
SELECT 1 FROM unnest($2::text[], $3::text[]) AS used(table_name, column_name)
|
||||
JOIN pg_attribute a ON a.attrelid = to_regclass(used.table_name) AND a.attname = used.column_name AND NOT a.attisdropped
|
||||
WHERE used.table_name = required.table_name
|
||||
AND NOT has_column_privilege(a.attrelid, a.attnum, required.privilege)
|
||||
AND NOT CASE WHEN required.privilege = 'DELETE'
|
||||
THEN has_table_privilege(a.attrelid, 'DELETE') -- DELETE is a row privilege, never held per column
|
||||
ELSE has_column_privilege(a.attrelid, a.attnum, required.privilege) END
|
||||
)
|
||||
`,
|
||||
[
|
||||
|
|
@ -691,16 +828,17 @@ export class PostgresStore implements HeimdallStore {
|
|||
)
|
||||
ON CONFLICT (provider, provider_user_id)
|
||||
DO UPDATE SET
|
||||
account_id = EXCLUDED.account_id,
|
||||
username = EXCLUDED.username,
|
||||
display_name = EXCLUDED.display_name,
|
||||
primary_email = EXCLUDED.primary_email,
|
||||
access_token_encrypted = EXCLUDED.access_token_encrypted,
|
||||
refresh_token_encrypted = EXCLUDED.refresh_token_encrypted,
|
||||
token_expires_at = EXCLUDED.token_expires_at,
|
||||
refresh_failed_at = NULL,
|
||||
scopes = EXCLUDED.scopes,
|
||||
profile_json = EXCLUDED.profile_json,
|
||||
updated_at = EXCLUDED.updated_at
|
||||
WHERE linked_identities.account_id = EXCLUDED.account_id
|
||||
RETURNING *
|
||||
`,
|
||||
[
|
||||
|
|
@ -721,7 +859,144 @@ export class PostgresStore implements HeimdallStore {
|
|||
]
|
||||
);
|
||||
|
||||
return mapLinkedIdentityRow(expectRow(result.rows[0], "upsertLinkedIdentity"));
|
||||
// The conflict arm updates only the holder's own row; another account's yields no row.
|
||||
if (!result.rows[0]) throw new IdentityHeldElsewhereError();
|
||||
return mapLinkedIdentityRow(result.rows[0]);
|
||||
}
|
||||
|
||||
async unlinkLinkedIdentity(accountId: string, identityId: string): Promise<UnlinkResult> {
|
||||
const client = await this.pool.connect();
|
||||
try {
|
||||
await client.query("BEGIN");
|
||||
try {
|
||||
// The account row serialises its unlinks: two clients racing for the last two identities queue here.
|
||||
await client.query("SELECT id FROM accounts WHERE id = $1 FOR UPDATE", [accountId]);
|
||||
const held = await client.query<{ n: string | number }>(
|
||||
"SELECT count(*) AS n FROM linked_identities WHERE account_id = $1",
|
||||
[accountId]
|
||||
);
|
||||
let result: UnlinkResult;
|
||||
if (Number(held.rows[0]?.n ?? 0) <= 1) {
|
||||
const mine = await client.query("SELECT 1 FROM linked_identities WHERE id = $1 AND account_id = $2", [identityId, accountId]);
|
||||
result = mine.rowCount ? { kind: "last_identity" } : { kind: "not_found" };
|
||||
} else {
|
||||
const deleted = await client.query<LinkedIdentityRow>(
|
||||
"DELETE FROM linked_identities WHERE id = $2 AND account_id = $1 RETURNING *",
|
||||
[accountId, identityId]
|
||||
);
|
||||
result = deleted.rows[0] ? { kind: "unlinked", identity: mapLinkedIdentityRow(deleted.rows[0]) } : { kind: "not_found" };
|
||||
}
|
||||
await client.query("COMMIT");
|
||||
return result;
|
||||
} catch (error) {
|
||||
await client.query("ROLLBACK");
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
async moveIdentities(input: MoveIdentitiesInput): Promise<MoveResult> {
|
||||
const client = await this.pool.connect();
|
||||
try {
|
||||
await client.query("BEGIN");
|
||||
try {
|
||||
// Both accounts, one statement each in id order, before anything is read: opposite moves queue here
|
||||
// instead of deadlocking. The order is the code's own, not whatever order a plan locks a set in.
|
||||
for (const id of [input.fromAccountId, input.toAccountId].sort()) {
|
||||
await client.query("SELECT id FROM accounts WHERE id = $1 FOR UPDATE", [id]);
|
||||
}
|
||||
const existing = await selectIdentityMove(client, input.moveId);
|
||||
let forward: MoveFacts["forward"] = null;
|
||||
if (input.reversesMoveId !== undefined) {
|
||||
const forwardMove = await selectIdentityMove(client, input.reversesMoveId);
|
||||
const reversal = forwardMove ? await client.query("SELECT 1 FROM identity_moves WHERE reverses_move_id = $1", [forwardMove.id]) : null;
|
||||
forward = forwardMove ? { move: forwardMove, reversed: (reversal?.rowCount ?? 0) > 0 } : null;
|
||||
}
|
||||
let proofSessionsLive = true;
|
||||
for (const proof of input.proofSessions) {
|
||||
const live = await client.query(
|
||||
"SELECT 1 FROM sessions WHERE id = $1 AND app_slug = $2 AND account_id = $3 AND access_revision = $4 AND expires_at > $5",
|
||||
[proof.sessionId, proof.appSlug, proof.accountId, proof.accessRevision, input.at]
|
||||
);
|
||||
if (!live.rowCount) proofSessionsLive = false;
|
||||
}
|
||||
const source = await client.query<LinkedIdentityRow>(
|
||||
"SELECT * FROM linked_identities WHERE account_id = $1 ORDER BY created_at ASC, id ASC FOR UPDATE",
|
||||
[input.fromAccountId]
|
||||
);
|
||||
const destination = await client.query<{ provider: Provider }>("SELECT provider FROM linked_identities WHERE account_id = $1", [input.toAccountId]);
|
||||
const sourceIdentities = source.rows.map(mapLinkedIdentityRow);
|
||||
const decision = decideMove(input, {
|
||||
existing,
|
||||
forward,
|
||||
proofSessionsLive,
|
||||
sourceIdentities,
|
||||
destinationProviders: new Set(destination.rows.map((row) => row.provider)),
|
||||
sourceIsAlias: sourceIdentities.length === 0 && (await hasUnreversedMoveFrom(client, input.fromAccountId)),
|
||||
destinationIsAlias: destination.rowCount === 0 && (await hasUnreversedMoveFrom(client, input.toAccountId)),
|
||||
});
|
||||
if (decision.kind !== "move") {
|
||||
await client.query("ROLLBACK");
|
||||
return decision.kind === "replayed" ? { kind: "replayed", move: decision.move } : decision.result;
|
||||
}
|
||||
const ids = decision.identities.map((identity) => identity.id);
|
||||
await client.query(
|
||||
`UPDATE linked_identities
|
||||
SET account_id = $2, access_token_encrypted = NULL, refresh_token_encrypted = NULL,
|
||||
token_expires_at = NULL, refresh_failed_at = NULL, updated_at = $3
|
||||
WHERE id = ANY($1) AND account_id = $4`,
|
||||
[ids, input.toAccountId, input.at, input.fromAccountId]
|
||||
);
|
||||
await client.query(
|
||||
"UPDATE sessions SET expires_at = $2, last_seen_at = $2, access_revision = access_revision + 1 WHERE account_id = $1 AND expires_at > $2",
|
||||
[input.fromAccountId, input.at]
|
||||
);
|
||||
for (const table of ["pending_links", "auth_completions"]) {
|
||||
await client.query(
|
||||
`UPDATE ${table} SET expires_at = $2 WHERE account_id = $1 AND consumed_at IS NULL AND expires_at > $2`,
|
||||
[input.fromAccountId, input.at]
|
||||
);
|
||||
}
|
||||
const move: StoredIdentityMove = {
|
||||
id: input.moveId,
|
||||
appSlug: input.appSlug,
|
||||
fromAccountId: input.fromAccountId,
|
||||
toAccountId: input.toAccountId,
|
||||
...(input.reversesMoveId !== undefined ? { reversesMoveId: input.reversesMoveId } : {}),
|
||||
moved: movedRecord(decision.identities),
|
||||
proof: input.proof,
|
||||
createdAt: input.at,
|
||||
};
|
||||
try {
|
||||
await client.query(
|
||||
`INSERT INTO identity_moves (id, app_slug, from_account_id, to_account_id, reverses_move_id, moved_json, proof_json, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
|
||||
[move.id, move.appSlug, move.fromAccountId, move.toAccountId, nullable(move.reversesMoveId), JSON.stringify(move.moved), JSON.stringify(move.proof), move.createdAt]
|
||||
);
|
||||
} catch (error) {
|
||||
// The row is the arbiter of a race the locks did not serialise (a reversal of the same move through another pool).
|
||||
if ((error as { code?: string }).code !== "23505") throw error;
|
||||
await client.query("ROLLBACK");
|
||||
const winner = await this.findIdentityMove(input.moveId);
|
||||
if (!winner) return { kind: "not_reversible" };
|
||||
const again = decideMove(input, { existing: winner, forward: null, proofSessionsLive: true, sourceIdentities: [], destinationProviders: new Set(), sourceIsAlias: false, destinationIsAlias: false });
|
||||
return again.kind === "replayed" ? { kind: "replayed", move: again.move } : { kind: "move_id_conflict" };
|
||||
}
|
||||
await client.query("COMMIT");
|
||||
return { kind: "moved", move };
|
||||
} catch (error) {
|
||||
await client.query("ROLLBACK").catch(() => undefined);
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
async findIdentityMove(moveId: string): Promise<StoredIdentityMove | null> {
|
||||
return selectIdentityMove(this.pool, moveId);
|
||||
}
|
||||
|
||||
async updateLinkedIdentityCredential(
|
||||
|
|
@ -731,6 +1006,7 @@ export class PostgresStore implements HeimdallStore {
|
|||
const client = await this.pool.connect();
|
||||
try {
|
||||
await client.query("BEGIN");
|
||||
let decision: CredentialDecision | undefined;
|
||||
try {
|
||||
const locked = await client.query<LinkedIdentityRow>(
|
||||
"SELECT * FROM linked_identities WHERE id = $1 FOR UPDATE",
|
||||
|
|
@ -741,9 +1017,15 @@ export class PostgresStore implements HeimdallStore {
|
|||
return null;
|
||||
}
|
||||
const row = mapLinkedIdentityRow(expectRow(locked.rows[0], "updateLinkedIdentityCredential"));
|
||||
const decision = await decide(row);
|
||||
decision = await decide(row);
|
||||
let committed = row;
|
||||
if (decision.kind !== "keep") {
|
||||
if (decision.kind === "failed") {
|
||||
const marked = await client.query<LinkedIdentityRow>(
|
||||
"UPDATE linked_identities SET refresh_failed_at = $2 WHERE id = $1 RETURNING *",
|
||||
[id, decision.failedAt]
|
||||
);
|
||||
committed = mapLinkedIdentityRow(expectRow(marked.rows[0], "updateLinkedIdentityCredential"));
|
||||
} else if (decision.kind !== "keep") {
|
||||
const rotated = decision.kind === "rotate" ? decision : undefined;
|
||||
const written = await client.query<LinkedIdentityRow>(
|
||||
`
|
||||
|
|
@ -751,6 +1033,7 @@ export class PostgresStore implements HeimdallStore {
|
|||
SET access_token_encrypted = $2,
|
||||
refresh_token_encrypted = $3,
|
||||
token_expires_at = $4,
|
||||
refresh_failed_at = NULL,
|
||||
scopes = $5,
|
||||
updated_at = $6
|
||||
WHERE id = $1
|
||||
|
|
@ -771,6 +1054,21 @@ export class PostgresStore implements HeimdallStore {
|
|||
return committed;
|
||||
} catch (error) {
|
||||
await client.query("ROLLBACK");
|
||||
if (decision?.kind === "rotate" || decision?.kind === "revoke") {
|
||||
// The provider answered, and what its answer called for could not be committed: the rollback took the answer
|
||||
// with it. In a transaction of its own, leave the marker, so no caller presents the token within the backoff.
|
||||
// Blank the token only when it is spent: a revoke, or a provider that rotates (Joystick) and consumed it.
|
||||
// A provider that keeps its refresh token valid (Twitch) keeps it, so a transient write failure does not
|
||||
// strand the link. Best effort: if this write fails too, the original error is the one that matters, and the
|
||||
// residual is named in docs/service-contract.md.
|
||||
const spent = decision.kind === "revoke" || decision.consumedRefreshToken;
|
||||
await client
|
||||
.query(
|
||||
`UPDATE linked_identities SET ${spent ? "refresh_token_encrypted = NULL, " : ""}refresh_failed_at = $2 WHERE id = $1`,
|
||||
[id, decision.updatedAt]
|
||||
)
|
||||
.catch(() => undefined);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
|
|
@ -1004,9 +1302,9 @@ export class PostgresStore implements HeimdallStore {
|
|||
`
|
||||
INSERT INTO auth_completions (
|
||||
code, attempt_id, app_slug, provider, mode, account_id, session_id,
|
||||
return_to, payload_json, created_at, expires_at
|
||||
return_to, target_id, payload_json, created_at, expires_at
|
||||
)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
|
||||
RETURNING *
|
||||
`,
|
||||
[
|
||||
|
|
@ -1018,6 +1316,7 @@ export class PostgresStore implements HeimdallStore {
|
|||
input.accountId,
|
||||
input.sessionId,
|
||||
input.returnTo,
|
||||
input.targetId ?? null,
|
||||
JSON.stringify(input.payloadJson),
|
||||
input.createdAt,
|
||||
input.expiresAt,
|
||||
|
|
@ -1027,6 +1326,14 @@ export class PostgresStore implements HeimdallStore {
|
|||
return mapAuthCompletionRow(expectRow(result.rows[0], "createAuthCompletion"));
|
||||
}
|
||||
|
||||
async findAuthCompletion(appSlug: AppSlug, code: string): Promise<StoredAuthCompletion | null> {
|
||||
const result = await this.pool.query<AuthCompletionRow>(
|
||||
"SELECT * FROM auth_completions WHERE code = $1 AND app_slug = $2",
|
||||
[code, appSlug]
|
||||
);
|
||||
return result.rowCount ? mapAuthCompletionRow(expectRow(result.rows[0], "findAuthCompletion")) : null;
|
||||
}
|
||||
|
||||
async consumeAuthCompletion(appSlug: AppSlug, code: string, at: string): Promise<StoredAuthCompletion | null> {
|
||||
const result = await this.pool.query<AuthCompletionRow>(
|
||||
`
|
||||
|
|
@ -1061,6 +1368,78 @@ export class PostgresStore implements HeimdallStore {
|
|||
return result.rowCount ? mapAuthCompletionRow(expectRow(result.rows[0], "consumeAuthCompletionByAttempt")) : null;
|
||||
}
|
||||
|
||||
async createPendingLink(input: CreatePendingLinkInput): Promise<StoredPendingLink> {
|
||||
const result = await this.pool.query<PendingLinkRow>(
|
||||
`
|
||||
INSERT INTO pending_links (
|
||||
id, app_slug, account_id, provider, provider_user_id, identity_json,
|
||||
return_to, created_at, expires_at
|
||||
)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
|
||||
RETURNING *
|
||||
`,
|
||||
[
|
||||
randomUUID(),
|
||||
input.appSlug,
|
||||
input.accountId,
|
||||
input.provider,
|
||||
input.providerUserId,
|
||||
JSON.stringify(input.identity),
|
||||
input.returnTo,
|
||||
input.createdAt,
|
||||
input.expiresAt,
|
||||
]
|
||||
);
|
||||
return mapPendingLinkRow(expectRow(result.rows[0], "createPendingLink"));
|
||||
}
|
||||
|
||||
async consumePendingLink(appSlug: AppSlug, id: string, accountId: string, at: string): Promise<StoredPendingLink | null> {
|
||||
const result = await this.pool.query<PendingLinkRow>(
|
||||
`
|
||||
UPDATE pending_links
|
||||
SET consumed_at = $4
|
||||
WHERE id = $1
|
||||
AND app_slug = $2
|
||||
AND account_id = $3
|
||||
AND consumed_at IS NULL
|
||||
AND expires_at > $4
|
||||
RETURNING *
|
||||
`,
|
||||
[id, appSlug, accountId, at]
|
||||
);
|
||||
return result.rowCount ? mapPendingLinkRow(expectRow(result.rows[0], "consumePendingLink")) : null;
|
||||
}
|
||||
|
||||
async claimOAuthStateUse(input: ClaimOAuthStateUseInput): Promise<boolean> {
|
||||
// No conflict target and no RETURNING: ON CONFLICT DO NOTHING alone says whether the row was new.
|
||||
const result = await this.pool.query(
|
||||
`
|
||||
INSERT INTO oauth_state_uses (jti, phase, app_slug, used_at, expires_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
ON CONFLICT DO NOTHING
|
||||
`,
|
||||
[input.jti, input.phase, input.appSlug, input.usedAt, input.expiresAt]
|
||||
);
|
||||
if (result.rowCount !== 1) return false;
|
||||
// Retention: one bounded delete of records past the shared cutoff, inline as the memory store does.
|
||||
// The claim row is already written, so a prune failure must not fail the claim: a throw would make
|
||||
// the user's retry look like a replay. Unpruned rows are harmless and the next claim prunes them.
|
||||
try {
|
||||
await this.pool.query(
|
||||
`
|
||||
DELETE FROM oauth_state_uses
|
||||
WHERE (jti, phase) IN (
|
||||
SELECT jti, phase FROM oauth_state_uses WHERE expires_at <= $1 LIMIT $2
|
||||
)
|
||||
`,
|
||||
[new Date(oauthStatePruneCutoffMs(Date.parse(input.usedAt))), OAUTH_STATE_PRUNE_BATCH]
|
||||
);
|
||||
} catch {
|
||||
// deliberately swallowed, see above
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
async upsertEntitlementSnapshot(input: CreateEntitlementSnapshotInput): Promise<void> {
|
||||
await this.pool.query(
|
||||
`
|
||||
|
|
@ -1091,6 +1470,52 @@ export class PostgresStore implements HeimdallStore {
|
|||
);
|
||||
}
|
||||
|
||||
async createConsentReceipt(input: CreateConsentReceiptInput): Promise<{ receipt: StoredConsentReceipt; created: boolean }> {
|
||||
const grant = input.kind === "grant" ? input : null;
|
||||
// No conflict target and the partial unique index decides: a second
|
||||
// revocation of one grant inserts nothing and the first is read back.
|
||||
const result = await this.pool.query<ConsentReceiptRow>(
|
||||
`
|
||||
INSERT INTO consent_receipts (
|
||||
id, kind, account_id, app_slug, provider, created_at,
|
||||
scopes_asked, scopes_granted, consent_page_digest, consent_text, revokes_receipt_id
|
||||
)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
|
||||
ON CONFLICT DO NOTHING
|
||||
RETURNING *
|
||||
`,
|
||||
[
|
||||
randomUUID(),
|
||||
input.kind,
|
||||
input.accountId,
|
||||
input.appSlug,
|
||||
input.provider,
|
||||
input.createdAt,
|
||||
grant ? grant.scopesAsked.join(" ") : null,
|
||||
grant ? grant.scopesGranted.join(" ") : null,
|
||||
grant ? grant.consentPageDigest : null,
|
||||
grant ? grant.consentText : null,
|
||||
input.kind === "revocation" ? input.revokesReceiptId : null,
|
||||
]
|
||||
);
|
||||
if (result.rowCount) {
|
||||
return { receipt: mapConsentReceiptRow(expectRow(result.rows[0], "createConsentReceipt")), created: true };
|
||||
}
|
||||
const existing = await this.pool.query<ConsentReceiptRow>(
|
||||
`SELECT * FROM consent_receipts WHERE revokes_receipt_id = $1`,
|
||||
[input.kind === "revocation" ? input.revokesReceiptId : null]
|
||||
);
|
||||
return { receipt: mapConsentReceiptRow(expectRow(existing.rows[0], "createConsentReceipt")), created: false };
|
||||
}
|
||||
|
||||
async listConsentReceipts(accountId: string): Promise<StoredConsentReceipt[]> {
|
||||
const result = await this.pool.query<ConsentReceiptRow>(
|
||||
`SELECT * FROM consent_receipts WHERE account_id = $1 ORDER BY created_at, id`,
|
||||
[accountId]
|
||||
);
|
||||
return result.rows.map(mapConsentReceiptRow);
|
||||
}
|
||||
|
||||
async createAuditEvent(input: CreateAuditEventInput): Promise<void> {
|
||||
await this.pool.query(
|
||||
`
|
||||
|
|
|
|||
|
|
@ -82,6 +82,19 @@ CREATE TABLE IF NOT EXISTS private_command_receipts (
|
|||
CREATE INDEX IF NOT EXISTS private_command_receipts_expiry_idx
|
||||
ON private_command_receipts(expires_at);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS pending_links (
|
||||
id TEXT PRIMARY KEY,
|
||||
app_slug TEXT NOT NULL,
|
||||
account_id TEXT NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
|
||||
provider TEXT NOT NULL,
|
||||
provider_user_id TEXT NOT NULL,
|
||||
identity_json JSONB NOT NULL,
|
||||
return_to TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
expires_at TIMESTAMPTZ NOT NULL,
|
||||
consumed_at TIMESTAMPTZ
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS auth_completions (
|
||||
code TEXT PRIMARY KEY,
|
||||
app_slug TEXT NOT NULL,
|
||||
|
|
@ -106,6 +119,15 @@ CREATE INDEX IF NOT EXISTS auth_completions_lookup_idx
|
|||
-- redeem the completion it created without ever needing the code.
|
||||
ALTER TABLE auth_completions ADD COLUMN IF NOT EXISTS attempt_id TEXT;
|
||||
|
||||
-- The connection target the signed state named (connection.targetId). Redeem
|
||||
-- compares it against the target the redeeming app states.
|
||||
ALTER TABLE auth_completions ADD COLUMN IF NOT EXISTS target_id TEXT;
|
||||
|
||||
-- When a refresh attempt on this row last failed or timed out, read under the row
|
||||
-- lock so a second Heimdall process does not present the same refresh token
|
||||
-- right behind it. Cleared by rotation, revocation and re-link.
|
||||
ALTER TABLE linked_identities ADD COLUMN IF NOT EXISTS refresh_failed_at TIMESTAMPTZ;
|
||||
|
||||
-- One attempt handle may bind at most one unconsumed completion (R21.1): a
|
||||
-- second completion for the same handle would let the by-attempt UPDATE in
|
||||
-- consumeAuthCompletionByAttempt match more than one row, silently consuming
|
||||
|
|
@ -119,6 +141,23 @@ CREATE UNIQUE INDEX IF NOT EXISTS auth_completions_attempt_unconsumed_unique_idx
|
|||
ON auth_completions(app_slug, attempt_id)
|
||||
WHERE attempt_id IS NOT NULL AND consumed_at IS NULL;
|
||||
|
||||
-- One use per (state jti, phase): a signed OAuth state launches once and
|
||||
-- completes once. The first INSERT for a pair wins; ON CONFLICT DO NOTHING
|
||||
-- reports every later claim as no row. A state is accepted until expires_at + 30 s
|
||||
-- of skew, so a row may be pruned only after that and is never consulted again;
|
||||
-- each successful claim deletes a bounded batch of rows past expires_at + skew
|
||||
-- + margin (OAUTH_STATE_* in types.ts), found through the expires_at index.
|
||||
CREATE TABLE IF NOT EXISTS oauth_state_uses (
|
||||
jti TEXT NOT NULL,
|
||||
phase TEXT NOT NULL,
|
||||
app_slug TEXT NOT NULL,
|
||||
used_at TIMESTAMPTZ NOT NULL,
|
||||
expires_at TIMESTAMPTZ NOT NULL,
|
||||
PRIMARY KEY (jti, phase)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS oauth_state_uses_expires_at_idx ON oauth_state_uses(expires_at);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS capability_grants (
|
||||
id TEXT PRIMARY KEY,
|
||||
account_id TEXT NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
|
||||
|
|
@ -149,6 +188,57 @@ CREATE TABLE IF NOT EXISTS entitlement_snapshots (
|
|||
UNIQUE(account_id, provider, scope)
|
||||
);
|
||||
|
||||
-- Consent receipts are append-only (the store role has INSERT and SELECT
|
||||
-- only): a revocation is a row that names the grant it takes back.
|
||||
CREATE TABLE IF NOT EXISTS consent_receipts (
|
||||
id TEXT PRIMARY KEY,
|
||||
kind TEXT NOT NULL,
|
||||
account_id TEXT NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
|
||||
app_slug TEXT NOT NULL,
|
||||
provider TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
scopes_asked TEXT,
|
||||
scopes_granted TEXT,
|
||||
consent_page_digest TEXT,
|
||||
consent_text TEXT,
|
||||
revokes_receipt_id TEXT,
|
||||
UNIQUE(id, account_id),
|
||||
FOREIGN KEY (revokes_receipt_id, account_id) REFERENCES consent_receipts(id, account_id)
|
||||
);
|
||||
|
||||
-- A revocation names a receipt of its own account (the composite foreign key;
|
||||
-- NULL skips it for grants). A grant is taken back once: the second
|
||||
-- revocation naming it conflicts.
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS consent_receipts_revokes_unique_idx
|
||||
ON consent_receipts(revokes_receipt_id)
|
||||
WHERE revokes_receipt_id IS NOT NULL;
|
||||
|
||||
CREATE INDEX IF NOT EXISTS consent_receipts_account_idx
|
||||
ON consent_receipts(account_id, created_at);
|
||||
|
||||
-- One row per identity move, append-only: no UPDATE and no DELETE, and no
|
||||
-- ON DELETE CASCADE, so the record outlives nothing it names. moved_json is
|
||||
-- [{id, provider, providerUserId, credentialStripped}]; proof_json is
|
||||
-- {from: [{tier, method, identityId}], to: {...} | null}. Never a token, sid,
|
||||
-- email or name. A move is reversed once: the second row naming it conflicts.
|
||||
CREATE TABLE IF NOT EXISTS identity_moves (
|
||||
id TEXT PRIMARY KEY,
|
||||
app_slug TEXT NOT NULL,
|
||||
from_account_id TEXT NOT NULL REFERENCES accounts(id),
|
||||
to_account_id TEXT NOT NULL REFERENCES accounts(id),
|
||||
reverses_move_id TEXT REFERENCES identity_moves(id),
|
||||
moved_json JSONB NOT NULL,
|
||||
proof_json JSONB NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS identity_moves_reverses_unique_idx
|
||||
ON identity_moves(reverses_move_id)
|
||||
WHERE reverses_move_id IS NOT NULL;
|
||||
|
||||
CREATE INDEX IF NOT EXISTS identity_moves_from_idx
|
||||
ON identity_moves(from_account_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS audit_events (
|
||||
id TEXT PRIMARY KEY,
|
||||
account_id TEXT,
|
||||
|
|
@ -210,7 +300,7 @@ export const REQUIRED_TABLES = createdTables.map(({ table }) => table);
|
|||
export const REQUIRED_COLUMNS = [
|
||||
...createdTables.flatMap(({ table, lines }) =>
|
||||
lines
|
||||
.filter((line) => !/^(?:PRIMARY KEY|UNIQUE)\b/.test(line))
|
||||
.filter((line) => !/^(?:PRIMARY KEY|UNIQUE|FOREIGN KEY)\b/.test(line))
|
||||
.map((line) => {
|
||||
const [, column, type] = /^(\w+) (\w+)/.exec(line)!;
|
||||
return { table, column: column!, type: type!, nullable: !/\b(?:NOT NULL|PRIMARY KEY)\b/.test(line) };
|
||||
|
|
|
|||
|
|
@ -33,12 +33,86 @@ export interface StoredLinkedIdentity {
|
|||
accessTokenEncrypted?: string;
|
||||
refreshTokenEncrypted?: string;
|
||||
tokenExpiresAt?: string;
|
||||
/** When a refresh attempt last failed; cleared by the next rotation, revocation or re-link. */
|
||||
refreshFailedAt?: string;
|
||||
scopes: string[];
|
||||
profileJson: Record<string, unknown>;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* An upsert named an identity another account holds. A provider identity
|
||||
* belongs to the account that holds it until that account unlinks it; no
|
||||
* write moves it.
|
||||
*/
|
||||
export class IdentityHeldElsewhereError extends Error {
|
||||
constructor() {
|
||||
super("This provider identity is held by another account.");
|
||||
this.name = "IdentityHeldElsewhereError";
|
||||
}
|
||||
}
|
||||
|
||||
/** What unlinkLinkedIdentity decided; `identity` is the row as it was deleted. */
|
||||
export type UnlinkResult =
|
||||
| { kind: "unlinked"; identity: StoredLinkedIdentity }
|
||||
| { kind: "last_identity" }
|
||||
| { kind: "not_found" };
|
||||
|
||||
/** One login a move carried; `credentialStripped` is history written at the move (the row held a token the move dropped). */
|
||||
export interface MovedIdentity {
|
||||
id: string;
|
||||
provider: Provider;
|
||||
providerUserId: string;
|
||||
credentialStripped: boolean;
|
||||
}
|
||||
|
||||
/** What each side's proofs were, as tiers and methods only: never a token, sid, email or name. */
|
||||
export interface IdentityMoveProof {
|
||||
from: { tier: "strong" | "weak"; method: string | null; identityId: string | null }[];
|
||||
to: { tier: "strong" | "weak"; method: string | null; identityId: string | null } | null;
|
||||
}
|
||||
|
||||
/** The append-only record of one move. */
|
||||
export interface StoredIdentityMove {
|
||||
id: string;
|
||||
appSlug: AppSlug;
|
||||
fromAccountId: string;
|
||||
toAccountId: string;
|
||||
reversesMoveId?: string;
|
||||
moved: MovedIdentity[];
|
||||
proof: IdentityMoveProof;
|
||||
createdAt: string;
|
||||
}
|
||||
|
||||
export interface MoveIdentitiesInput {
|
||||
moveId: string;
|
||||
appSlug: AppSlug;
|
||||
fromAccountId: string;
|
||||
toAccountId: string;
|
||||
/** The logins to carry, or every login the source holds. */
|
||||
identityIds: readonly string[] | "all";
|
||||
/** What the caller's from-proofs cover: the whole account, or exactly these logins. */
|
||||
covers: "account" | readonly string[];
|
||||
/** Sessions the proofs rested on; each must still be live when the transaction commits. */
|
||||
proofSessions: readonly { appSlug: AppSlug; sessionId: string; accountId: string; accessRevision: number }[];
|
||||
reversesMoveId?: string;
|
||||
proof: IdentityMoveProof;
|
||||
at: string;
|
||||
}
|
||||
|
||||
/** What moveIdentities decided. Refusals write nothing. */
|
||||
export type MoveResult =
|
||||
| { kind: "moved"; move: StoredIdentityMove }
|
||||
| { kind: "replayed"; move: StoredIdentityMove }
|
||||
| { kind: "move_id_conflict" }
|
||||
| { kind: "proof_lapsed" }
|
||||
| { kind: "already_moved" }
|
||||
| { kind: "identity_not_found" }
|
||||
| { kind: "identity_not_proved" }
|
||||
| { kind: "provider_conflict"; provider: Provider }
|
||||
| { kind: "not_reversible" };
|
||||
|
||||
export interface UpsertLinkedIdentityInput {
|
||||
id?: string;
|
||||
accountId: string;
|
||||
|
|
@ -58,8 +132,9 @@ export interface UpsertLinkedIdentityInput {
|
|||
|
||||
/**
|
||||
* What the owner of a refresh decides after reading the row under its lock.
|
||||
* `rotate` and `revoke` write token columns, scopes and updated_at only; they
|
||||
* never touch account, profile or identity fields.
|
||||
* `rotate` and `revoke` write token columns, scopes, updated_at and clear the
|
||||
* failed-refresh marker; `failed` writes the marker alone. None touches
|
||||
* account, profile or identity fields.
|
||||
*/
|
||||
export type CredentialDecision =
|
||||
| { kind: "keep" }
|
||||
|
|
@ -70,8 +145,11 @@ export type CredentialDecision =
|
|||
tokenExpiresAt: string;
|
||||
scopes: string[];
|
||||
updatedAt: string;
|
||||
/** The provider rotates refresh tokens, so the one presented is spent whether or not this decision commits. */
|
||||
consumedRefreshToken: boolean;
|
||||
}
|
||||
| { kind: "revoke"; updatedAt: string };
|
||||
| { kind: "revoke"; updatedAt: string }
|
||||
| { kind: "failed"; failedAt: string };
|
||||
|
||||
export interface StoredSession {
|
||||
id: string;
|
||||
|
|
@ -159,18 +237,46 @@ export interface StoredAuthCompletion {
|
|||
accountId: string;
|
||||
sessionId: string;
|
||||
returnTo: string;
|
||||
/** The connection target the signed state named, if any; compared at redeem. */
|
||||
targetId?: string;
|
||||
createdAt: string;
|
||||
expiresAt: string;
|
||||
consumedAt?: string;
|
||||
payloadJson: Record<string, unknown>;
|
||||
}
|
||||
|
||||
/** The skew a signed OAuth state is still accepted for past its exp: verifyOAuthState in app.ts reads this, so the two cannot drift. */
|
||||
export const OAUTH_STATE_SKEW_MS = 30_000;
|
||||
/** Extra time a use record is kept past exp + skew before it may be pruned. */
|
||||
export const OAUTH_STATE_PRUNE_MARGIN_MS = 10 * 60_000;
|
||||
/** The most use records one claim deletes. */
|
||||
export const OAUTH_STATE_PRUNE_BATCH = 50;
|
||||
|
||||
/**
|
||||
* The one retention rule for oauth_state_uses, shared by both stores: a record
|
||||
* is prunable when expires_at + skew + margin <= now, that is when its
|
||||
* expires_at is at or before this cutoff.
|
||||
*/
|
||||
export function oauthStatePruneCutoffMs(nowMs: number): number {
|
||||
return nowMs - OAUTH_STATE_SKEW_MS - OAUTH_STATE_PRUNE_MARGIN_MS;
|
||||
}
|
||||
|
||||
export interface ClaimOAuthStateUseInput {
|
||||
jti: string;
|
||||
/** `step_up_assert` is the app-asserted step-up route's one-use nonce claim: jti is a digest of session and nonce. */
|
||||
phase: "launch" | "callback" | "step_up_assert";
|
||||
appSlug: AppSlug;
|
||||
usedAt: string;
|
||||
expiresAt: string;
|
||||
}
|
||||
|
||||
export interface CreateAuthCompletionInput {
|
||||
/**
|
||||
* Correlation handle only (see StoredAuthCompletion.attemptId). The store
|
||||
* always mints `code` itself; a caller cannot choose it.
|
||||
*/
|
||||
attemptId?: string;
|
||||
targetId?: string;
|
||||
appSlug: AppSlug;
|
||||
provider: Provider;
|
||||
mode: OAuthMode;
|
||||
|
|
@ -182,6 +288,28 @@ export interface CreateAuthCompletionInput {
|
|||
payloadJson: Record<string, unknown>;
|
||||
}
|
||||
|
||||
/**
|
||||
* A link the callback has verified but not written. The identity attaches to
|
||||
* `accountId` (the account whose Heimdall access token began the link) only
|
||||
* when that same account confirms it; until then no linked-identity row
|
||||
* exists. `identity` holds the already-encrypted row to write.
|
||||
*/
|
||||
export interface StoredPendingLink {
|
||||
id: string;
|
||||
appSlug: AppSlug;
|
||||
accountId: string;
|
||||
provider: Provider;
|
||||
providerUserId: string;
|
||||
identity: UpsertLinkedIdentityInput;
|
||||
returnTo: string;
|
||||
createdAt: string;
|
||||
expiresAt: string;
|
||||
consumedAt?: string;
|
||||
}
|
||||
|
||||
/** The store mints `id`; a caller cannot choose it. */
|
||||
export type CreatePendingLinkInput = Omit<StoredPendingLink, "id" | "consumedAt">;
|
||||
|
||||
export interface StoredAuthAttempt {
|
||||
handle: string;
|
||||
appSlug: AppSlug;
|
||||
|
|
@ -219,6 +347,33 @@ export interface StoredPrivateCommandReceipt {
|
|||
|
||||
export type CreatePrivateCommandReceiptInput = StoredPrivateCommandReceipt;
|
||||
|
||||
/**
|
||||
* What a person agreed to, or took back. Append-only: a grant row is never
|
||||
* edited, and a revocation is a second row naming it, so a grant is live
|
||||
* exactly when no revocation names it. `scopesAsked` is what Heimdall sent the
|
||||
* provider, `scopesGranted` what the provider returned, `consentPageDigest`
|
||||
* the hash of the wording the person was shown and `consentText` that wording
|
||||
* itself. A grant is revoked at most once: a second revocation naming the same
|
||||
* grant is not written, and the store answers with the first.
|
||||
*/
|
||||
export type StoredConsentReceipt = {
|
||||
id: string;
|
||||
accountId: string;
|
||||
appSlug: AppSlug;
|
||||
provider: Provider;
|
||||
createdAt: string;
|
||||
} & (
|
||||
| { kind: "grant"; scopesAsked: string[]; scopesGranted: string[]; consentPageDigest: string; consentText: string }
|
||||
| { kind: "revocation"; revokesReceiptId: string }
|
||||
);
|
||||
|
||||
/** The store mints `id`; a caller cannot choose it. */
|
||||
export type CreateConsentReceiptInput = StoredConsentReceipt extends infer R
|
||||
? R extends StoredConsentReceipt
|
||||
? Omit<R, "id">
|
||||
: never
|
||||
: never;
|
||||
|
||||
export interface HeimdallStore {
|
||||
ensureSchema(): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
|
|
@ -229,7 +384,26 @@ export interface HeimdallStore {
|
|||
findStoredLinkedIdentity(provider: Provider, providerUserId: string): Promise<StoredLinkedIdentity | null>;
|
||||
findStoredLinkedIdentityForAccount(accountId: string, provider: Provider): Promise<StoredLinkedIdentity | null>;
|
||||
listStoredLinkedIdentitiesForAccount(accountId: string): Promise<StoredLinkedIdentity[]>;
|
||||
/** Writes the holder's own row; throws IdentityHeldElsewhereError rather than move another account's identity. */
|
||||
upsertLinkedIdentity(input: UpsertLinkedIdentityInput): Promise<StoredLinkedIdentity>;
|
||||
/**
|
||||
* The only delete of a linked identity. One transaction locks the account,
|
||||
* refuses to take its last identity, and deletes the row only if the
|
||||
* account holds it (an id that is missing or another account's is the same
|
||||
* `not_found`).
|
||||
*/
|
||||
unlinkLinkedIdentity(accountId: string, identityId: string): Promise<UnlinkResult>;
|
||||
/**
|
||||
* The only writer that sets a linked identity's account to another account,
|
||||
* in one transaction: lock both accounts (in id order), answer a repeated
|
||||
* moveId from its row, re-check the proof sessions, refuse what the rules
|
||||
* refuse, move the rows with their credentials stripped, revoke the source's
|
||||
* sessions and expire its pending links and unredeemed completions, and
|
||||
* append the identity_moves row. A reversal (`reversesMoveId`) moves back
|
||||
* exactly what the forward move carried. The destination never loses an identity.
|
||||
*/
|
||||
moveIdentities(input: MoveIdentitiesInput): Promise<MoveResult>;
|
||||
findIdentityMove(moveId: string): Promise<StoredIdentityMove | null>;
|
||||
/**
|
||||
* Serialise decisions about one row's credential. `decide` receives the row
|
||||
* as read under the lock (never a caller's snapshot) and the decision is
|
||||
|
|
@ -263,6 +437,8 @@ export interface HeimdallStore {
|
|||
createPrivateCommandReceipt(input: CreatePrivateCommandReceiptInput): Promise<StoredPrivateCommandReceipt>;
|
||||
findPrivateCommandReceipt(appSlug: AppSlug, idempotencyKey: string): Promise<StoredPrivateCommandReceipt | null>;
|
||||
createAuthCompletion(input: CreateAuthCompletionInput): Promise<StoredAuthCompletion>;
|
||||
/** Read a completion without consuming it, so redeem can refuse a mismatch without burning the code. */
|
||||
findAuthCompletion(appSlug: AppSlug, code: string): Promise<StoredAuthCompletion | null>;
|
||||
consumeAuthCompletion(appSlug: AppSlug, code: string, at: string): Promise<StoredAuthCompletion | null>;
|
||||
/**
|
||||
* Consume a completion by its correlated attempt handle instead of its
|
||||
|
|
@ -271,6 +447,27 @@ export interface HeimdallStore {
|
|||
* it created without ever needing to know (or forge) the code.
|
||||
*/
|
||||
consumeAuthCompletionByAttempt(appSlug: AppSlug, attemptId: string, at: string): Promise<StoredAuthCompletion | null>;
|
||||
createPendingLink(input: CreatePendingLinkInput): Promise<StoredPendingLink>;
|
||||
/**
|
||||
* Single-use redemption: returns the link only for the app and the account
|
||||
* it was begun by, before it expires and once. A mismatch returns null and
|
||||
* leaves the link unconsumed.
|
||||
*/
|
||||
consumePendingLink(appSlug: AppSlug, id: string, accountId: string, at: string): Promise<StoredPendingLink | null>;
|
||||
upsertEntitlementSnapshot(input: CreateEntitlementSnapshotInput): Promise<void>;
|
||||
/**
|
||||
* Claim one use of a signed OAuth state: true only for the first claim of
|
||||
* (jti, phase), false for every later one. Without it a state is a bearer
|
||||
* token any number of browsers can complete, so an attacker who learns a
|
||||
* victim's state completes it as themselves and hands the victim a code
|
||||
* for the attacker's account. `expiresAt` is the state's own expiry; the
|
||||
* state is refused at that time before any claim, so the record is dead
|
||||
* after it and a store may drop it.
|
||||
*/
|
||||
claimOAuthStateUse(input: ClaimOAuthStateUseInput): Promise<boolean>;
|
||||
createAuditEvent(input: CreateAuditEventInput): Promise<void>;
|
||||
/** `created` is false when a revocation for that grant already existed and is what comes back. */
|
||||
createConsentReceipt(input: CreateConsentReceiptInput): Promise<{ receipt: StoredConsentReceipt; created: boolean }>;
|
||||
/** Every receipt the account holds, oldest first. */
|
||||
listConsentReceipts(accountId: string): Promise<StoredConsentReceipt[]>;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,3 +37,7 @@
|
|||
{"ts": "2026-09-08T12:20:12+00:00", "type": "security", "status": "accepted", "note": "epiphany/heimdall-caller-identity, second Hands pass: closed the two Soul-proven holes. (1) auth-completions redeem code is now always store-minted (never handoff.attemptId); attemptId survives only as a separate correlation field on StoredAuthCompletion/CreateAuthCompletionInput, and a new store.consumeAuthCompletionByAttempt(appSlug, attemptId, at) lets the private command plane's completeAuth redeem by the handle it already owns instead of forging an HTTP self-call with completionCode=handle. (2) startOAuthFlow now refuses any returnTo whose origin is not in AppProfile.allowedReturnOrigins (repixelizer/streampixels/bifrost -> <slug>.gamecult.org, ghostlight -> yggdrasil.gamecult.org per its docs/app-profiles doc and existing test fixtures; a registered app's allowlist is derived from its stored redirectUris origins). AppCaller is now branded with an unexported Symbol (app-caller.ts); private-command-plane.ts's two { appSlug } literals are gone, replaced by app-caller.ts's callerFromOpenedEnvelope. Deleted: validateAppRegistration, AppRegistrationRequest, RegistrationProblem, AppRegistrationError, HeimdallStore.registerApp (writer). Kept: findRegisteredApp/listRegisteredApps/resolveAppProfile fallback -- AppSlug is a plain string (contracts.ts), registered_apps is a real extension point for a slug Heimdall was never rebuilt for, and isBuiltInApp's only production call site (listAppProfiles) depends on that fallback existing; a row is now provisioned by direct SQL (or InMemoryStore.seedRegisteredApp in tests), not by any app-facing writer. Deleted the two appSlug===\"ghostlight\" branches in private-command-plane.ts; the requirement is now AppProfile.requiredEntitlementPolicyKind, checked generically through resolveAppProfile. tsc --noEmit clean; vitest 94 passed/1 pre-existing-skip, only pre-existing failure is tests/odin-publication.test.ts (Cannot find module 'cultcache-ts', present on main too).", "branch": "epiphany/heimdall-caller-identity"}
|
||||
{"ts": "2026-10-19T15:56:24+00:00", "type": "design", "status": "accepted", "note": "Refresh is now one locked primitive for every provider (replaces unserialized refreshLinkedIdentityCredentialIfNeeded); Joystick is managed-only (Heimdall-held credential, no viewer sign-in until joystick:follow_up:joystick-viewer-signin-public-bot). Merged in PR #1, live at d51fa6b; campaign joystick:campaign:self.", "branch": "eureka/joystick-h1"}
|
||||
{"ts": "2026-10-19T16:03:16+00:00", "type": "verification", "status": "accepted", "note": "Live d51fa6b (H1) verified by a real human sign-in: the operator's StreamPixels Twitch sign-in through Heimdall start/callback, 2026-10-19 ('Twitch auth worked fine'); a streampixels session was created 16:02:33Z, after the 15:51Z switch. Joystick consent round trip still open: joystick:follow_up:h1-joystick-consent-round-trip."}
|
||||
{"ts": "2026-11-12T23:10:15+00:00", "type": "design", "status": "accepted", "note": "Changelog 2026-11-12: sign_in start accepts stepUp (app-authenticated, sign_in only, off by default); signed state carries step_up; launch adds Twitch force_verify=true, YouTube prompt='login consent', Google prompt=login; any other provider is 400 step_up_not_supported; completion reports stepUpRequested. Not deployed. For joystick:follow_up:chat-s7055-7056 (StreamPixels link hardening, second factor via fresh sign-in)."}
|
||||
{"ts": "2026-11-13T19:10:00+00:00", "type": "design", "status": "accepted", "note": "Changelog 2026-11-13: GET /v1/me/identities lists an account's identities (no credentials, profile or email); POST /v1/me/identities/:id/unlink deletes one with a step-up proof (access claim step_up_at, 600 s, never carried by refresh), refuses the last identity (409), writes revocation receipts when the provider's last identity goes. upsertLinkedIdentity no longer moves an identity between accounts (IdentityHeldElsewhereError; links/confirm 409 identity_linked_elsewhere, callback link_initiator_mismatch). The store role needs DELETE on linked_identities (startup refuses without it): owner-role GRANT at deploy."}
|
||||
{"ts": "2026-11-13T20:01:42+00:00", "type": "design", "status": "accepted", "note": "Changelog 2026-11-13: POST /v1/apps/{app}/step-up (profile grant stepUpAssertion, bifrost only; methods bifrost-passkey, bifrost-email-code). App secret plus the member's live bearer for that app; mints a same-session access token with step_up_at now and new claim step_up_method (exp kept, no refresh, no session write); nonce single-use via oauth_state_uses phase step_up_assert (no schema change), retained to the session expiry as of the claim (a refresh may slide the session past it); in-process rate limits 10 per 600 s per account, 120 per 60 s per app; audit step_up_asserted and step_up_assertion_refused with a nonce digest (429s and not-permitted refusals audited once per window; not-permitted has a 5 per 60 s per-app budget); nonce is base64url 16-128. Provider step-up sign-ins now carry step_up_method provider:<name>; identity_unlinked records stepUpMethod. Heimdall cannot verify the factor: it trusts the calling app. Not deployed; no env, secret or migration. For heimdall-body:follow_up:chat-s7419-7419.", "branch": "heimdall/app-asserted-step-up"}
|
||||
{"ts": "2026-11-14T01:10:00+00:00", "type": "design", "status": "accepted", "note": "Changelog 2026-11-14: POST /v1/apps/{app}/identity-moves (profile grant identityMoves, bifrost only; accountProofMethods bifrost-passkey) and the identity_moves table, the only writer of linked_identities.account_id (moveIdentities, one transaction, accounts locked in id order, shared decideMove on both stores). Access claims gain auth_at and auth_identity_id (sign_in callback only). proofTier is the one freshness rule (unlink reads it; strong 600 s step_up_at, weak 300 s auth_at); proofCovers: only an asserted account-proof method covers a whole account, otherwise the login in auth_identity_id (ruling move-proof-strict-passkey). Moves strip credentials, revoke the source's sessions, expire its pending links and unredeemed completions, write revocation receipts under the source, audit identity_moved; moveId is idempotent (replay answers the stored receipt without proof liveness); a move is reversible once. Not deployed: the owner must apply the identity_moves DDL and GRANT SELECT, INSERT ON identity_moves to the store role before the new build starts (startup refuses SCHEMA_MISSING / SCHEMA_PRIVILEGES otherwise).", "branch": "heimdall/identity-moves"}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import { entitlementFacts } from "../src/facts.js";
|
|||
import { startHeimdallPrivateCommandPlane } from "../src/private-command-plane.js";
|
||||
import { openPrivateEnvelope, sealPrivateEnvelope, type HeimdallPrivateEnvelope } from "../src/private-command-security.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { launchState } from "./oauth-flow.js";
|
||||
|
||||
const secret = "ghostlight-private-command-secret";
|
||||
const resources: Array<{ close(): Promise<unknown> }> = [];
|
||||
|
|
@ -107,9 +108,12 @@ describe("Heimdall Eve access plugin", () => {
|
|||
const begin = openPrivateEnvelope(beginWire, secret);
|
||||
expect(begin.schema).toBe("heimdall.auth_begin_receipt.v1");
|
||||
const handle = String(begin.handle);
|
||||
const navigation = begin.navigation as { url: string };
|
||||
const navigation = begin.navigation as { url: string; allowedOrigins: string[] };
|
||||
const state = new URL(navigation.url).searchParams.get("state");
|
||||
expect(state).toBeTruthy();
|
||||
// The browser goes to Heimdall's launch hop first, and only Heimdall's origin is allowed.
|
||||
expect(navigation.url.startsWith("https://heimdall.gamecult.org/v1/oauth/discord/launch?state=")).toBe(true);
|
||||
expect(navigation.allowedOrigins).toEqual(["https://heimdall.gamecult.org"]);
|
||||
|
||||
const pendingEnvelope = sealPrivateEnvelope({
|
||||
appSlug: "ghostlight",
|
||||
|
|
@ -124,9 +128,11 @@ describe("Heimdall Eve access plugin", () => {
|
|||
const pending = openPrivateEnvelope(decodeEnvelope(pendingResponse.payload), secret);
|
||||
expect(pending).toMatchObject({ status: "pending", handle });
|
||||
|
||||
const { cookie } = await launchState(app, state ?? "");
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(state ?? "")}`,
|
||||
headers: { cookie },
|
||||
});
|
||||
expect(callback.statusCode, callback.body).toBe(201);
|
||||
// The completion code is always minted by the store now, never the
|
||||
|
|
@ -291,7 +297,7 @@ function testConfig(): HeimdallConfig {
|
|||
storage: { backend: "memory", applySchemaOnStartup: true },
|
||||
providers: {
|
||||
discord: { clientId: "discord-client", clientSecret: "discord-secret" },
|
||||
patreon: {}, github: {}, twitch: {}, youtube: {}, spotify: {}, joystick: {},
|
||||
patreon: {}, github: {}, twitch: {}, youtube: {}, spotify: {}, joystick: {}, google: {},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ import { join } from "node:path";
|
|||
import { inspect } from "node:util";
|
||||
import { afterEach, describe, expect, it } from "vitest";
|
||||
import { type FastifyInstance } from "fastify";
|
||||
import { buildApp, errorIdentity } from "../src/app.js";
|
||||
import { buildApp, errorIdentity, getHeimdallRuntimeContext, startOAuthFlow } from "../src/app.js";
|
||||
import { resolveAppCaller } from "../src/app-caller.js";
|
||||
import { builtInAppProfiles, callbackMint } from "../src/app-profiles.js";
|
||||
import { deliverBackendHandoff, type BackendHandoffPayload } from "../src/backend-handoff.js";
|
||||
import { type HeimdallConfig, loadConfig } from "../src/config.js";
|
||||
|
|
@ -12,96 +13,7 @@ import { entitlementFacts, identityFacts } from "../src/facts.js";
|
|||
import { createOAuthRuntimeRegistry, ProviderResponseError, type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { createRuntimeKeyMaterial, signJwt, verifyJwt } from "../src/signing.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
|
||||
function createTestConfig(): HeimdallConfig {
|
||||
return {
|
||||
serviceName: "heimdall",
|
||||
host: "127.0.0.1",
|
||||
port: 4100,
|
||||
workspaceRoot: "E:/Projects/Heimdall",
|
||||
dataRoot: "E:/Projects/Heimdall/.heimdall-data",
|
||||
cultCachePath: "E:/Projects/Heimdall/.heimdall-data/cultcache/heimdall.service.cc",
|
||||
publicBaseUrl: "https://heimdall.gamecult.org",
|
||||
issuer: "https://heimdall.gamecult.org",
|
||||
daemonId: "yggdrasil-heimdall",
|
||||
idunnRudpHealth: undefined,
|
||||
idunnHealthContract: "heimdall.cultnet-rudp-provider-health",
|
||||
providerHealthIdentityPath: "E:/Projects/Heimdall/.heimdall-data/provider-health-identity.cc",
|
||||
sessionTtlSeconds: 3600,
|
||||
refreshTtlSeconds: 60 * 60 * 24 * 30,
|
||||
stateTtlSeconds: 600,
|
||||
completionTtlSeconds: 300,
|
||||
bootstrapSigningPrivateKeyOnMissing: false,
|
||||
tokenEncryptionKeyBase64: Buffer.alloc(32, 7).toString("base64"),
|
||||
appSharedSecrets: {
|
||||
streampixels: "streampixels-secret",
|
||||
repixelizer: "repixelizer-secret",
|
||||
bifrost: "bifrost-secret",
|
||||
},
|
||||
appBackendCallbacks: {
|
||||
bifrost: ["https://bifrost.gamecult.org/auth/heimdall/callback"],
|
||||
repixelizer: ["https://repixelizer.gamecult.org/api/auth/heimdall/callback"],
|
||||
},
|
||||
storage: {
|
||||
backend: "memory",
|
||||
applySchemaOnStartup: true,
|
||||
},
|
||||
providers: {
|
||||
discord: { clientId: "discord-client", clientSecret: "discord-secret" },
|
||||
patreon: { clientId: "patreon-client", clientSecret: "patreon-secret" },
|
||||
github: { clientId: "github-client", clientSecret: "github-secret" },
|
||||
twitch: { clientId: "twitch-client", clientSecret: "twitch-secret" },
|
||||
youtube: { clientId: "youtube-client", clientSecret: "youtube-secret" },
|
||||
spotify: { clientId: "spotify-client", clientSecret: "spotify-secret" },
|
||||
joystick: { clientId: "joystick-client", clientSecret: "joystick-secret" },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function createMockDiscordRuntime(): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return {
|
||||
accessToken: "discord-access-token",
|
||||
refreshToken: "discord-refresh-token",
|
||||
tokenType: "Bearer",
|
||||
scope: ["identify", "guilds.members.read"],
|
||||
expiresAt: "2026-04-26T13:00:00.000Z",
|
||||
raw: { source: "test" },
|
||||
};
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return {
|
||||
provider: "discord",
|
||||
providerUserId: "discord-user-123",
|
||||
username: "meta",
|
||||
displayName: "Meta",
|
||||
primaryEmail: "meta@gamecult.org",
|
||||
profile: { id: "discord-user-123", username: "meta" },
|
||||
};
|
||||
},
|
||||
async evaluateEntitlements({ callback }) {
|
||||
return {
|
||||
facts: [entitlementFacts.appAccess],
|
||||
snapshots: [
|
||||
{
|
||||
accountId: callback.accountId,
|
||||
provider: "discord",
|
||||
scope: "repixelizer:discord_role_access:gamecult-guild",
|
||||
evaluatedAt: "2026-04-26T12:00:00.000Z",
|
||||
isAllowed: true,
|
||||
reasonCode: "matched_role",
|
||||
reasonDetail: "Matched Repixelizer access role.",
|
||||
rawSummaryJson: {
|
||||
guildId: "gamecult-guild",
|
||||
matchedRoles: ["role-repixelizer"],
|
||||
},
|
||||
},
|
||||
],
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
import { createMockDiscordRuntime, createTestConfig, launchFlow, providerRedirect, stateOf, type LaunchedFlow } from "./oauth-flow.js";
|
||||
|
||||
const apps: Awaited<ReturnType<typeof buildApp>>[] = [];
|
||||
const originalFetch = globalThis.fetch;
|
||||
|
|
@ -134,7 +46,7 @@ function getHeimdallContext(app: FastifyInstance) {
|
|||
}).heimdallContext;
|
||||
}
|
||||
|
||||
async function startDiscordSignIn(app: FastifyInstance): Promise<string> {
|
||||
async function startDiscordSignIn(app: FastifyInstance): Promise<LaunchedFlow> {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
|
|
@ -146,7 +58,7 @@ async function startDiscordSignIn(app: FastifyInstance): Promise<string> {
|
|||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
return response.json().stateToken as string;
|
||||
return launchFlow(app, response.json());
|
||||
}
|
||||
|
||||
afterEach(async () => {
|
||||
|
|
@ -207,9 +119,9 @@ describe("Heimdall service", () => {
|
|||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const payload = response.json();
|
||||
expect(payload.authorizationUrl).toContain("discord.com/oauth2/authorize");
|
||||
expect((await providerRedirect(app, payload)).href).toContain("discord.com/oauth2/authorize");
|
||||
|
||||
const verified = verifyJwt(payload.stateToken as string, getPublicKey(app));
|
||||
const verified = verifyJwt(stateOf(payload), getPublicKey(app));
|
||||
expect(verified.valid).toBe(true);
|
||||
if (verified.valid) {
|
||||
expect(verified.payload).toEqual(
|
||||
|
|
@ -249,6 +161,170 @@ describe("Heimdall service", () => {
|
|||
expect(response.json()).toEqual(expect.objectContaining({ error: "app_auth_required" }));
|
||||
});
|
||||
|
||||
describe("apps that bind browser completion to their own attempt", () => {
|
||||
// Bifrost's browser binding is the secrecy of its attempt nonce, which
|
||||
// travels readable in the signed state. Only Bifrost may mint a Bifrost
|
||||
// state, so a known nonce cannot carry a stranger's completion
|
||||
// (finding known-nonce-login-csrf).
|
||||
const victimAttempt = "VICTIM-ATTEMPT-NONCE";
|
||||
const bifrostReturn = `https://bifrost.gamecult.org/auth/heimdall/complete?attempt=${victimAttempt}`;
|
||||
const bifrostStart = (handoff?: { kind: "browser_completion" }) => ({
|
||||
appSlug: "bifrost" as const,
|
||||
mode: "sign_in" as const,
|
||||
returnTo: bifrostReturn,
|
||||
...(handoff ? { handoff } : {}),
|
||||
});
|
||||
|
||||
it("refuses an unauthenticated Bifrost start for browser_completion and for an omitted handoff", async () => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
for (const payload of [bifrostStart({ kind: "browser_completion" }), bifrostStart()]) {
|
||||
const response = await app.inject({ method: "POST", url: "/v1/oauth/discord/start", payload });
|
||||
expect(response.statusCode).toBe(401);
|
||||
expect(response.json()).toEqual({ error: "app_auth_required" });
|
||||
}
|
||||
});
|
||||
|
||||
it("the attack fails: a stranger cannot obtain a Bifrost state carrying a chosen return_to nonce", async () => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
payload: bifrostStart({ kind: "browser_completion" }),
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
expect(response.body).not.toContain(victimAttempt);
|
||||
expect(response.body).not.toContain("stateToken");
|
||||
expect(response.body).not.toContain("authorizationUrl");
|
||||
});
|
||||
|
||||
it("still starts for Bifrost's own app secret, with the requested return_to in the state", async () => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
headers: { "x-heimdall-app-secret": "bifrost-secret" },
|
||||
payload: bifrostStart({ kind: "browser_completion" }),
|
||||
});
|
||||
expect(response.statusCode).toBe(201);
|
||||
const verified = verifyJwt(stateOf(response.json()), getPublicKey(app));
|
||||
expect(verified.valid).toBe(true);
|
||||
if (verified.valid) {
|
||||
expect(verified.payload).toEqual(expect.objectContaining({ app_slug: "bifrost", return_to: bifrostReturn }));
|
||||
}
|
||||
});
|
||||
|
||||
it("refuses another app's credentials on a Bifrost start", async () => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
for (const secret of ["streampixels-secret", "repixelizer-secret"]) {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
headers: { "x-heimdall-app-secret": secret },
|
||||
payload: bifrostStart({ kind: "browser_completion" }),
|
||||
});
|
||||
expect(response.statusCode, secret).toBe(401);
|
||||
expect(response.json()).toEqual({ error: "app_auth_required" });
|
||||
}
|
||||
});
|
||||
|
||||
it("refuses another app's authenticated caller on a direct Bifrost start, with no policy attached", async () => {
|
||||
// Over HTTP the caller is resolved against the body's slug, so a foreign
|
||||
// secret never becomes a caller at all. The command plane and direct
|
||||
// callers hand startOAuthFlow a caller of their own, so the slug match is
|
||||
// decided here too.
|
||||
const config = createTestConfig();
|
||||
const app = await buildApp({ config });
|
||||
apps.push(app);
|
||||
const foreign = resolveAppCaller(config, "repixelizer", { "x-heimdall-app-secret": "repixelizer-secret" });
|
||||
const own = resolveAppCaller(config, "bifrost", { "x-heimdall-app-secret": "bifrost-secret" });
|
||||
|
||||
const refused = await startOAuthFlow(getHeimdallRuntimeContext(app), "discord", foreign, bifrostStart({ kind: "browser_completion" }));
|
||||
expect(refused.statusCode).toBe(401);
|
||||
const allowed = await startOAuthFlow(getHeimdallRuntimeContext(app), "discord", own, bifrostStart({ kind: "browser_completion" }));
|
||||
expect(allowed.statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("gates every mode, provider and handoff kind Bifrost admits, not one spelling of them", async () => {
|
||||
// Hand mutants narrowing the gate to browser_completion or to sign_in
|
||||
// survived the single-case tests (finding gate-tests-narrow).
|
||||
const store = new InMemoryStore();
|
||||
const now = new Date().toISOString();
|
||||
const initiator = await store.createAccount({ createdAt: now, lastSeenAt: now });
|
||||
const app = await buildApp({ config: createTestConfig(), store });
|
||||
apps.push(app);
|
||||
const handoffs = [
|
||||
undefined,
|
||||
{ kind: "browser_completion" },
|
||||
{
|
||||
kind: "backend_callback",
|
||||
attemptId: "bifrost-attempt-1",
|
||||
callbackUrl: "https://bifrost.gamecult.org/auth/heimdall/callback",
|
||||
},
|
||||
];
|
||||
|
||||
let cases = 0;
|
||||
for (const mode of ["sign_in", "link", "connect"] as const) {
|
||||
for (const provider of ["discord", "patreon"] as const) {
|
||||
for (const handoff of handoffs) {
|
||||
const label = `${mode} ${provider} ${handoff?.kind ?? "omitted"}`;
|
||||
const payload = {
|
||||
appSlug: "bifrost",
|
||||
mode,
|
||||
returnTo: bifrostReturn,
|
||||
...(mode === "link" ? { initiatingAccountId: initiator.id } : {}),
|
||||
...(handoff ? { handoff } : {}),
|
||||
};
|
||||
const refused = await app.inject({ method: "POST", url: `/v1/oauth/${provider}/start`, payload });
|
||||
expect(refused.statusCode, label).toBe(401);
|
||||
expect(refused.json(), label).toEqual({ error: "app_auth_required" });
|
||||
|
||||
const allowed = await app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/oauth/${provider}/start`,
|
||||
headers: { "x-heimdall-app-secret": "bifrost-secret" },
|
||||
payload,
|
||||
});
|
||||
expect(allowed.statusCode, label).toBe(201);
|
||||
expect(allowed.json().authorizationUrl, label).toContain(`/v1/oauth/${provider}/launch?state=`);
|
||||
cases += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
expect(cases).toBe(18);
|
||||
});
|
||||
|
||||
it("leaves public-by-design apps unchanged: unauthenticated browser_completion starts still succeed", async () => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
for (const [appSlug, provider, returnTo] of [
|
||||
["repixelizer", "discord", "https://repixelizer.gamecult.org/app/"],
|
||||
["streampixels", "twitch", "https://streampixels.gamecult.org/app/"],
|
||||
] as const) {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/oauth/${provider}/start`,
|
||||
payload: { appSlug, mode: "sign_in", returnTo, handoff: { kind: "browser_completion" } },
|
||||
});
|
||||
expect(response.statusCode, appSlug).toBe(201);
|
||||
}
|
||||
});
|
||||
|
||||
it("flags only Bifrost's profile", () => {
|
||||
expect(
|
||||
Object.values(builtInAppProfiles).filter((profile) => profile.startRequiresAppCaller).map((profile) => profile.slug)
|
||||
).toEqual(["bifrost"]);
|
||||
});
|
||||
});
|
||||
|
||||
it("accepts caller-owned entitlement policy for a browser completion handoff when the caller is trusted", async () => {
|
||||
// The other half of the same pin: a caller holding the secret may attach
|
||||
// policy even without a backend_callback handoff, because identity no
|
||||
|
|
@ -302,9 +378,9 @@ describe("Heimdall service", () => {
|
|||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const payload = response.json();
|
||||
expect(payload.authorizationUrl).toContain("discord.com/oauth2/authorize");
|
||||
expect((await providerRedirect(app, payload)).href).toContain("discord.com/oauth2/authorize");
|
||||
|
||||
const verified = verifyJwt(payload.stateToken as string, getPublicKey(app));
|
||||
const verified = verifyJwt(stateOf(payload), getPublicKey(app));
|
||||
expect(verified.valid).toBe(true);
|
||||
if (verified.valid) {
|
||||
expect(verified.payload).toEqual(
|
||||
|
|
@ -348,11 +424,11 @@ describe("Heimdall service", () => {
|
|||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const payload = response.json();
|
||||
const authorizationUrl = new URL(payload.authorizationUrl as string);
|
||||
const authorizationUrl = await providerRedirect(app, payload);
|
||||
expect(`${authorizationUrl.origin}${authorizationUrl.pathname}`).toBe("https://www.patreon.com/oauth2/authorize");
|
||||
expect(authorizationUrl.searchParams.get("scope")).toBe("identity identity[email]");
|
||||
|
||||
const verified = verifyJwt(payload.stateToken as string, getPublicKey(app));
|
||||
const verified = verifyJwt(stateOf(payload), getPublicKey(app));
|
||||
expect(verified.valid).toBe(true);
|
||||
if (verified.valid) {
|
||||
expect(verified.payload).toEqual(
|
||||
|
|
@ -396,9 +472,9 @@ describe("Heimdall service", () => {
|
|||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const payload = response.json();
|
||||
expect(payload.authorizationUrl).toContain("discord.com/oauth2/authorize");
|
||||
expect((await providerRedirect(app, payload)).href).toContain("discord.com/oauth2/authorize");
|
||||
|
||||
const verified = verifyJwt(payload.stateToken as string, getPublicKey(app));
|
||||
const verified = verifyJwt(stateOf(payload), getPublicKey(app));
|
||||
expect(verified.valid).toBe(true);
|
||||
if (verified.valid) {
|
||||
expect(verified.payload).toEqual(
|
||||
|
|
@ -442,10 +518,10 @@ describe("Heimdall service", () => {
|
|||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const payload = response.json();
|
||||
const authorizationUrl = new URL(payload.authorizationUrl as string);
|
||||
const authorizationUrl = await providerRedirect(app, payload);
|
||||
expect(`${authorizationUrl.origin}${authorizationUrl.pathname}`).toBe("https://www.patreon.com/oauth2/authorize");
|
||||
|
||||
const verified = verifyJwt(payload.stateToken as string, getPublicKey(app));
|
||||
const verified = verifyJwt(stateOf(payload), getPublicKey(app));
|
||||
expect(verified.valid).toBe(true);
|
||||
if (verified.valid) {
|
||||
expect(verified.payload).toEqual(
|
||||
|
|
@ -473,10 +549,11 @@ describe("Heimdall service", () => {
|
|||
});
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
|
|
@ -689,10 +766,11 @@ describe("Heimdall service", () => {
|
|||
});
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const callbackResponse = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
const completionCode = callbackResponse.json().completion.code as string;
|
||||
|
||||
|
|
@ -731,10 +809,11 @@ describe("Heimdall service", () => {
|
|||
const auditEvents = () =>
|
||||
[...(store as unknown as { auditEvents: Map<string, { eventType: string; sessionId?: string; eventPayloadJson: unknown }> }).auditEvents.values()];
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
const { code, expiresAt } = callback.json().completion as { code: string; expiresAt: string };
|
||||
const created = auditEvents().filter((event) => event.eventType === "auth_completion_created");
|
||||
|
|
@ -815,10 +894,11 @@ describe("Heimdall service", () => {
|
|||
});
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const callbackResponse = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callbackResponse.statusCode).toBe(201);
|
||||
const refreshToken = callbackResponse.json().refreshToken as string;
|
||||
|
|
@ -862,11 +942,12 @@ describe("Heimdall service", () => {
|
|||
});
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: {
|
||||
cookie: flow.cookie,
|
||||
accept: "text/html",
|
||||
},
|
||||
});
|
||||
|
|
@ -912,12 +993,13 @@ describe("Heimdall service", () => {
|
|||
},
|
||||
});
|
||||
expect(startResponse.statusCode).toBe(201);
|
||||
const stateToken = startResponse.json().stateToken as string;
|
||||
const flow = await launchFlow(app, startResponse.json());
|
||||
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: {
|
||||
cookie: flow.cookie,
|
||||
accept: "text/html",
|
||||
},
|
||||
});
|
||||
|
|
@ -1123,11 +1205,12 @@ describe("Heimdall service", () => {
|
|||
returnTo: "https://streampixels.gamecult.org/auth/connect",
|
||||
},
|
||||
});
|
||||
const stateToken = startResponse.json().stateToken as string;
|
||||
const flow = await launchFlow(app, startResponse.json());
|
||||
|
||||
const callbackResponse = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/twitch/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/twitch/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
const accountId = callbackResponse.json().account.id as string;
|
||||
|
||||
|
|
@ -1210,11 +1293,12 @@ describe("Heimdall service", () => {
|
|||
returnTo: "https://streampixels.gamecult.org/auth/connect",
|
||||
},
|
||||
});
|
||||
const stateToken = startResponse.json().stateToken as string;
|
||||
const flow = await launchFlow(app, startResponse.json());
|
||||
|
||||
const callbackResponse = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/twitch/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/twitch/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
const accountId = callbackResponse.json().account.id as string;
|
||||
|
||||
|
|
@ -1276,10 +1360,11 @@ describe("Heimdall service", () => {
|
|||
});
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const callbackResponse = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callbackResponse.statusCode).toBe(201);
|
||||
const evaluationsAtSignIn = evaluations;
|
||||
|
|
@ -1355,17 +1440,136 @@ describe("Heimdall service", () => {
|
|||
expect(urls).toEqual([]);
|
||||
});
|
||||
|
||||
// Targets made only of whitespace, format characters, controls and the invisible fillers that render as nothing.
|
||||
const BLANK_TARGETS = [
|
||||
" ", "\t", "\n ", "\u200B", "\u00A0\uFEFF",
|
||||
"\u2800", "\u3164", "\u115F", "\u1160", "\uFFA0", "\u034F", "\u0000", "\u0007", " \u2800\u3164 ",
|
||||
// Marks, private-use, unassigned and lone-surrogate code points, and the symbols that read as nothing: none is a letter or a number.
|
||||
"\u0300", "\uE000", "\u0378", "\uD800", "\u{16FE4}", "\u{1D159}", "\u{F0000}", "\u0300\uE000 ",
|
||||
];
|
||||
// A target is usable when it holds a letter or a number that is not an invisible filler.
|
||||
const NAMING_TARGETS = ["creator-1", " creator-1 ", "Framgång", "42", "\u2800a\u3164", "\u3164\u0300x"];
|
||||
|
||||
describe("a connect start that names a connection target is the app backend's", () => {
|
||||
// The target is app-backend authority: the StreamPixels backend proves the creator-manage session and states the
|
||||
// creator it started the connect for. Anyone else naming {creator, X} would have X's connector rebound to their
|
||||
// own OAuth account at StreamPixels' redeem.
|
||||
const returnTo = "https://streampixels.gamecult.org/auth/connect";
|
||||
const managed = ["twitch", "youtube", "joystick"] as const;
|
||||
const startFor = (app: FastifyInstance, provider: string, connection: unknown, headers: Record<string, string> = {}) =>
|
||||
app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/oauth/${provider}/start`,
|
||||
headers,
|
||||
payload: { appSlug: "streampixels", mode: "connect", returnTo, connection },
|
||||
});
|
||||
const own = { "x-heimdall-app-secret": "streampixels-secret" };
|
||||
|
||||
it.each(managed)("%s: a creator target is refused without the app's own secret and minted for it", async (provider) => {
|
||||
const config = createTestConfig();
|
||||
const app = await buildApp({ config });
|
||||
apps.push(app);
|
||||
const creator = { kind: "creator", targetId: "victim-creator" };
|
||||
|
||||
for (const headers of [{}, { "x-heimdall-app-secret": "repixelizer-secret" }, { "x-heimdall-app-secret": "wrong" }]) {
|
||||
const refused = await startFor(app, provider, creator, headers);
|
||||
expect([refused.statusCode, refused.json()]).toEqual([401, { error: "app_auth_required" }]);
|
||||
expect(refused.body).not.toContain("authorizationUrl");
|
||||
}
|
||||
const started = await startFor(app, provider, creator, own);
|
||||
expect(started.statusCode).toBe(201);
|
||||
const verified = verifyJwt(stateOf(started.json()), getPublicKey(app));
|
||||
expect(verified.valid && verified.payload).toEqual(expect.objectContaining({ connection: expect.objectContaining(creator) }));
|
||||
|
||||
// A direct caller (the command plane hands startOAuthFlow its own) is held to the slug too.
|
||||
const input = { appSlug: "streampixels" as const, mode: "connect" as const, returnTo, connection: { kind: "creator" as const, targetId: "victim-creator" } };
|
||||
const foreign = resolveAppCaller(config, "repixelizer", { "x-heimdall-app-secret": "repixelizer-secret" });
|
||||
expect((await startOAuthFlow(getHeimdallRuntimeContext(app), provider, foreign, input)).statusCode).toBe(401);
|
||||
expect((await startOAuthFlow(getHeimdallRuntimeContext(app), provider, null, input)).statusCode).toBe(401);
|
||||
});
|
||||
|
||||
it.each(["twitch", "youtube"] as const)("%s: any connection kind needs the app's secret, not only creator", async (provider) => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
const account = { kind: "account", targetId: "victim-account" };
|
||||
|
||||
const refused = await startFor(app, provider, account);
|
||||
expect([refused.statusCode, refused.json()]).toEqual([401, { error: "app_auth_required" }]);
|
||||
expect((await startFor(app, provider, account, own)).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it.each(managed)("%s: a blank target is refused even for the app, whatever the blank is made of", async (provider) => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
for (const kind of ["creator", "account"]) {
|
||||
for (const targetId of BLANK_TARGETS) {
|
||||
const refused = await startFor(app, provider, { kind, targetId }, own);
|
||||
expect([refused.statusCode, refused.json().error], `${kind} ${JSON.stringify(targetId)}`).toEqual([400, "invalid_connection_target"]);
|
||||
expect(refused.body).not.toContain("authorizationUrl");
|
||||
}
|
||||
}
|
||||
for (const targetId of NAMING_TARGETS) {
|
||||
expect((await startFor(app, provider, { kind: "creator", targetId }, own)).statusCode, JSON.stringify(targetId)).toBe(201);
|
||||
}
|
||||
});
|
||||
|
||||
it.each(managed)("%s: a blank target without the app's secret gets 401, not the 400 that would tell a stranger what the gate checks", async (provider) => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
for (const headers of [{}, { "x-heimdall-app-secret": "wrong" }]) {
|
||||
for (const targetId of [" ", "\u2800"]) {
|
||||
const refused = await startFor(app, provider, { kind: "creator", targetId }, headers);
|
||||
expect([refused.statusCode, refused.json()], JSON.stringify(targetId)).toEqual([401, { error: "app_auth_required" }]);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("the callback mint holds a blank creator target to the same bar", () => {
|
||||
const streampixels = builtInAppProfiles.streampixels!;
|
||||
for (const targetId of BLANK_TARGETS) {
|
||||
expect(callbackMint(streampixels, "joystick", "connect", { kind: "creator", targetId }), JSON.stringify(targetId)).toBe("refused");
|
||||
}
|
||||
// A visible character among the blanks names a target.
|
||||
expect(callbackMint(streampixels, "joystick", "connect", { kind: "creator", targetId: "\u2800a\u3164" })).toBe("custody_only");
|
||||
for (const targetId of NAMING_TARGETS) {
|
||||
expect(callbackMint(streampixels, "joystick", "connect", { kind: "creator", targetId }), JSON.stringify(targetId)).toBe("custody_only");
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("joystick connect", () => {
|
||||
const creator = { kind: "creator", targetId: "creator-1" };
|
||||
async function connect(app: FastifyInstance, extra: Record<string, unknown> = { connection: creator }) {
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/start",
|
||||
headers: { "x-heimdall-app-secret": "streampixels-secret" },
|
||||
payload: { appSlug: "streampixels", mode: "connect", returnTo: "https://streampixels.gamecult.org/auth/connect", ...extra },
|
||||
});
|
||||
return start;
|
||||
}
|
||||
|
||||
it("gates a connect start that names a creator on the app's own secret: none and a foreign app's are 401, its own is 201", async () => {
|
||||
const config = createTestConfig();
|
||||
const app = await buildApp({ config });
|
||||
apps.push(app);
|
||||
const body = { appSlug: "streampixels", mode: "connect", returnTo: "https://streampixels.gamecult.org/auth/connect", connection: creator };
|
||||
const start = (headers: Record<string, string>) => app.inject({ method: "POST", url: "/v1/oauth/joystick/start", headers, payload: body });
|
||||
|
||||
for (const headers of [{}, { "x-heimdall-app-secret": "repixelizer-secret" }, { "x-heimdall-app-secret": "wrong" }]) {
|
||||
const refused = await start(headers);
|
||||
expect([refused.statusCode, refused.json()]).toEqual([401, { error: "app_auth_required" }]);
|
||||
}
|
||||
expect((await start({ "x-heimdall-app-secret": "streampixels-secret" })).statusCode).toBe(201);
|
||||
|
||||
// A direct caller (the command plane hands startOAuthFlow its own) is held to the slug too.
|
||||
const input = { appSlug: "streampixels" as const, mode: "connect" as const, returnTo: body.returnTo, connection: { kind: "creator" as const, targetId: "creator-1" } };
|
||||
const foreign = resolveAppCaller(config, "repixelizer", { "x-heimdall-app-secret": "repixelizer-secret" });
|
||||
expect((await startOAuthFlow(getHeimdallRuntimeContext(app), "joystick", foreign, input)).statusCode).toBe(401);
|
||||
});
|
||||
|
||||
it.each([
|
||||
["no connection", {}, "creator_connection_required"],
|
||||
["an account connection", { connection: { kind: "account", targetId: "victim-1" } }, "creator_connection_required"],
|
||||
|
|
@ -1377,7 +1581,7 @@ describe("Heimdall service", () => {
|
|||
expect(start.statusCode).toBe(400);
|
||||
expect(start.json().error).toBe(error);
|
||||
expect(start.json().authorizationUrl).toBeUndefined();
|
||||
expect(start.json().stateToken).toBeUndefined();
|
||||
expect(start.json()).not.toHaveProperty("stateToken");
|
||||
});
|
||||
|
||||
it.each([
|
||||
|
|
@ -1393,14 +1597,15 @@ describe("Heimdall service", () => {
|
|||
apps.push(app);
|
||||
const keys = createRuntimeKeyMaterial({ ...config, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
const calls = stubJoystick({ channel_id: "chan-forged", username: "deru" });
|
||||
const stateToken = (await connect(app)).json().stateToken as string;
|
||||
const verified = verifyJwt(stateToken, keys.publicKey);
|
||||
const flow = await launchFlow(app, (await connect(app)).json());
|
||||
const verified = verifyJwt(flow.state, keys.publicKey);
|
||||
expect(verified.valid).toBe(true);
|
||||
const forged = signJwt({ ...(verified as { payload: Record<string, unknown> }).payload, connection }, keys);
|
||||
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(forged)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBeGreaterThanOrEqual(400);
|
||||
expect(calls).toEqual([]);
|
||||
|
|
@ -1432,9 +1637,11 @@ describe("Heimdall service", () => {
|
|||
handoff: { kind: "backend_callback", attemptId: "attempt-js-1", callbackUrl },
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(start.json().stateToken as string)}`,
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBeLessThan(300);
|
||||
|
||||
|
|
@ -1453,7 +1660,7 @@ describe("Heimdall service", () => {
|
|||
apps.push(app);
|
||||
const start = await connect(app);
|
||||
expect(start.statusCode).toBe(201);
|
||||
const url = new URL(start.json().authorizationUrl as string);
|
||||
const url = await providerRedirect(app, start.json());
|
||||
expect(`${url.origin}${url.pathname}`).toBe("https://joystick.tv/api/oauth/authorize");
|
||||
expect(url.searchParams.get("client_id")).toBe("joystick-client");
|
||||
expect(url.searchParams.get("scope")).toBe("identity:read stream:read chat:read followers:read subscribers:read");
|
||||
|
|
@ -1467,10 +1674,11 @@ describe("Heimdall service", () => {
|
|||
const app = await buildApp({ config: createTestConfig(), store });
|
||||
apps.push(app);
|
||||
stubJoystick({ channel_id: "deru-chan", username: "deru" });
|
||||
const stateToken = (await connect(app)).json().stateToken as string;
|
||||
const flow = await launchFlow(app, (await connect(app)).json());
|
||||
const connected = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=a&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/joystick/callback?code=a&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
const accountId = connected.json().account.id as string;
|
||||
const before = await store.findStoredLinkedIdentityForAccount(accountId, "joystick");
|
||||
|
|
@ -1518,14 +1726,15 @@ describe("Heimdall service", () => {
|
|||
apps.push(app);
|
||||
const keys = createRuntimeKeyMaterial({ ...config, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
const calls = stubJoystick({ channel_id: "chan-forged", username: "deru" });
|
||||
const stateToken = (await connect(app)).json().stateToken as string;
|
||||
const verified = verifyJwt(stateToken, keys.publicKey);
|
||||
const flow = await launchFlow(app, (await connect(app)).json());
|
||||
const verified = verifyJwt(flow.state, keys.publicKey);
|
||||
expect(verified.valid).toBe(true);
|
||||
const forged = signJwt({ ...(verified as { payload: Record<string, unknown> }).payload, mode }, keys);
|
||||
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(forged)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBeGreaterThanOrEqual(400);
|
||||
expect(callback.body).not.toContain("viewer_access");
|
||||
|
|
@ -1542,11 +1751,12 @@ describe("Heimdall service", () => {
|
|||
const app = await buildApp({ config: createTestConfig(), store });
|
||||
apps.push(app);
|
||||
const calls = stubJoystick({ channel_id: "chan-9", username: "deru", nickname: "Deru!", photo_url: "https://img/x.png" });
|
||||
const stateToken = (await connect(app)).json().stateToken as string;
|
||||
const flow = await launchFlow(app, (await connect(app)).json());
|
||||
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=the-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/joystick/callback?code=the-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBeLessThan(300);
|
||||
|
||||
|
|
@ -1575,10 +1785,11 @@ describe("Heimdall service", () => {
|
|||
const app = await buildApp({ config: createTestConfig(), store });
|
||||
apps.push(app);
|
||||
stubJoystick({ channel_id: "chan-9", username: "deru" });
|
||||
const stateToken = (await connect(app)).json().stateToken as string;
|
||||
const flow = await launchFlow(app, (await connect(app)).json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
const row = await store.findStoredLinkedIdentityForAccount(callback.json().account.id as string, "joystick");
|
||||
expect(row?.displayName).toBe("deru");
|
||||
|
|
@ -1589,10 +1800,11 @@ describe("Heimdall service", () => {
|
|||
const app = await buildApp({ config: createTestConfig(), store });
|
||||
apps.push(app);
|
||||
stubJoystick({ username: "deru" });
|
||||
const stateToken = (await connect(app)).json().stateToken as string;
|
||||
const flow = await launchFlow(app, (await connect(app)).json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBeGreaterThanOrEqual(400);
|
||||
expect(await store.findStoredLinkedIdentity("joystick", "undefined")).toBeNull();
|
||||
|
|
@ -1787,11 +1999,11 @@ describe("error answers never echo an input", () => {
|
|||
const app = await buildApp({ config: createTestConfig(), oauthRuntimes: { discord: failingDiscordRuntime() } });
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
headers: { accept: "text/html" },
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie, accept: "text/html" },
|
||||
});
|
||||
|
||||
expect(response.headers["content-type"]).toContain("text/html");
|
||||
|
|
@ -1823,9 +2035,11 @@ describe("error answers never echo an input", () => {
|
|||
},
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(start.json().stateToken as string)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(502);
|
||||
|
|
@ -1843,16 +2057,16 @@ describe("the relayed provider error", () => {
|
|||
const injected = `<script>alert(1)</script>"\\\u0007é${"x".repeat(300)}`;
|
||||
const allowed = /^[\x20-\x21\x23-\x5b\x5d-\x7e]*$/;
|
||||
|
||||
function providerErrorUrl(stateToken: string): string {
|
||||
const query = new URLSearchParams({ state: stateToken, error: `${"e".repeat(100)}\u0000`, error_description: injected });
|
||||
return `/v1/oauth/discord/callback?${query.toString()}`;
|
||||
function providerErrorRequest(flow: LaunchedFlow) {
|
||||
const query = new URLSearchParams({ state: flow.state, error: `${"e".repeat(100)}\u0000`, error_description: injected });
|
||||
return { method: "GET" as const, url: `/v1/oauth/discord/callback?${query.toString()}`, headers: { cookie: flow.cookie } };
|
||||
}
|
||||
|
||||
it("is printable and bounded in the JSON answer", async () => {
|
||||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
const response = await app.inject({ method: "GET", url: providerErrorUrl(await startDiscordSignIn(app)) });
|
||||
const response = await app.inject(providerErrorRequest(await startDiscordSignIn(app)));
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
const { providerError, providerErrorDescription } = response.json() as Record<string, string>;
|
||||
|
|
@ -1866,11 +2080,8 @@ describe("the relayed provider error", () => {
|
|||
const app = await buildApp({ config: createTestConfig() });
|
||||
apps.push(app);
|
||||
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: providerErrorUrl(await startDiscordSignIn(app)),
|
||||
headers: { accept: "text/html" },
|
||||
});
|
||||
const request = providerErrorRequest(await startDiscordSignIn(app));
|
||||
const response = await app.inject({ ...request, headers: { ...request.headers, accept: "text/html" } });
|
||||
|
||||
expect(response.headers["content-type"]).toContain("text/html");
|
||||
expect(response.body.match(/<script/gi)).toHaveLength(1);
|
||||
|
|
@ -1902,7 +2113,7 @@ describe("the relayed provider error", () => {
|
|||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
|
||||
await app.inject({ method: "GET", url: providerErrorUrl(start.json().stateToken as string) });
|
||||
await app.inject(providerErrorRequest(await launchFlow(app, start.json())));
|
||||
|
||||
expect(deliveries).toHaveLength(1);
|
||||
const description = String(deliveries[0]!.errorDescription);
|
||||
|
|
@ -1928,10 +2139,11 @@ describe("the failed-callback audit event", () => {
|
|||
});
|
||||
apps.push(app);
|
||||
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(response.statusCode).toBe(502);
|
||||
|
||||
|
|
@ -1955,10 +2167,11 @@ describe("the failed-callback audit event for a provider's HTTP refusal", () =>
|
|||
const store = new InMemoryStore();
|
||||
const app = await buildApp({ config: createTestConfig(), store, oauthRuntimes: createOAuthRuntimeRegistry() });
|
||||
apps.push(app);
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
const flow = await startDiscordSignIn(app);
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}`,
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBe(502);
|
||||
const events = [...(store as unknown as { auditEvents: Map<string, { eventType: string; eventPayloadJson: unknown }> }).auditEvents.values()];
|
||||
|
|
@ -2012,8 +2225,12 @@ describe("the failed-callback audit event for a provider's HTTP refusal", () =>
|
|||
},
|
||||
});
|
||||
apps.push(app);
|
||||
const stateToken = await startDiscordSignIn(app);
|
||||
await app.inject({ method: "GET", url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(stateToken)}` });
|
||||
const flow = await startDiscordSignIn(app);
|
||||
await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=test-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
|
||||
const events = [...(store as unknown as { auditEvents: Map<string, { eventType: string; eventPayloadJson: Record<string, unknown> }> }).auditEvents.values()];
|
||||
const failed = events.find((event) => event.eventType === "oauth_callback_failed");
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ import { InMemoryStore } from "../src/store/index.js";
|
|||
import { PostgresStore } from "../src/store/postgres.js";
|
||||
import { CREATE_SCHEMA_SQL } from "../src/store/schema.js";
|
||||
import { type CreateAuthCompletionInput, type HeimdallStore } from "../src/store/types.js";
|
||||
import { launchState, stateOf } from "./oauth-flow.js";
|
||||
|
||||
const ghostlightSecret = "ghostlight-private-command-secret";
|
||||
const resources: Array<{ close(): Promise<unknown> }> = [];
|
||||
|
|
@ -66,6 +67,7 @@ function testConfig(overrides: Partial<HeimdallConfig> = {}): HeimdallConfig {
|
|||
youtube: {},
|
||||
spotify: {},
|
||||
joystick: {},
|
||||
google: {},
|
||||
},
|
||||
...overrides,
|
||||
};
|
||||
|
|
@ -102,10 +104,11 @@ async function start(app: App, payload: unknown, headers: Record<string, string>
|
|||
}
|
||||
|
||||
async function completeAs(app: App, stateToken: string, who: string) {
|
||||
const { cookie } = await launchState(app, stateToken);
|
||||
return app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=${who}&state=${encodeURIComponent(stateToken)}`,
|
||||
headers: { accept: "application/json" },
|
||||
headers: { accept: "application/json", cookie },
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -213,7 +216,7 @@ describe("R21.1: the attempt handle is unreachable from the public start route",
|
|||
});
|
||||
expect(response.statusCode, response.body).toBe(201);
|
||||
expect(response.json().handoff).toEqual({ kind: "browser_completion" });
|
||||
const state = jwtPayload(response.json().stateToken as string);
|
||||
const state = jwtPayload(stateOf(response.json()));
|
||||
expect(state.handoff).toEqual({ kind: "browser_completion" });
|
||||
expect(JSON.stringify(state)).not.toContain(attempt.handle);
|
||||
});
|
||||
|
|
@ -237,7 +240,7 @@ describe("R21.1: the attempt handle is unreachable from the public start route",
|
|||
expect(response.body).not.toContain(planted);
|
||||
if (response.statusCode === 201) {
|
||||
expect(response.json().handoff).toEqual({ kind: "browser_completion" });
|
||||
expect(jwtPayload(response.json().stateToken as string).handoff).toEqual({ kind: "browser_completion" });
|
||||
expect(jwtPayload(stateOf(response.json())).handoff).toEqual({ kind: "browser_completion" });
|
||||
} else {
|
||||
expect(response.statusCode, response.body).toBe(400);
|
||||
}
|
||||
|
|
@ -249,7 +252,7 @@ describe("R21.1: the attempt handle is unreachable from the public start route",
|
|||
const response = await start(app, { appSlug: "ghostlight", mode: "sign_in", returnTo: legitReturn, ...extra });
|
||||
expect(response.statusCode, response.body).toBe(201);
|
||||
expect(response.body).not.toContain(planted);
|
||||
expect(jwtPayload(response.json().stateToken as string).handoff).toEqual({ kind: "browser_completion" });
|
||||
expect(jwtPayload(stateOf(response.json())).handoff).toEqual({ kind: "browser_completion" });
|
||||
}
|
||||
});
|
||||
|
||||
|
|
@ -264,8 +267,8 @@ describe("R21.1: the attempt handle is unreachable from the public start route",
|
|||
const calls = source.match(/(?<!function )startOAuthFlow\(/g) ?? [];
|
||||
if (calls.length) callers.push(`${file}:${calls.length}`);
|
||||
if (file.endsWith("app.ts")) {
|
||||
// The HTTP route's call ends at the body; no fifth argument.
|
||||
expect(source).toMatch(/startOAuthFlow\(\{ config, keys, store \}, request\.params\.provider, caller, request\.body\);/);
|
||||
// The HTTP route passes only the bearer-derived linkAccountId; never an attempt handle.
|
||||
expect(source).toMatch(/startOAuthFlow\(\{ config, keys, store \}, request\.params\.provider, caller, request\.body, \{\s*\.\.\.\(linkAccountId !== undefined \? \{ linkAccountId \} : \{\}\),\s*\}\);/);
|
||||
}
|
||||
}
|
||||
expect(callers.sort()).toEqual(["app.ts:1", "private-command-plane.ts:1"]);
|
||||
|
|
@ -306,7 +309,7 @@ describe("R21.1: the attempt handle is unreachable from the public start route",
|
|||
handoff: { kind: "browser_completion", attemptId: handle },
|
||||
});
|
||||
expect(attackerStart.statusCode).toBe(201);
|
||||
const attackerCallback = await completeAs(app, attackerStart.json().stateToken as string, "attacker");
|
||||
const attackerCallback = await completeAs(app, stateOf(attackerStart.json()), "attacker");
|
||||
expect(attackerCallback.statusCode, attackerCallback.body).toBe(201);
|
||||
expect((await store.findAuthAttempt("ghostlight", handle))?.status).toBe("pending");
|
||||
|
||||
|
|
@ -340,7 +343,7 @@ describe("R21.1: the attempt handle is unreachable from the public start route",
|
|||
expect(response.statusCode, response.body).toBe(201);
|
||||
// Delivery to port 1 fails; whatever the callback returns, the attempt
|
||||
// must be untouched and no completion may be bound to it.
|
||||
await completeAs(app, response.json().stateToken as string, "attacker");
|
||||
await completeAs(app, stateOf(response.json()), "attacker");
|
||||
expect((await store.findAuthAttempt("ghostlight", attempt.handle))?.status).toBe("pending");
|
||||
expect(await store.consumeAuthCompletionByAttempt("ghostlight", attempt.handle, new Date().toISOString())).toBeNull();
|
||||
});
|
||||
|
|
@ -363,7 +366,7 @@ describe("R21.2: the WeakSet brand at every consumer", () => {
|
|||
if (line.includes("caller.appSlug")) expect(line, `${file}: ${line.trim()}`).toContain("isAppCaller(caller)");
|
||||
}
|
||||
}
|
||||
expect(consumers).toEqual(["app.ts: reads=2 guards=2"]);
|
||||
expect(consumers).toEqual(["app.ts: reads=4 guards=4"]);
|
||||
});
|
||||
|
||||
it("a caller minted for app A is refused where app B is expected, over HTTP and by direct call", async () => {
|
||||
|
|
@ -493,26 +496,27 @@ partialUniqueIndexContract("PostgresStore over pg-mem", async () => {
|
|||
});
|
||||
|
||||
describe("duplicate-handle error surfacing through the callback route", () => {
|
||||
it("state tokens are replayable, and a replay while the handle's completion is unconsumed echoes the store error in a 502", async () => {
|
||||
it("a replayed state is refused as already used before any exchange, and leaves the real completion intact", async () => {
|
||||
const { app, store, begin } = await planeHarness();
|
||||
const receipt = await begin("begin-replay");
|
||||
const handle = String(receipt.handle);
|
||||
const state = new URL((receipt.navigation as { url: string }).url).searchParams.get("state") ?? "";
|
||||
const first = await completeAs(app, state, "victim");
|
||||
const { cookie } = await launchState(app, state);
|
||||
const callbackWith = () =>
|
||||
app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=victim&state=${encodeURIComponent(state)}`,
|
||||
headers: { accept: "application/json", cookie },
|
||||
});
|
||||
const first = await callbackWith();
|
||||
expect(first.statusCode).toBe(201);
|
||||
const replay = await completeAs(app, state, "victim");
|
||||
// Nothing consumed the state's jti, so the second exchange still runs and
|
||||
// reaches createAuthCompletion, where the unique index refuses it. The
|
||||
// route's catch (app.ts ~1290) now answers with a fixed detail rather than
|
||||
// the store's own text, so a Postgres 23505 cannot hand the caller a
|
||||
// constraint name. The full text stays in the audit event.
|
||||
expect(replay.statusCode, replay.body).toBe(502);
|
||||
expect(replay.json()).toMatchObject({
|
||||
error: "oauth_callback_failed",
|
||||
detail: "The provider callback could not be completed.",
|
||||
});
|
||||
expect(JSON.stringify(replay.json())).not.toContain("unconsumed completion");
|
||||
// The failed replay must not have damaged the real completion.
|
||||
// The state's jti was consumed by the first callback, so the second never
|
||||
// reaches createAuthCompletion, whose unique index used to be the only
|
||||
// thing refusing a replay (and whose Postgres 23505 text the route had to
|
||||
// keep out of the answer).
|
||||
const replay = await callbackWith();
|
||||
expect(replay.statusCode, replay.body).toBe(400);
|
||||
expect(replay.json()).toEqual({ error: "state_already_used" });
|
||||
expect((await store.findAuthAttempt("ghostlight", handle))?.status).toBe("completed");
|
||||
expect(await store.consumeAuthCompletionByAttempt("ghostlight", handle, new Date().toISOString())).toBeTruthy();
|
||||
});
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ import { type HeimdallConfig } from "../src/config.js";
|
|||
import { entitlementFacts } from "../src/facts.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { launchState, stateOf } from "./oauth-flow.js";
|
||||
|
||||
const resources: Array<{ close(): Promise<unknown> }> = [];
|
||||
|
||||
|
|
@ -52,6 +53,7 @@ function testConfig(): HeimdallConfig {
|
|||
youtube: {},
|
||||
spotify: {},
|
||||
joystick: {},
|
||||
google: {},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
|
@ -86,10 +88,11 @@ async function start(app: App, payload: Record<string, unknown>, headers: Record
|
|||
}
|
||||
|
||||
async function completeAs(app: App, stateToken: string, who: string) {
|
||||
const { cookie } = await launchState(app, stateToken);
|
||||
return app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=${who}&state=${encodeURIComponent(stateToken)}`,
|
||||
headers: { accept: "application/json" },
|
||||
headers: { accept: "application/json", cookie },
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -110,7 +113,7 @@ describe("takeover chain: caller-chosen attemptId is never the redemption code",
|
|||
});
|
||||
expect(started.statusCode).toBe(201);
|
||||
|
||||
const callback = await completeAs(app, started.json().stateToken as string, "victim");
|
||||
const callback = await completeAs(app, stateOf(started.json()), "victim");
|
||||
expect(callback.statusCode).toBe(201);
|
||||
const minted = callback.json().completion.code as string;
|
||||
expect(minted).not.toBe("attacker-fixed");
|
||||
|
|
@ -125,7 +128,7 @@ describe("takeover chain: caller-chosen attemptId is never the redemption code",
|
|||
const { app, store } = await harness();
|
||||
const started = await start(app, { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" });
|
||||
expect(started.statusCode).toBe(201);
|
||||
const callback = await completeAs(app, started.json().stateToken as string, "victim");
|
||||
const callback = await completeAs(app, stateOf(started.json()), "victim");
|
||||
expect(callback.statusCode).toBe(201);
|
||||
const code = callback.json().completion.code as string;
|
||||
expect(code).toMatch(uuidV4);
|
||||
|
|
@ -159,7 +162,7 @@ describe("takeover chain: caller-chosen attemptId is never the redemption code",
|
|||
it("attemptId set to a real victim completion code does not let the attacker's flow touch the victim's completion", async () => {
|
||||
const { app } = await harness();
|
||||
const victimStart = await start(app, { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" });
|
||||
const victimCallback = await completeAs(app, victimStart.json().stateToken as string, "victim");
|
||||
const victimCallback = await completeAs(app, stateOf(victimStart.json()), "victim");
|
||||
const victimCode = victimCallback.json().completion.code as string;
|
||||
|
||||
const attackerStart = await start(app, {
|
||||
|
|
@ -168,7 +171,7 @@ describe("takeover chain: caller-chosen attemptId is never the redemption code",
|
|||
returnTo: "https://repixelizer.gamecult.org/app/",
|
||||
handoff: { kind: "browser_completion", attemptId: victimCode },
|
||||
});
|
||||
const attackerCallback = await completeAs(app, attackerStart.json().stateToken as string, "attacker");
|
||||
const attackerCallback = await completeAs(app, stateOf(attackerStart.json()), "attacker");
|
||||
expect(attackerCallback.statusCode).toBe(201);
|
||||
expect(attackerCallback.json().completion.code).not.toBe(victimCode);
|
||||
|
||||
|
|
@ -204,7 +207,7 @@ describe("consumeAuthCompletion: single-use, scoped, expiring", () => {
|
|||
it("a code redeems exactly once under concurrent redemption, and never for another app", async () => {
|
||||
const { app } = await harness();
|
||||
const started = await start(app, { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" });
|
||||
const callback = await completeAs(app, started.json().stateToken as string, "victim");
|
||||
const callback = await completeAs(app, stateOf(started.json()), "victim");
|
||||
const code = callback.json().completion.code as string;
|
||||
|
||||
const crossApp = await redeem(app, "bifrost", code);
|
||||
|
|
@ -265,7 +268,7 @@ describe("attempt-handle binding: the public start route may attach a completion
|
|||
handoff: { kind: "browser_completion", attemptId: attempt.handle },
|
||||
});
|
||||
expect(attackerStart.statusCode).toBe(201);
|
||||
await completeAs(app, attackerStart.json().stateToken as string, "attacker");
|
||||
await completeAs(app, stateOf(attackerStart.json()), "attacker");
|
||||
|
||||
const after = await store.findAuthAttempt("ghostlight", attempt.handle);
|
||||
expect(after?.status).toBe("pending");
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ import { type OAuthProviderRuntime } from "../src/oauth.js";
|
|||
import { startHeimdallPrivateCommandPlane } from "../src/private-command-plane.js";
|
||||
import { sealPrivateEnvelope, type HeimdallPrivateEnvelope } from "../src/private-command-security.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { launchFlow } from "./oauth-flow.js";
|
||||
|
||||
const ghostlightSecret = "ghostlight-private-command-secret";
|
||||
const resources: Array<{ close(): Promise<unknown> }> = [];
|
||||
|
|
@ -60,6 +61,7 @@ function testConfig(): HeimdallConfig {
|
|||
youtube: {},
|
||||
spotify: {},
|
||||
joystick: {},
|
||||
google: {},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
|
@ -104,10 +106,11 @@ describe("caller identity: unauthenticated mint paths", () => {
|
|||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=victim-code&state=${encodeURIComponent(start.json().stateToken as string)}`,
|
||||
headers: { accept: "text/html" },
|
||||
url: `/v1/oauth/discord/callback?code=victim-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { accept: "text/html", cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBe(200);
|
||||
|
||||
|
|
|
|||
65
tests/consent-drift.test.ts
Normal file
65
tests/consent-drift.test.ts
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
import { afterEach, expect, it, vi } from "vitest";
|
||||
import { type FastifyInstance } from "fastify";
|
||||
|
||||
// The receipt records the wording the person was shown. If the wording changes
|
||||
// between the ask and the callback (a deploy inside the state's lifetime), the
|
||||
// receipt must still hold what they saw.
|
||||
|
||||
const drift = vi.hoisted(() => ({ on: false }));
|
||||
vi.mock("../src/consent.js", async (importOriginal) => {
|
||||
const real = await importOriginal<typeof import("../src/consent.js")>();
|
||||
return { ...real, consentText: (ask: Parameters<typeof real.consentText>[0]) => real.consentText(ask) + (drift.on ? "\nREWORDED AFTER THE ASK" : "") };
|
||||
});
|
||||
|
||||
import { buildApp } from "../src/app.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { createTestConfig, setCookieOf, stateOf } from "./oauth-flow.js";
|
||||
|
||||
const apps: FastifyInstance[] = [];
|
||||
afterEach(async () => {
|
||||
drift.on = false;
|
||||
while (apps.length) await apps.pop()?.close();
|
||||
});
|
||||
|
||||
it("a receipt holds the wording of the ask, not wording rebuilt at the callback", async () => {
|
||||
const store = new InMemoryStore();
|
||||
const app = await buildApp({
|
||||
config: createTestConfig(),
|
||||
store,
|
||||
oauthRuntimes: {
|
||||
joystick: {
|
||||
async exchangeAuthorizationCode() {
|
||||
return { accessToken: "joy-access-code-a", refreshToken: "r", tokenType: "Bearer", scope: ["identity:read"], expiresAt: "2099-01-01T00:00:00.000Z", raw: {} };
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return { provider: "joystick", providerUserId: "joy-a", username: "a", profile: {} };
|
||||
},
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
apps.push(app);
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/start",
|
||||
headers: { "x-heimdall-app-secret": "streampixels-secret" },
|
||||
payload: { appSlug: "streampixels", mode: "connect", connection: { kind: "creator", targetId: "c" }, returnTo: "https://streampixels.gamecult.org/s", handoff: { kind: "browser_completion" } },
|
||||
});
|
||||
const state = stateOf(start.json());
|
||||
const ask = await app.inject({ method: "GET", url: `/v1/oauth/joystick/launch?state=${encodeURIComponent(state)}`, headers: { accept: "text/html" } });
|
||||
const askCookie = setCookieOf(ask).find((c) => c.startsWith("__Host-heimdall-ask-"))!.split(";")[0]!;
|
||||
const go = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/consent",
|
||||
headers: { "content-type": "application/x-www-form-urlencoded", cookie: askCookie },
|
||||
payload: new URLSearchParams({ state, decision: "continue" }).toString(),
|
||||
});
|
||||
const binding = setCookieOf(go).find((c) => c.startsWith("__Host-heimdall-oauth-"))!.split(";")[0]!;
|
||||
drift.on = true; // the wording changes after the person has agreed
|
||||
const done = await app.inject({ method: "GET", url: `/v1/oauth/joystick/callback?state=${encodeURIComponent(state)}&code=code-a`, headers: { cookie: binding, accept: "application/json" } });
|
||||
expect(done.statusCode).toBe(201);
|
||||
const [receipt] = await store.listConsentReceipts(done.json().account.id);
|
||||
expect(receipt?.kind === "grant" && receipt.consentText).not.toContain("REWORDED");
|
||||
});
|
||||
64
tests/fixtures/fake-idunn-rudp.ts
vendored
Normal file
64
tests/fixtures/fake-idunn-rudp.ts
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
/**
|
||||
* A stand-in for Idunn's health endpoint: it accepts each RUDP connect, acks
|
||||
* the frame that follows and keeps every delivered frame. Heimdall opens a
|
||||
* fresh socket and session per publication, so sessions are kept per remote.
|
||||
*/
|
||||
import dgram from "node:dgram";
|
||||
import {
|
||||
CultNetRudpSession,
|
||||
decodeRudpPacket,
|
||||
encodeRudpPacket,
|
||||
type CultNetTransportFrame,
|
||||
} from "cultnet-ts";
|
||||
|
||||
export interface FakeIdunnRudp {
|
||||
port: number;
|
||||
frames: CultNetTransportFrame[];
|
||||
/** Resolves with the nth delivered frame (0-based) once it has arrived. */
|
||||
frame(index: number): Promise<CultNetTransportFrame>;
|
||||
close(): void;
|
||||
}
|
||||
|
||||
export async function startFakeIdunnRudp(): Promise<FakeIdunnRudp> {
|
||||
const server = dgram.createSocket("udp4");
|
||||
const sessions = new Map<string, CultNetRudpSession>();
|
||||
const frames: CultNetTransportFrame[] = [];
|
||||
const waiting: Array<{ index: number; resolve: (frame: CultNetTransportFrame) => void }> = [];
|
||||
|
||||
server.on("message", (wire, remote) => {
|
||||
const packet = decodeRudpPacket(wire);
|
||||
const key = `${remote.address}:${remote.port}`;
|
||||
if (packet.packetType === "connect") {
|
||||
const session = new CultNetRudpSession({
|
||||
connectionId: 0x1d0d0001,
|
||||
initialSequence: 1,
|
||||
resendDelayMs: 100,
|
||||
});
|
||||
sessions.set(key, session);
|
||||
server.send(encodeRudpPacket(session.acceptConnect(packet, Date.now())), remote.port, remote.address);
|
||||
return;
|
||||
}
|
||||
const session = sessions.get(key);
|
||||
if (!session) return;
|
||||
const result = session.receive(packet, Date.now());
|
||||
if (result.reply) server.send(encodeRudpPacket(result.reply), remote.port, remote.address);
|
||||
for (const frame of result.delivered) {
|
||||
frames.push(frame);
|
||||
for (const waiter of waiting.filter((entry) => entry.index === frames.length - 1)) waiter.resolve(frame);
|
||||
}
|
||||
if (result.delivered.length > 0) {
|
||||
server.send(encodeRudpPacket(session.createAck()), remote.port, remote.address);
|
||||
}
|
||||
});
|
||||
await new Promise<void>((resolve) => server.bind(0, "127.0.0.1", resolve));
|
||||
|
||||
return {
|
||||
port: server.address().port,
|
||||
frames,
|
||||
frame: (index) =>
|
||||
frames[index]
|
||||
? Promise.resolve(frames[index]!)
|
||||
: new Promise((resolve) => waiting.push({ index, resolve })),
|
||||
close: () => server.close(),
|
||||
};
|
||||
}
|
||||
1
tests/fixtures/idunn-runtime/.gitattributes
vendored
Normal file
1
tests/fixtures/idunn-runtime/.gitattributes
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
* -text
|
||||
11
tests/fixtures/idunn-runtime/README.md
vendored
Normal file
11
tests/fixtures/idunn-runtime/README.md
vendored
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
# Idunn runtime fixtures
|
||||
|
||||
Written by the Rust owner, not by Heimdall's tests. Copied byte for byte from CultLib
|
||||
`217a9480`, `packages/cultnet-ts/test/fixtures/idunn-runtime/web` (`expected.cc`,
|
||||
`activation.cc`, `activation-key.seed`, `provider-identity.credential`) and that directory's
|
||||
`machine-id`. CultLib regenerates them with `packages/cultnet-rs/examples/idunn_runtime_fixture.rs`
|
||||
(its own README has the Yggdrasil command); the provider identity is bound to `machine-id`, so a
|
||||
test that decodes it supplies that machine id instead of `/etc/machine-id`.
|
||||
|
||||
Every key here is a test key. `provider-identity.credential` is the shape Idunn passes on the
|
||||
presence-identity descriptor: key fields are 32-integer arrays, which only the Rust owner writes.
|
||||
1
tests/fixtures/idunn-runtime/activation-key.seed
vendored
Normal file
1
tests/fixtures/idunn-runtime/activation-key.seed
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
¯ÂOd×f¯l*oµ‘ÀFªv‰n<E280B0>hLûÑpšS´p
|
||||
BIN
tests/fixtures/idunn-runtime/activation.cc
vendored
Normal file
BIN
tests/fixtures/idunn-runtime/activation.cc
vendored
Normal file
Binary file not shown.
BIN
tests/fixtures/idunn-runtime/expected.cc
vendored
Normal file
BIN
tests/fixtures/idunn-runtime/expected.cc
vendored
Normal file
Binary file not shown.
1
tests/fixtures/idunn-runtime/machine-id
vendored
Normal file
1
tests/fixtures/idunn-runtime/machine-id
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1
|
||||
BIN
tests/fixtures/idunn-runtime/provider-identity.credential
vendored
Normal file
BIN
tests/fixtures/idunn-runtime/provider-identity.credential
vendored
Normal file
Binary file not shown.
79
tests/fixtures/presence-descriptors.ts
vendored
79
tests/fixtures/presence-descriptors.ts
vendored
|
|
@ -1,64 +1,45 @@
|
|||
/**
|
||||
* What Idunn hands a generation for runtime presence: a parent-only identity
|
||||
* store and an activation seed, passed as descriptors named in LISTEN_FDNAMES.
|
||||
* Every key here is generated for the test or a canary byte pattern.
|
||||
* What Idunn hands a generation for runtime presence: the bundle directory, a
|
||||
* parent-only identity store and an activation seed, the last two passed as
|
||||
* descriptors named in LISTEN_FDNAMES. The bytes are the Rust owner's, copied
|
||||
* from CultLib (see idunn-runtime/README.md); every key in them is a test key.
|
||||
*/
|
||||
import { closeSync, openSync } from "node:fs";
|
||||
import { chmod, mkdir, writeFile } from "node:fs/promises";
|
||||
import { chmod, copyFile, mkdir, readFile } from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
|
||||
import { encode } from "@msgpack/msgpack";
|
||||
import { SingleFileMessagePackBackingStore } from "@gamecult/cultcache-ts";
|
||||
import { IDUNN_RUNTIME_ACTIVATION_CREDENTIAL_NAME } from "cultnet-ts";
|
||||
|
||||
import { openOrEnrollProviderHealthIdentity } from "../../src/provider-health-identity.js";
|
||||
import type { RuntimeBundleFacts } from "../../src/runtime-presence.js";
|
||||
export const idunnRuntimeFixtures = path.join(import.meta.dirname, "idunn-runtime");
|
||||
|
||||
export const bundleFacts: RuntimeBundleFacts = {
|
||||
target: "heimdall",
|
||||
planId: "plan-1",
|
||||
incarnationId: "incarnation-1",
|
||||
sealedReleaseId: "release-1",
|
||||
runtimeId: "runtime-1",
|
||||
runtimeInstanceId: "instance-1",
|
||||
expectedProjectionSha256: "sha256-projection",
|
||||
activationWitnessSha256: "sha256-witness",
|
||||
activationSignerIdentityId: "activation-signer",
|
||||
stateSchemaGeneration: null,
|
||||
stateContractSha256: null,
|
||||
capabilities: [],
|
||||
healthContract: "health-contract",
|
||||
};
|
||||
const FIXTURE_FILES = [
|
||||
"expected.cc",
|
||||
"activation.cc",
|
||||
"activation-key.seed",
|
||||
"provider-identity.credential",
|
||||
"machine-id",
|
||||
] as const;
|
||||
|
||||
/** Write both stores into `dir`, readable by any uid (the children run as others). */
|
||||
/** The machine id the fixture identity is bound to, in place of /etc/machine-id. */
|
||||
export const fixtureMachineId = async (dir: string = idunnRuntimeFixtures): Promise<string> =>
|
||||
(await readFile(path.join(dir, "machine-id"), "utf8")).trim();
|
||||
|
||||
/** Copy the fixtures into `dir`, readable by any uid (the children run as others). */
|
||||
export async function writePresenceFixtures(dir: string): Promise<void> {
|
||||
await mkdir(dir, { recursive: true });
|
||||
await chmod(dir, 0o755);
|
||||
const enrolled = path.join(dir, "enrolled.cc");
|
||||
await openOrEnrollProviderHealthIdentity(enrolled);
|
||||
const [record] = await new SingleFileMessagePackBackingStore(enrolled).pullAll();
|
||||
// Re-wrapped the way cultcache-rs writes a store, which is how Idunn writes it.
|
||||
await writeFile(
|
||||
path.join(dir, "runtime-presence-identity.cc"),
|
||||
encode([
|
||||
[
|
||||
"gamecult-provider-health-identity",
|
||||
"gamecult.provider_health_identity.private.v1",
|
||||
record!.payload,
|
||||
"2026-09-06T00:00:00.000Z",
|
||||
"gamecult.provider_health_identity.private.v1",
|
||||
],
|
||||
]),
|
||||
{ mode: 0o644 }
|
||||
);
|
||||
await writeFile(path.join(dir, "activation-seed"), Buffer.alloc(32, 7), { mode: 0o644 });
|
||||
for (const name of FIXTURE_FILES) {
|
||||
const target = path.join(dir, name);
|
||||
await copyFile(path.join(idunnRuntimeFixtures, name), target);
|
||||
await chmod(target, 0o644);
|
||||
}
|
||||
}
|
||||
|
||||
/** Open both descriptors and name them the way systemd's LISTEN_FDNAMES does. */
|
||||
export function openPresenceDescriptors(dir: string): { env: NodeJS.ProcessEnv; close: () => void } {
|
||||
const fds = [
|
||||
[openSync(path.join(dir, "runtime-presence-identity.cc"), "r"), "gamecult-runtime-presence-identity"],
|
||||
[openSync(path.join(dir, "activation-seed"), "r"), IDUNN_RUNTIME_ACTIVATION_CREDENTIAL_NAME],
|
||||
[openSync(path.join(dir, "provider-identity.credential"), "r"), "gamecult-runtime-presence-identity"],
|
||||
[openSync(path.join(dir, "activation-key.seed"), "r"), IDUNN_RUNTIME_ACTIVATION_CREDENTIAL_NAME],
|
||||
] as const;
|
||||
const names: string[] = [];
|
||||
for (const [fd, name] of fds) {
|
||||
|
|
@ -67,6 +48,14 @@ export function openPresenceDescriptors(dir: string): { env: NodeJS.ProcessEnv;
|
|||
}
|
||||
return {
|
||||
env: { LISTEN_FDNAMES: names.join(":") },
|
||||
close: () => fds.forEach(([fd]) => closeSync(fd)),
|
||||
// The authority closes each descriptor it reads; this releases only what it did not.
|
||||
close: () =>
|
||||
fds.forEach(([fd]) => {
|
||||
try {
|
||||
closeSync(fd);
|
||||
} catch {
|
||||
// already closed by the reader
|
||||
}
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
|
|
|||
27
tests/fixtures/state-root-generation-child.ts
vendored
27
tests/fixtures/state-root-generation-child.ts
vendored
|
|
@ -10,8 +10,8 @@ import { readFile, writeFile } from "node:fs/promises";
|
|||
import path from "node:path";
|
||||
|
||||
import { loadConfig } from "../../src/config.js";
|
||||
import { PublisherSequence, buildPresenceStatement } from "../../src/runtime-presence.js";
|
||||
import { bundleFacts, openPresenceDescriptors } from "./presence-descriptors.js";
|
||||
import { openPresenceAuthority } from "../../src/runtime-presence.js";
|
||||
import { fixtureMachineId, openPresenceDescriptors } from "./presence-descriptors.js";
|
||||
import { createHeimdallRuntimePulse, publishHeimdallVerseState } from "../../src/verse-state.js";
|
||||
|
||||
const [role, stateRoot, fixtureDir] = process.argv.slice(2) as [string, string, string];
|
||||
|
|
@ -25,18 +25,17 @@ const config = loadConfig({
|
|||
async function publishPresence(): Promise<void> {
|
||||
const descriptors = openPresenceDescriptors(fixtureDir);
|
||||
try {
|
||||
const observedAtUnixMillis = Date.now();
|
||||
await buildPresenceStatement({
|
||||
bundle: bundleFacts,
|
||||
state: "warming",
|
||||
detail: "generation probe",
|
||||
boundEndpoint: null,
|
||||
writeLeaseSha256: null,
|
||||
observedAtUnixMillis,
|
||||
publisherSequence: new PublisherSequence().next(observedAtUnixMillis),
|
||||
providerHealthIdentityPath: path.join(stateRoot, "provider-health-identity.cc"),
|
||||
env: descriptors.env,
|
||||
});
|
||||
const authority = await openPresenceAuthority(
|
||||
{
|
||||
idunnRuntimeBundlePath: fixtureDir,
|
||||
host: config.host,
|
||||
port: config.port,
|
||||
providerHealthIdentityPath: path.join(stateRoot, "provider-health-identity.cc"),
|
||||
},
|
||||
descriptors.env,
|
||||
() => fixtureMachineId(fixtureDir),
|
||||
);
|
||||
authority.sign("warming", "generation probe", Date.now());
|
||||
} finally {
|
||||
descriptors.close();
|
||||
}
|
||||
|
|
|
|||
537
tests/google-link.test.ts
Normal file
537
tests/google-link.test.ts
Normal file
|
|
@ -0,0 +1,537 @@
|
|||
import { createHash, createSign, generateKeyPairSync } from "node:crypto";
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { type FastifyInstance } from "fastify";
|
||||
import { buildApp } from "../src/app.js";
|
||||
import { loadConfig, type HeimdallConfig } from "../src/config.js";
|
||||
import { resetGoogleJwksCache } from "../src/google-oidc.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { IdentityHeldElsewhereError, InMemoryStore } from "../src/store/index.js";
|
||||
import { launchFlow, launchWithRedirect, stateOf, type LaunchedFlow } from "./oauth-flow.js";
|
||||
|
||||
const CLIENT_ID = "google-client";
|
||||
const REDIRECT = "https://heimdall.gamecult.org/v1/oauth/google/callback";
|
||||
const rsa = generateKeyPairSync("rsa", { modulusLength: 2048 });
|
||||
const originalFetch = globalThis.fetch;
|
||||
const apps: FastifyInstance[] = [];
|
||||
|
||||
function config(): HeimdallConfig {
|
||||
const base = loadConfig({
|
||||
GC_ACCESS_BASE_URL: "https://heimdall.gamecult.org",
|
||||
GC_ACCESS_PROVIDER_GOOGLE_CLIENT_ID: CLIENT_ID,
|
||||
GC_ACCESS_PROVIDER_DISCORD_CLIENT_ID: "discord-client",
|
||||
} as NodeJS.ProcessEnv);
|
||||
return {
|
||||
...base,
|
||||
storage: { backend: "memory", applySchemaOnStartup: true },
|
||||
tokenEncryptionKeyBase64: Buffer.alloc(32, 7).toString("base64"),
|
||||
bootstrapSigningPrivateKeyOnMissing: true,
|
||||
appSharedSecrets: { ...base.appSharedSecrets, bifrost: "bifrost-secret" },
|
||||
providers: {
|
||||
...base.providers,
|
||||
google: { clientId: CLIENT_ID, clientSecret: "google-secret" },
|
||||
discord: { clientId: "discord-client", clientSecret: "discord-secret" },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function discordRuntime(providerUserId: string, name: string): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return { accessToken: "d-at", refreshToken: "d-rt", tokenType: "Bearer", scope: ["identify"], expiresAt: "2099-01-01T00:00:00.000Z", raw: {} };
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return { provider: "discord", providerUserId, username: name, displayName: name, profile: { id: providerUserId } };
|
||||
},
|
||||
// Discord grants app access only under a policy the app named at start.
|
||||
async evaluateEntitlements(input) {
|
||||
return { facts: input.callback.entitlementPolicy ? ["entitlement.app_access"] : [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// Bifrost refuses an unauthenticated start: its backend holds the app secret.
|
||||
const BIFROST_APP = { "x-heimdall-app-secret": "bifrost-secret" };
|
||||
|
||||
function b64(value: unknown): string {
|
||||
return Buffer.from(JSON.stringify(value)).toString("base64url");
|
||||
}
|
||||
|
||||
function signedIdToken(claims: Record<string, unknown>): string {
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
const body = `${b64({ alg: "RS256", kid: "k1" })}.${b64({
|
||||
iss: "https://accounts.google.com",
|
||||
aud: CLIENT_ID,
|
||||
azp: CLIENT_ID,
|
||||
sub: "g-sub-1",
|
||||
email: "person@example.org",
|
||||
email_verified: true,
|
||||
name: "Person",
|
||||
iat: now,
|
||||
exp: now + 600,
|
||||
...claims,
|
||||
})}`;
|
||||
return `${body}.${createSign("RSA-SHA256").update(body).sign(rsa.privateKey).toString("base64url")}`;
|
||||
}
|
||||
|
||||
interface GoogleLeg {
|
||||
tokenRequests: URLSearchParams[];
|
||||
}
|
||||
|
||||
/** Google's two endpoints: the key set, and a token endpoint whose id_token echoes the nonce it was told. */
|
||||
function fakeGoogle(options: { nonceFrom: () => string | undefined; claims?: Record<string, unknown> }): GoogleLeg {
|
||||
const leg: GoogleLeg = { tokenRequests: [] };
|
||||
globalThis.fetch = (async (input: string | URL, init?: RequestInit) => {
|
||||
const url = String(input);
|
||||
if (url === "https://www.googleapis.com/oauth2/v3/certs") {
|
||||
return new Response(
|
||||
JSON.stringify({ keys: [{ ...(rsa.publicKey.export({ format: "jwk" }) as object), kid: "k1", alg: "RS256" }] }),
|
||||
{ status: 200 }
|
||||
);
|
||||
}
|
||||
if (url === "https://oauth2.googleapis.com/token") {
|
||||
leg.tokenRequests.push(new URLSearchParams(String(init?.body)));
|
||||
return new Response(
|
||||
JSON.stringify({
|
||||
access_token: "g-at",
|
||||
token_type: "Bearer",
|
||||
expires_in: 3600,
|
||||
scope: "openid email profile",
|
||||
id_token: signedIdToken({ nonce: options.nonceFrom(), ...options.claims }),
|
||||
}),
|
||||
{ status: 200 }
|
||||
);
|
||||
}
|
||||
throw new Error(`unexpected fetch ${url}`);
|
||||
}) as typeof fetch;
|
||||
return leg;
|
||||
}
|
||||
|
||||
function accountCount(store: InMemoryStore): number {
|
||||
return (store as unknown as { accounts: Map<string, unknown> }).accounts.size;
|
||||
}
|
||||
|
||||
async function signInWithDiscord(app: FastifyInstance, providerUserId = "discord-1"): Promise<{ accessToken: string; accountId: string }> {
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
headers: BIFROST_APP,
|
||||
payload: { appSlug: "bifrost", mode: "sign_in", returnTo: "https://bifrost.gamecult.org/auth/heimdall/complete" },
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBe(201);
|
||||
const body = callback.json();
|
||||
return { accessToken: body.accessToken as string, accountId: body.account.id as string };
|
||||
}
|
||||
|
||||
async function build(store = new InMemoryStore(), discordUser = "discord-1") {
|
||||
const app = await buildApp({ config: config(), store, oauthRuntimes: { discord: discordRuntime(discordUser, "Person") } });
|
||||
apps.push(app);
|
||||
return { app, store };
|
||||
}
|
||||
|
||||
function startGoogle(app: FastifyInstance, accessToken?: string, mode: "link" | "sign_in" = "link") {
|
||||
return app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/google/start",
|
||||
headers: { ...BIFROST_APP, ...(accessToken ? { authorization: `Bearer ${accessToken}` } : {}) },
|
||||
payload: { appSlug: "bifrost", mode, returnTo: "https://bifrost.gamecult.org/auth/heimdall/complete" },
|
||||
});
|
||||
}
|
||||
|
||||
function callbackGoogle(app: FastifyInstance, flow: LaunchedFlow) {
|
||||
return app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/google/callback?code=g-code&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
}
|
||||
|
||||
const DISCORD_POLICY = { kind: "discord_role_access", guildId: "g", allowedRoleIds: ["member"] } as const;
|
||||
|
||||
/** Begin a link with `token`, let Google answer as `claims` says, and return the callback's answer. */
|
||||
async function linkGoogleCallback(app: FastifyInstance, token: string, claims?: Record<string, unknown>) {
|
||||
const start = await startGoogle(app, token);
|
||||
expect(start.statusCode).toBe(201);
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined, ...(claims ? { claims } : {}) });
|
||||
return callbackGoogle(app, startFlow);
|
||||
}
|
||||
|
||||
function confirmLink(app: FastifyInstance, token: string | undefined, pendingLinkId: string) {
|
||||
return app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/apps/bifrost/links/confirm",
|
||||
headers: token ? { authorization: `Bearer ${token}` } : {},
|
||||
payload: { pendingLinkId },
|
||||
});
|
||||
}
|
||||
|
||||
/** The whole link: callback, then the initiator's confirm. */
|
||||
async function linkGoogle(app: FastifyInstance, token: string, claims?: Record<string, unknown>) {
|
||||
const done = await linkGoogleCallback(app, token, claims);
|
||||
expect(done.statusCode).toBe(201);
|
||||
const confirmed = await confirmLink(app, token, done.json().pendingLinkId);
|
||||
expect(confirmed.statusCode).toBe(201);
|
||||
return confirmed;
|
||||
}
|
||||
|
||||
afterEach(async () => {
|
||||
globalThis.fetch = originalFetch;
|
||||
resetGoogleJwksCache();
|
||||
while (apps.length) await apps.pop()?.close();
|
||||
});
|
||||
|
||||
describe("a link write that loses the race to another account", () => {
|
||||
it("links/confirm answers 409 identity_linked_elsewhere when the store refuses the move after the check passed", async () => {
|
||||
const { app, store } = await build();
|
||||
const { accessToken } = await signInWithDiscord(app);
|
||||
const done = await linkGoogleCallback(app, accessToken);
|
||||
expect(done.statusCode).toBe(201);
|
||||
vi.spyOn(store, "upsertLinkedIdentity").mockRejectedValueOnce(new IdentityHeldElsewhereError());
|
||||
const confirmed = await confirmLink(app, accessToken, done.json().pendingLinkId);
|
||||
expect([confirmed.statusCode, confirmed.json().error]).toEqual([409, "identity_linked_elsewhere"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Google as a Heimdall OIDC provider", () => {
|
||||
it("builds the authorization request: openid email profile, the exact callback, state, nonce and an S256 challenge", async () => {
|
||||
const { app } = await build();
|
||||
const { accessToken } = await signInWithDiscord(app);
|
||||
const start = await startGoogle(app, accessToken);
|
||||
|
||||
expect(start.statusCode).toBe(201);
|
||||
expect(start.json().callbackUrl).toBe(REDIRECT);
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
expect(`${url.origin}${url.pathname}`).toBe("https://accounts.google.com/o/oauth2/v2/auth");
|
||||
expect(url.searchParams.get("client_id")).toBe(CLIENT_ID);
|
||||
expect(url.searchParams.get("redirect_uri")).toBe(REDIRECT);
|
||||
expect(url.searchParams.get("response_type")).toBe("code");
|
||||
expect(url.searchParams.get("scope")).toBe("openid email profile");
|
||||
expect(url.searchParams.get("state")).toBe(stateOf(start.json()));
|
||||
expect(url.searchParams.get("nonce")).toMatch(/^[A-Za-z0-9_-]{43}$/);
|
||||
expect(url.searchParams.get("code_challenge")).toMatch(/^[A-Za-z0-9_-]{43}$/);
|
||||
expect(url.searchParams.get("code_challenge_method")).toBe("S256");
|
||||
});
|
||||
|
||||
it("links Google to the account that asked, with PKCE proven end to end and the id_token's nonce matched", async () => {
|
||||
const { app, store } = await build();
|
||||
const { accessToken, accountId } = await signInWithDiscord(app);
|
||||
const start = await startGoogle(app, accessToken);
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
const leg = fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined });
|
||||
|
||||
const done = await callbackGoogle(app, startFlow);
|
||||
|
||||
// Phase one verified the identity and recorded it; it linked nothing and issued no session.
|
||||
expect(done.statusCode).toBe(201);
|
||||
expect(done.json().status).toBe("link_pending");
|
||||
expect(done.json().accessToken).toBeUndefined();
|
||||
expect(await store.findStoredLinkedIdentity("google", "g-sub-1")).toBeNull();
|
||||
const confirmed = await confirmLink(app, accessToken, done.json().pendingLinkId);
|
||||
expect(confirmed.statusCode).toBe(201);
|
||||
expect(confirmed.json().accountId).toBe(accountId);
|
||||
expect(accountCount(store)).toBe(1);
|
||||
const sent = leg.tokenRequests[0]!;
|
||||
expect(sent.get("grant_type")).toBe("authorization_code");
|
||||
expect(sent.get("redirect_uri")).toBe(REDIRECT);
|
||||
// The verifier Heimdall sent hashes to the challenge it put in the authorization URL.
|
||||
expect(createHash("sha256").update(sent.get("code_verifier") ?? "", "ascii").digest("base64url")).toBe(
|
||||
url.searchParams.get("code_challenge")
|
||||
);
|
||||
const stored = await store.findStoredLinkedIdentity("google", "g-sub-1");
|
||||
expect(stored?.accountId).toBe(accountId);
|
||||
expect(stored?.primaryEmail).toBe("person@example.org");
|
||||
});
|
||||
|
||||
it("signs in the account Google is linked to, with no session, and mints nothing", async () => {
|
||||
const { app, store } = await build();
|
||||
const { accessToken, accountId } = await signInWithDiscord(app);
|
||||
await linkGoogle(app, accessToken);
|
||||
|
||||
const signIn = await startGoogle(app, undefined, "sign_in");
|
||||
expect(signIn.statusCode).toBe(201);
|
||||
const signInFlow = await launchWithRedirect(app, signIn.json());
|
||||
const signInUrl = signInFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => signInUrl.searchParams.get("nonce") ?? undefined });
|
||||
const done = await callbackGoogle(app, signInFlow);
|
||||
|
||||
expect(done.statusCode).toBe(201);
|
||||
expect(done.json().account.id).toBe(accountId);
|
||||
expect(accountCount(store)).toBe(1);
|
||||
});
|
||||
|
||||
it("refuses a link start whose named initiator is not the bearer's account", async () => {
|
||||
const { app, store } = await build();
|
||||
const a = await signInWithDiscord(app, "discord-1");
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/google/start",
|
||||
headers: { ...BIFROST_APP, authorization: `Bearer ${a.accessToken}` },
|
||||
payload: {
|
||||
appSlug: "bifrost",
|
||||
mode: "link",
|
||||
returnTo: "https://bifrost.gamecult.org/auth/heimdall/complete",
|
||||
initiatingAccountId: `${a.accountId}-other`,
|
||||
},
|
||||
});
|
||||
expect([start.statusCode, start.json().error]).toEqual([400, "link_initiator_conflict"]);
|
||||
expect(accountCount(store)).toBe(1);
|
||||
});
|
||||
|
||||
it("refuses a link start with no Heimdall session", async () => {
|
||||
const { app, store } = await build();
|
||||
const start = await startGoogle(app);
|
||||
expect(start.statusCode).toBe(401);
|
||||
expect(start.json().error).toBe("link_session_required");
|
||||
expect(accountCount(store)).toBe(0);
|
||||
});
|
||||
|
||||
it.each([
|
||||
["a garbage bearer", () => "not-a-token"],
|
||||
["a token for another app", async (app: FastifyInstance) => {
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
payload: { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" },
|
||||
});
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const cb = await app.inject({ method: "GET", url: `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(flow.state)}`, headers: { cookie: flow.cookie } });
|
||||
return cb.json().accessToken as string;
|
||||
}],
|
||||
])("refuses a link start carrying %s", async (_name, token) => {
|
||||
const { app, store } = await build();
|
||||
const bearer = await token(app);
|
||||
const before = accountCount(store);
|
||||
const start = await startGoogle(app, bearer);
|
||||
expect(start.statusCode).toBe(401);
|
||||
expect(start.json().error).toBe("invalid_link_session");
|
||||
expect(accountCount(store)).toBe(before);
|
||||
});
|
||||
|
||||
it("refuses a first Google login from a subject no account holds, and mints no account for it", async () => {
|
||||
// The person who has a Discord account arrives with Google for the first time, signing in rather than linking.
|
||||
const { app, store } = await build();
|
||||
await signInWithDiscord(app);
|
||||
const start = await startGoogle(app, undefined, "sign_in");
|
||||
expect(start.statusCode).toBe(201);
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined });
|
||||
|
||||
const before = accountCount(store);
|
||||
const done = await callbackGoogle(app, startFlow);
|
||||
|
||||
expect(done.statusCode).toBe(403);
|
||||
expect(done.json().error).toBe("identity_not_linked");
|
||||
expect(accountCount(store)).toBe(before);
|
||||
expect(await store.findStoredLinkedIdentity("google", "g-sub-1")).toBeNull();
|
||||
});
|
||||
|
||||
it("never moves or merges: a Google subject already linked to one account cannot be linked to another", async () => {
|
||||
const store = new InMemoryStore();
|
||||
const first = await build(store, "discord-1");
|
||||
const a = await signInWithDiscord(first.app, "discord-1");
|
||||
await linkGoogle(first.app, a.accessToken);
|
||||
|
||||
// A second person, a second account, the same Google subject.
|
||||
const second = await build(store, "discord-2");
|
||||
const b = await signInWithDiscord(second.app, "discord-2");
|
||||
expect(b.accountId).not.toBe(a.accountId);
|
||||
const startB = await startGoogle(second.app, b.accessToken);
|
||||
const startBFlow = await launchWithRedirect(second.app, startB.json());
|
||||
const urlB = startBFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => urlB.searchParams.get("nonce") ?? undefined });
|
||||
const done = await callbackGoogle(second.app, startBFlow);
|
||||
|
||||
expect(done.statusCode).toBe(403);
|
||||
expect((await store.findStoredLinkedIdentity("google", "g-sub-1"))?.accountId).toBe(a.accountId);
|
||||
});
|
||||
|
||||
it.each([
|
||||
["an unverified email", { email_verified: false }],
|
||||
["another client's audience", { aud: "other-client", azp: "other-client" }],
|
||||
["a nonce this request did not carry", { nonce: "replayed" }],
|
||||
["an expired token", { exp: Math.floor(Date.now() / 1000) - 3600 }],
|
||||
])("links nothing when the id_token has %s", async (_name, claims) => {
|
||||
const { app, store } = await build();
|
||||
const { accessToken } = await signInWithDiscord(app);
|
||||
const start = await startGoogle(app, accessToken);
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined, claims });
|
||||
|
||||
const done = await callbackGoogle(app, startFlow);
|
||||
|
||||
expect(done.statusCode).toBe(502);
|
||||
expect(await store.findStoredLinkedIdentity("google", "g-sub-1")).toBeNull();
|
||||
expect(accountCount(store)).toBe(1);
|
||||
});
|
||||
|
||||
it("keys the identity by sub: the same email under a different sub is a different, unlinkable identity", async () => {
|
||||
const { app, store } = await build();
|
||||
const { accessToken, accountId } = await signInWithDiscord(app);
|
||||
await linkGoogle(app, accessToken, { sub: "g-sub-2" });
|
||||
expect((await store.findStoredLinkedIdentity("google", "g-sub-2"))?.accountId).toBe(accountId);
|
||||
expect(await store.findStoredLinkedIdentity("google", "person@example.org")).toBeNull();
|
||||
});
|
||||
|
||||
describe("link is two-phase", () => {
|
||||
it("a victim completing an attacker's link URL attaches the victim's Google sub to no account", async () => {
|
||||
const store = new InMemoryStore();
|
||||
const attacker = await build(store, "discord-attacker");
|
||||
const a = await signInWithDiscord(attacker.app, "discord-attacker");
|
||||
const victim = await build(store, "discord-victim");
|
||||
const v = await signInWithDiscord(victim.app, "discord-victim");
|
||||
|
||||
// The attacker begins a link and sends the Google URL to the victim, who finishes it as themselves.
|
||||
const done = await linkGoogleCallback(attacker.app, a.accessToken, { sub: "victim-google-sub" });
|
||||
expect(done.statusCode).toBe(201);
|
||||
expect(await store.findStoredLinkedIdentity("google", "victim-google-sub")).toBeNull();
|
||||
|
||||
// The victim's app holds the victim's token: Heimdall refuses it, and the link stays unwritten.
|
||||
const asVictim = await confirmLink(victim.app, v.accessToken, done.json().pendingLinkId);
|
||||
expect(asVictim.statusCode).toBe(410);
|
||||
expect(await store.findStoredLinkedIdentity("google", "victim-google-sub")).toBeNull();
|
||||
|
||||
// No token at all, and a garbage token, are refused the same way.
|
||||
expect((await confirmLink(attacker.app, undefined, done.json().pendingLinkId)).statusCode).toBe(401);
|
||||
expect((await confirmLink(attacker.app, "garbage", done.json().pendingLinkId)).statusCode).toBe(401);
|
||||
expect(await store.findStoredLinkedIdentity("google", "victim-google-sub")).toBeNull();
|
||||
|
||||
// The refused attempts did not burn the pending link: its initiator can still confirm it.
|
||||
expect((await confirmLink(attacker.app, a.accessToken, done.json().pendingLinkId)).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("signing in with Google cannot reach a Google sub the attacker's pending link recorded", async () => {
|
||||
const { app } = await build();
|
||||
const a = await signInWithDiscord(app);
|
||||
await linkGoogleCallback(app, a.accessToken, { sub: "victim-google-sub" });
|
||||
|
||||
const signIn = await startGoogle(app, undefined, "sign_in");
|
||||
const signInFlow = await launchWithRedirect(app, signIn.json());
|
||||
const url = signInFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined, claims: { sub: "victim-google-sub" } });
|
||||
expect((await callbackGoogle(app, signInFlow)).statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it("a pending link is single-use", async () => {
|
||||
const { app } = await build();
|
||||
const a = await signInWithDiscord(app);
|
||||
const done = await linkGoogleCallback(app, a.accessToken);
|
||||
expect((await confirmLink(app, a.accessToken, done.json().pendingLinkId)).statusCode).toBe(201);
|
||||
expect((await confirmLink(app, a.accessToken, done.json().pendingLinkId)).statusCode).toBe(410);
|
||||
});
|
||||
|
||||
it("a pending link expires after the completion TTL", async () => {
|
||||
const { app, store } = await build();
|
||||
const a = await signInWithDiscord(app);
|
||||
const done = await linkGoogleCallback(app, a.accessToken);
|
||||
const ttlMs = Date.parse(done.json().expiresAt) - Date.now();
|
||||
expect(ttlMs).toBeGreaterThan(0);
|
||||
expect(ttlMs).toBeLessThanOrEqual(300_000);
|
||||
|
||||
vi.useFakeTimers({ toFake: ["Date"], now: Date.now() + 301_000 });
|
||||
try {
|
||||
expect((await confirmLink(app, a.accessToken, done.json().pendingLinkId)).statusCode).toBe(410);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
expect(await store.findStoredLinkedIdentity("google", "g-sub-1")).toBeNull();
|
||||
});
|
||||
|
||||
it("a pending link is bound to its app: another app's session cannot confirm it", async () => {
|
||||
const { app, store } = await build();
|
||||
const a = await signInWithDiscord(app);
|
||||
const done = await linkGoogleCallback(app, a.accessToken);
|
||||
const other = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
payload: { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" },
|
||||
});
|
||||
const flow = await launchFlow(app, other.json());
|
||||
const cb = await app.inject({ method: "GET", url: `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(flow.state)}`, headers: { cookie: flow.cookie } });
|
||||
const res = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/apps/repixelizer/links/confirm",
|
||||
headers: { authorization: `Bearer ${cb.json().accessToken}` },
|
||||
payload: { pendingLinkId: done.json().pendingLinkId },
|
||||
});
|
||||
expect(res.statusCode).toBe(410);
|
||||
expect(await store.findStoredLinkedIdentity("google", "g-sub-1")).toBeNull();
|
||||
});
|
||||
|
||||
it("refuses at confirm a sub another account linked in between, and never moves it", async () => {
|
||||
const store = new InMemoryStore();
|
||||
const first = await build(store, "discord-1");
|
||||
const a = await signInWithDiscord(first.app, "discord-1");
|
||||
const second = await build(store, "discord-2");
|
||||
const b = await signInWithDiscord(second.app, "discord-2");
|
||||
|
||||
const pendingA = await linkGoogleCallback(first.app, a.accessToken);
|
||||
const pendingB = await linkGoogleCallback(second.app, b.accessToken);
|
||||
expect((await confirmLink(first.app, a.accessToken, pendingA.json().pendingLinkId)).statusCode).toBe(201);
|
||||
const lost = await confirmLink(second.app, b.accessToken, pendingB.json().pendingLinkId);
|
||||
|
||||
expect(lost.statusCode).toBe(409);
|
||||
expect((await store.findStoredLinkedIdentity("google", "g-sub-1"))?.accountId).toBe(a.accountId);
|
||||
});
|
||||
});
|
||||
|
||||
describe("entitlements at the callback", () => {
|
||||
it("a Discord-origin member returning through Google keeps entitlement.app_access under the start-time policy", async () => {
|
||||
const { app } = await build();
|
||||
const member = await signInWithDiscord(app);
|
||||
await linkGoogle(app, member.accessToken);
|
||||
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/google/start",
|
||||
headers: { "x-heimdall-app-secret": "bifrost-secret" },
|
||||
payload: {
|
||||
appSlug: "bifrost",
|
||||
mode: "sign_in",
|
||||
returnTo: "https://bifrost.gamecult.org/auth/heimdall/complete",
|
||||
entitlementPolicy: DISCORD_POLICY,
|
||||
},
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined });
|
||||
const done = await callbackGoogle(app, startFlow);
|
||||
|
||||
expect(done.statusCode).toBe(201);
|
||||
expect(done.json().claimSet.facts).toContain("entitlement.app_access");
|
||||
});
|
||||
|
||||
it("without a start-time policy the other identities grant nothing", async () => {
|
||||
const { app } = await build();
|
||||
const member = await signInWithDiscord(app);
|
||||
await linkGoogle(app, member.accessToken);
|
||||
|
||||
const start = await startGoogle(app, undefined, "sign_in");
|
||||
const startFlow = await launchWithRedirect(app, start.json());
|
||||
const url = startFlow.url;
|
||||
fakeGoogle({ nonceFrom: () => url.searchParams.get("nonce") ?? undefined });
|
||||
const done = await callbackGoogle(app, startFlow);
|
||||
|
||||
expect(done.statusCode).toBe(201);
|
||||
expect(done.json().claimSet.facts).not.toContain("entitlement.app_access");
|
||||
});
|
||||
});
|
||||
|
||||
it("leaves the six existing providers minting on first login", async () => {
|
||||
const { app, store } = await build();
|
||||
await signInWithDiscord(app);
|
||||
expect(accountCount(store)).toBe(1);
|
||||
});
|
||||
});
|
||||
197
tests/google-oidc.test.ts
Normal file
197
tests/google-oidc.test.ts
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
import { createSign, generateKeyPairSync, type KeyObject } from "node:crypto";
|
||||
import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
||||
import {
|
||||
deriveOidcSecrets,
|
||||
GoogleIdTokenError,
|
||||
resetGoogleJwksCache,
|
||||
verifyGoogleIdToken,
|
||||
type GoogleIdTokenFailure,
|
||||
} from "../src/google-oidc.js";
|
||||
|
||||
const CLIENT_ID = "google-client.apps.googleusercontent.com";
|
||||
const NONCE = "the-nonce";
|
||||
const NOW_MS = Date.parse("2026-11-04T12:00:00.000Z");
|
||||
const NOW_S = Math.floor(NOW_MS / 1000);
|
||||
|
||||
const rsa = generateKeyPairSync("rsa", { modulusLength: 2048 });
|
||||
const otherRsa = generateKeyPairSync("rsa", { modulusLength: 2048 });
|
||||
const originalFetch = globalThis.fetch;
|
||||
let jwksFetches = 0;
|
||||
|
||||
function jwks(kidKeys: Record<string, KeyObject>) {
|
||||
return {
|
||||
keys: Object.entries(kidKeys).map(([kid, key]) => ({
|
||||
...(key.export({ format: "jwk" }) as Record<string, string>),
|
||||
kid,
|
||||
alg: "RS256",
|
||||
use: "sig",
|
||||
})),
|
||||
};
|
||||
}
|
||||
|
||||
function serveJwks(kidKeys: Record<string, KeyObject>) {
|
||||
globalThis.fetch = (async (input: string | URL) => {
|
||||
expect(String(input)).toBe("https://www.googleapis.com/oauth2/v3/certs");
|
||||
jwksFetches += 1;
|
||||
return new Response(JSON.stringify(jwks(kidKeys)), { status: 200, headers: { "cache-control": "public, max-age=3600" } });
|
||||
}) as typeof fetch;
|
||||
}
|
||||
|
||||
function b64(value: unknown): string {
|
||||
return Buffer.from(JSON.stringify(value)).toString("base64url");
|
||||
}
|
||||
|
||||
function idToken(
|
||||
claims: Record<string, unknown> = {},
|
||||
options: { kid?: string; alg?: string; key?: KeyObject; omit?: string[] } = {}
|
||||
): string {
|
||||
const payload: Record<string, unknown> = {
|
||||
iss: "https://accounts.google.com",
|
||||
aud: CLIENT_ID,
|
||||
azp: CLIENT_ID,
|
||||
sub: "110169484474386276334",
|
||||
email: "meta@example.org",
|
||||
email_verified: true,
|
||||
name: "Meta",
|
||||
picture: "https://lh3.googleusercontent.com/a/x",
|
||||
nonce: NONCE,
|
||||
iat: NOW_S - 10,
|
||||
exp: NOW_S + 3000,
|
||||
...claims,
|
||||
};
|
||||
for (const key of options.omit ?? []) delete payload[key];
|
||||
const header = b64({ alg: options.alg ?? "RS256", typ: "JWT", kid: options.kid ?? "k1" });
|
||||
const body = `${header}.${b64(payload)}`;
|
||||
const signature = createSign("RSA-SHA256").update(body).sign(options.key ?? rsa.privateKey).toString("base64url");
|
||||
return `${body}.${signature}`;
|
||||
}
|
||||
|
||||
async function refusal(token: string, nonce = NONCE): Promise<GoogleIdTokenFailure> {
|
||||
try {
|
||||
await verifyGoogleIdToken(token, { clientId: CLIENT_ID, nonce }, NOW_MS);
|
||||
} catch (error) {
|
||||
expect(error).toBeInstanceOf(GoogleIdTokenError);
|
||||
return (error as GoogleIdTokenError).code;
|
||||
}
|
||||
throw new Error("the token was accepted");
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
resetGoogleJwksCache();
|
||||
jwksFetches = 0;
|
||||
serveJwks({ k1: rsa.publicKey });
|
||||
});
|
||||
afterEach(() => {
|
||||
globalThis.fetch = originalFetch;
|
||||
});
|
||||
|
||||
describe("verifyGoogleIdToken", () => {
|
||||
it("accepts a good token and returns the subject as the identity", async () => {
|
||||
const claims = await verifyGoogleIdToken(idToken(), { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS);
|
||||
expect(claims).toEqual({
|
||||
sub: "110169484474386276334",
|
||||
email: "meta@example.org",
|
||||
name: "Meta",
|
||||
picture: "https://lh3.googleusercontent.com/a/x",
|
||||
});
|
||||
});
|
||||
|
||||
it("accepts the bare-host issuer Google also uses", async () => {
|
||||
await expect(verifyGoogleIdToken(idToken({ iss: "accounts.google.com" }), { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS)).resolves.toMatchObject({
|
||||
sub: "110169484474386276334",
|
||||
});
|
||||
});
|
||||
|
||||
it.each<[string, () => string, GoogleIdTokenFailure]>([
|
||||
["a foreign issuer", () => idToken({ iss: "https://evil.example" }), "bad_issuer"],
|
||||
["an issuer that merely contains Google's", () => idToken({ iss: "https://accounts.google.com.evil.example" }), "bad_issuer"],
|
||||
["another client's audience", () => idToken({ aud: "other-client", azp: "other-client" }), "bad_audience"],
|
||||
["an array audience whose azp is not this client", () => idToken({ aud: [CLIENT_ID, "other"], azp: "other" }), "bad_audience"],
|
||||
["an array audience with no azp", () => idToken({ aud: [CLIENT_ID], azp: undefined }), "bad_audience"],
|
||||
["an expired token", () => idToken({ exp: NOW_S - 61 }), "expired"],
|
||||
["a token with no exp", () => idToken({}, { omit: ["exp"] }), "expired"],
|
||||
["a token issued in the future", () => idToken({ iat: NOW_S + 3600 }), "not_yet_valid"],
|
||||
["a token with no iat", () => idToken({}, { omit: ["iat"] }), "not_yet_valid"],
|
||||
["a nonce this request did not carry", () => idToken({ nonce: "someone-elses" }), "bad_nonce"],
|
||||
["a token with no nonce", () => idToken({}, { omit: ["nonce"] }), "bad_nonce"],
|
||||
["no subject", () => idToken({}, { omit: ["sub"] }), "missing_subject"],
|
||||
["an empty subject", () => idToken({ sub: "" }), "missing_subject"],
|
||||
["no email", () => idToken({}, { omit: ["email"] }), "email_missing"],
|
||||
["an unverified email", () => idToken({ email_verified: false }), "email_not_verified"],
|
||||
["no email_verified claim", () => idToken({}, { omit: ["email_verified"] }), "email_not_verified"],
|
||||
["a string email_verified other than true", () => idToken({ email_verified: "yes" }), "email_not_verified"],
|
||||
["alg none", () => idToken({}, { alg: "none" }), "unsupported_algorithm"],
|
||||
["alg HS256", () => idToken({}, { alg: "HS256" }), "unsupported_algorithm"],
|
||||
["a key Google does not publish", () => idToken({}, { kid: "unknown" }), "unknown_key"],
|
||||
["a signature by another key under Google's kid", () => idToken({}, { key: otherRsa.privateKey }), "bad_signature"],
|
||||
["three empty parts", () => "..", "malformed"],
|
||||
["two parts", () => "a.b", "malformed"],
|
||||
])("refuses %s", async (_name, make, code) => {
|
||||
expect(await refusal(make())).toBe(code);
|
||||
});
|
||||
|
||||
it("checks the signature before it believes any claim", async () => {
|
||||
// A forged payload with every claim right is still refused as a bad signature.
|
||||
const forged = idToken({}, { key: otherRsa.privateKey });
|
||||
expect(await refusal(forged)).toBe("bad_signature");
|
||||
});
|
||||
|
||||
it("takes email_verified string 'true' as Google's older tokens spell it", async () => {
|
||||
await expect(verifyGoogleIdToken(idToken({ email_verified: "true" }), { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS)).resolves.toMatchObject({
|
||||
email: "meta@example.org",
|
||||
});
|
||||
});
|
||||
|
||||
it("caches Google's keys and refetches once for a rotated kid, not for every bad token", async () => {
|
||||
await verifyGoogleIdToken(idToken(), { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS);
|
||||
await verifyGoogleIdToken(idToken(), { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS + 1000);
|
||||
expect(jwksFetches).toBe(1);
|
||||
serveJwks({ k1: rsa.publicKey, k2: otherRsa.publicKey });
|
||||
const rotated = idToken({}, { kid: "k2", key: otherRsa.privateKey });
|
||||
// Inside the refetch floor the unknown kid is refused without a fetch.
|
||||
await expect(verifyGoogleIdToken(rotated, { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS + 2000)).rejects.toMatchObject({ code: "unknown_key" });
|
||||
expect(jwksFetches).toBe(1);
|
||||
await expect(verifyGoogleIdToken(rotated, { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS + 120_000)).resolves.toMatchObject({ sub: "110169484474386276334" });
|
||||
expect(jwksFetches).toBe(2);
|
||||
});
|
||||
|
||||
it("refuses with jwks_unavailable when Google's key endpoint fails", async () => {
|
||||
resetGoogleJwksCache();
|
||||
globalThis.fetch = (async () => new Response("down", { status: 503 })) as typeof fetch;
|
||||
expect(await refusal(idToken())).toBe("jwks_unavailable");
|
||||
});
|
||||
|
||||
it("never quotes the token in its refusal", async () => {
|
||||
const token = idToken({ email: "secret-person@example.org", nonce: "wrong" });
|
||||
try {
|
||||
await verifyGoogleIdToken(token, { clientId: CLIENT_ID, nonce: NONCE }, NOW_MS);
|
||||
} catch (error) {
|
||||
expect(String((error as Error).message)).not.toContain("secret-person");
|
||||
expect(String((error as Error).message)).not.toContain(token.slice(0, 20));
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("deriveOidcSecrets", () => {
|
||||
const key = generateKeyPairSync("ed25519").privateKey;
|
||||
const otherKey = generateKeyPairSync("ed25519").privateKey;
|
||||
|
||||
it("is the same pair for the same state and Heimdall key, so nothing is stored between start and callback", () => {
|
||||
expect(deriveOidcSecrets("jti-1", key)).toEqual(deriveOidcSecrets("jti-1", key));
|
||||
});
|
||||
|
||||
it("differs per state, per Heimdall key, and between verifier and nonce", () => {
|
||||
const a = deriveOidcSecrets("jti-1", key);
|
||||
expect(deriveOidcSecrets("jti-2", key).codeVerifier).not.toBe(a.codeVerifier);
|
||||
expect(deriveOidcSecrets("jti-2", key).nonce).not.toBe(a.nonce);
|
||||
expect(deriveOidcSecrets("jti-1", otherKey).codeVerifier).not.toBe(a.codeVerifier);
|
||||
expect(a.codeVerifier).not.toBe(a.nonce);
|
||||
});
|
||||
|
||||
it("yields an RFC 7636 verifier (43-128 unreserved characters) and its S256 challenge", () => {
|
||||
const { codeVerifier, codeChallenge } = deriveOidcSecrets("jti-1", key);
|
||||
expect(codeVerifier).toMatch(/^[A-Za-z0-9_-]{43,128}$/);
|
||||
expect(codeChallenge).toMatch(/^[A-Za-z0-9_-]{43}$/);
|
||||
expect(codeChallenge).not.toBe(codeVerifier);
|
||||
});
|
||||
});
|
||||
632
tests/identity-moves.test.ts
Normal file
632
tests/identity-moves.test.ts
Normal file
|
|
@ -0,0 +1,632 @@
|
|||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { buildApp } from "../src/app.js";
|
||||
import { builtInAppProfiles } from "../src/app-profiles.js";
|
||||
import { AUTH_PROOF_TTL_SECONDS, issueAccessClaim, proofTier } from "../src/claims.js";
|
||||
import { type AppSlug, type Provider } from "../src/contracts.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { createRuntimeKeyMaterial } from "../src/signing.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { type CreateAuditEventInput } from "../src/store/types.js";
|
||||
import { createTestConfig, launchFlow } from "./oauth-flow.js";
|
||||
|
||||
// POST /v1/apps/{app}/identity-moves, driven over HTTP the way Bifrost would
|
||||
// call it: the proofs are real access tokens whose claims say how and through
|
||||
// which login the member signed in; the answers are what a caller can see.
|
||||
|
||||
const now = "2026-11-14T12:00:00.000Z";
|
||||
const appAuth = { "x-heimdall-app-secret": "bifrost-secret" };
|
||||
const moveId = (tag: string) => `move-${tag}`.padEnd(20, "x");
|
||||
const nowS = () => Math.floor(Date.now() / 1000);
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), "heimdall-identity-moves-"));
|
||||
const config = { ...createTestConfig(), signingPrivateKeyPath: join(dir, "signing.pem"), bootstrapSigningPrivateKeyOnMissing: true };
|
||||
afterAll(() => rmSync(dir, { recursive: true, force: true }));
|
||||
|
||||
const apps: Awaited<ReturnType<typeof buildApp>>[] = [];
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
vi.restoreAllMocks();
|
||||
await Promise.all(apps.splice(0).map((app) => app.close()));
|
||||
});
|
||||
|
||||
function twitchRuntime(providerUserId: string): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return { accessToken: "at", refreshToken: "rt", tokenType: "Bearer", scope: ["user:read:email"], raw: {} };
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return { provider: "twitch", providerUserId, username: providerUserId, profile: { id: providerUserId } };
|
||||
},
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function discordRuntime(providerUserId: string): OAuthProviderRuntime {
|
||||
return { ...twitchRuntime(providerUserId), async resolveIdentity() { return { provider: "discord", providerUserId, username: providerUserId, profile: { id: providerUserId } }; } };
|
||||
}
|
||||
|
||||
async function rig(twitchUser = "t-signin") {
|
||||
const store = new InMemoryStore();
|
||||
const audit: CreateAuditEventInput[] = [];
|
||||
const realAudit = store.createAuditEvent.bind(store);
|
||||
store.createAuditEvent = async (input) => {
|
||||
audit.push(structuredClone(input));
|
||||
return realAudit(input);
|
||||
};
|
||||
const app = await buildApp({ config, store, oauthRuntimes: { twitch: twitchRuntime(twitchUser), discord: discordRuntime("d-linked") } });
|
||||
apps.push(app);
|
||||
const keys = createRuntimeKeyMaterial({ ...config, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
return { app, store, keys, audit };
|
||||
}
|
||||
type Rig = Awaited<ReturnType<typeof rig>>;
|
||||
|
||||
let seq = 0;
|
||||
/** An account holding the given logins, each with a credential, and one live-session proof factory. */
|
||||
async function acct(r: Rig, held: Array<[Provider, string?]>) {
|
||||
seq += 1;
|
||||
const account = await r.store.createAccount({ createdAt: now, lastSeenAt: now, displayName: "DISPLAY-CANARY", primaryEmail: "canary@example.test" });
|
||||
const rows = [];
|
||||
for (const [provider, user] of held) {
|
||||
rows.push(
|
||||
await r.store.upsertLinkedIdentity({
|
||||
accountId: account.id,
|
||||
provider,
|
||||
providerUserId: user ?? `${provider}-${seq}`,
|
||||
scopes: ["identify"],
|
||||
accessTokenEncrypted: "ACCESS-CIPHERTEXT",
|
||||
refreshTokenEncrypted: "REFRESH-CIPHERTEXT",
|
||||
profileJson: {},
|
||||
createdAt: now,
|
||||
updatedAt: now,
|
||||
})
|
||||
);
|
||||
}
|
||||
return { account, rows };
|
||||
}
|
||||
type Acct = Awaited<ReturnType<typeof acct>>;
|
||||
|
||||
interface ProofOptions {
|
||||
app?: AppSlug;
|
||||
/** Seconds since the sign-in; null mints a token with no sign-in claim (a refresh or link would). */
|
||||
signedInAgo?: number | null;
|
||||
via?: number;
|
||||
stepUp?: { agoS?: number; method: string };
|
||||
}
|
||||
/** A live session for the account and the access token it would hold. */
|
||||
async function proof(r: Rig, a: Acct, o: ProofOptions = {}) {
|
||||
const ago = o.signedInAgo === undefined ? 0 : o.signedInAgo;
|
||||
const issued = await issueAccessClaim({
|
||||
config,
|
||||
keys: r.keys,
|
||||
store: r.store,
|
||||
input: {
|
||||
appSlug: o.app ?? "bifrost",
|
||||
accountId: a.account.id,
|
||||
linkedIdentities: a.rows.map((row) => ({ provider: row.provider, providerUserId: row.providerUserId })),
|
||||
facts: [],
|
||||
...(ago === null ? {} : { authAt: nowS() - ago, authIdentityId: a.rows[o.via ?? 0]!.id }),
|
||||
...(o.stepUp ? { stepUpAt: nowS() - (o.stepUp.agoS ?? 0), stepUpMethod: o.stepUp.method } : {}),
|
||||
},
|
||||
});
|
||||
return { token: issued.accessToken, sid: issued.session.sessionId };
|
||||
}
|
||||
const passkey = { method: "bifrost-passkey" };
|
||||
|
||||
const move = (r: Rig, body: object, headers: Record<string, string> = appAuth, app = "bifrost") =>
|
||||
r.app.inject({ method: "POST", url: `/v1/apps/${app}/identity-moves`, headers, payload: body });
|
||||
const held = async (r: Rig, a: Acct) => (await r.store.listStoredLinkedIdentitiesForAccount(a.account.id)).map((i) => i.id).sort();
|
||||
const err = (res: { statusCode: number; json(): { error?: string } }) => [res.statusCode, res.json().error];
|
||||
|
||||
/** Source with discord+google, destination with patreon: a passkey on the source and any fresh proof on the destination. */
|
||||
async function scene(r: Rig) {
|
||||
const from = await acct(r, [["discord"], ["google"]]);
|
||||
const to = await acct(r, [["patreon"]]);
|
||||
return {
|
||||
from,
|
||||
to,
|
||||
fromProof: await proof(r, from, { stepUp: passkey }),
|
||||
toProof: await proof(r, to),
|
||||
};
|
||||
}
|
||||
|
||||
describe("a sanctioned move", () => {
|
||||
it("two fresh proofs move every login of the source and answer the receipt, with no token, email or name", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const sourceIds = await held(r, s.from);
|
||||
const res = await move(r, { moveId: moveId("a"), fromProofs: [s.fromProof.token], toProof: s.toProof.token });
|
||||
expect(res.statusCode).toBe(200);
|
||||
expect(res.headers["cache-control"]).toBe("no-store");
|
||||
expect(res.json()).toEqual({
|
||||
moveId: moveId("a"),
|
||||
accountId: s.to.account.id,
|
||||
movedIdentityIds: expect.arrayContaining(sourceIds),
|
||||
proof: { from: "strong", to: "weak" },
|
||||
});
|
||||
expect(res.json().movedIdentityIds).toHaveLength(2);
|
||||
expect(res.body).not.toMatch(/CIPHERTEXT|canary|DISPLAY|ey[A-Za-z0-9_-]{20,}\./);
|
||||
expect(await held(r, s.from)).toEqual([]);
|
||||
expect(await held(r, s.to)).toEqual(expect.arrayContaining(sourceIds));
|
||||
expect(await held(r, s.to)).toHaveLength(3);
|
||||
expect(r.audit.find((e) => e.eventType === "identity_moved")).toMatchObject({
|
||||
accountId: s.from.account.id,
|
||||
eventPayloadJson: { moveId: moveId("a"), toAccountId: s.to.account.id, providers: ["discord", "google"], reversesMoveId: null },
|
||||
});
|
||||
});
|
||||
|
||||
it("answers the identical body for the same moveId after the source's sessions are revoked, and changes nothing twice", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const body = { moveId: moveId("b"), fromProofs: [s.fromProof.token], toProof: s.toProof.token };
|
||||
const first = await move(r, body);
|
||||
expect(first.statusCode).toBe(200);
|
||||
const session = await r.store.findSession("bifrost", s.fromProof.sid);
|
||||
expect(Date.parse(session!.expiresAt), "the source's session is already dead").toBeLessThanOrEqual(Date.now());
|
||||
const again = await move(r, body);
|
||||
expect([again.statusCode, again.body]).toEqual([200, first.body]);
|
||||
expect(r.audit.filter((e) => e.eventType === "identity_moved")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("a moveId reused for another account pair, another proof owner or another reversesMoveId is 409 move_id_conflict and changes nothing", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const other = await acct(r, [["twitch"]]);
|
||||
await move(r, { moveId: moveId("c"), fromProofs: [s.fromProof.token], toProof: s.toProof.token });
|
||||
const otherProof = await proof(r, other);
|
||||
const toStranger = await move(r, { moveId: moveId("c"), fromProofs: [s.fromProof.token], toProof: otherProof.token });
|
||||
expect(err(toStranger)).toEqual([409, "move_id_conflict"]);
|
||||
const fromStranger = await move(r, { moveId: moveId("c"), fromProofs: [otherProof.token], toProof: s.toProof.token });
|
||||
expect(err(fromStranger)).toEqual([409, "move_id_conflict"]);
|
||||
const asReversal = await move(r, { moveId: moveId("c"), fromProofs: [s.toProof.token], reversesMoveId: moveId("zz") });
|
||||
expect(err(asReversal)).toEqual([409, "move_id_conflict"]);
|
||||
expect(await held(r, other)).toHaveLength(1);
|
||||
expect(await held(r, s.to)).toHaveLength(3);
|
||||
});
|
||||
|
||||
it("a replay whose proofs are another app's tokens, or another account's, is 409 move_id_conflict, not the stored receipt", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const body = { moveId: moveId("rp"), fromProofs: [s.fromProof.token], toProof: s.toProof.token };
|
||||
expect((await move(r, body)).statusCode).toBe(200);
|
||||
const foreign = await proof(r, s.from, { app: "streampixels", stepUp: passkey });
|
||||
expect(err(await move(r, { ...body, fromProofs: [foreign.token] }))).toEqual([409, "move_id_conflict"]);
|
||||
const foreignTo = await proof(r, s.to, { app: "streampixels" });
|
||||
expect(err(await move(r, { ...body, toProof: foreignTo.token }))).toEqual([409, "move_id_conflict"]);
|
||||
expect((await move(r, body)).statusCode, "the genuine proofs still replay").toBe(200);
|
||||
});
|
||||
|
||||
it("an app without the secret is 401; streampixels with its own secret is 403 not_allowed_for_app", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const body = { moveId: moveId("d"), fromProofs: [s.fromProof.token], toProof: s.toProof.token };
|
||||
expect(err(await move(r, body, {}))).toEqual([401, "app_auth_required"]);
|
||||
expect(err(await move(r, body, { "x-heimdall-app-secret": "nope" }))).toEqual([401, "app_auth_required"]);
|
||||
expect(err(await move(r, body, { "x-heimdall-app-secret": "streampixels-secret" }, "streampixels"))).toEqual([403, "not_allowed_for_app"]);
|
||||
expect(await held(r, s.from)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("only bifrost is granted moves, and its account proofs are methods it may assert", () => {
|
||||
const granted = Object.values(builtInAppProfiles).filter((p) => p.identityMoves !== undefined);
|
||||
expect(granted.map((p) => p.slug)).toEqual(["bifrost"]);
|
||||
const bifrost = granted[0]!;
|
||||
expect(bifrost.identityMoves!.accountProofMethods.every((m) => bifrost.stepUpAssertion!.methods.includes(m))).toBe(true);
|
||||
expect(bifrost.identityMoves!.accountProofMethods).not.toContain("bifrost-email-code");
|
||||
});
|
||||
});
|
||||
|
||||
describe("what a proof must be", () => {
|
||||
it("another app's token, a revoked session and a forged signature are 403 proof_invalid and nothing moves", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const foreign = await proof(r, s.from, { app: "streampixels", stepUp: passkey });
|
||||
const revoked = await proof(r, s.from, { stepUp: passkey });
|
||||
await r.store.revokeSession("bifrost", revoked.sid, s.from.account.id, 1, new Date().toISOString());
|
||||
const forged = s.fromProof.token.slice(0, -6) + "AAAAAA";
|
||||
for (const [fromProofs, toProof, who] of [
|
||||
[[foreign.token], s.toProof.token, "from"],
|
||||
[[revoked.token], s.toProof.token, "from"],
|
||||
[[forged], s.toProof.token, "from"],
|
||||
[[s.fromProof.token], forged, "to"],
|
||||
] as const) {
|
||||
const res = await move(r, { moveId: moveId("e"), fromProofs, toProof });
|
||||
expect([res.statusCode, res.json()]).toEqual([403, { error: "proof_invalid", proof: who }]);
|
||||
}
|
||||
expect(await held(r, s.from)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("a sign-in 300 s old passes and 301 s is proof_stale; a token with no sign-in claim (refresh, link) is proof_stale; a step-up inside 600 s reports strong", async () => {
|
||||
const r = await rig();
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
vi.setSystemTime(new Date(now));
|
||||
const to = await acct(r, [["patreon"]]);
|
||||
const toProof = await proof(r, to);
|
||||
const providers: Provider[] = ["discord", "google", "twitch", "github", "spotify", "youtube"];
|
||||
const attempt = async (tag: string, o: ProofOptions) => {
|
||||
const from = await acct(r, [[providers.shift()!]]);
|
||||
const p = await proof(r, from, o);
|
||||
return move(r, { moveId: moveId(tag), fromProofs: [p.token], toProof: toProof.token });
|
||||
};
|
||||
const edge = await attempt("edge", { signedInAgo: AUTH_PROOF_TTL_SECONDS });
|
||||
expect([edge.statusCode, edge.json().proof]).toEqual([200, { from: "weak", to: "weak" }]);
|
||||
const late = await attempt("late", { signedInAgo: AUTH_PROOF_TTL_SECONDS + 1 });
|
||||
expect([late.statusCode, late.json()]).toEqual([403, { error: "proof_stale", proof: "from" }]);
|
||||
const none = await attempt("none", { signedInAgo: null });
|
||||
expect(err(none)).toEqual([403, "proof_stale"]);
|
||||
const strong = await attempt("strong", { signedInAgo: 5_000, stepUp: { agoS: 600, method: "provider:twitch" } });
|
||||
expect([strong.statusCode, strong.json().proof.from]).toEqual([200, "strong"]);
|
||||
const stale = await attempt("stale", { signedInAgo: 5_000, stepUp: { agoS: 601, method: "bifrost-passkey" } });
|
||||
expect(err(stale)).toEqual([403, "proof_stale"]);
|
||||
// The destination's proof is held to the same rule.
|
||||
const from = await acct(r, [["google"]]);
|
||||
const fresh = await proof(r, from);
|
||||
const staleTo = await proof(r, to, { signedInAgo: AUTH_PROOF_TTL_SECONDS + 1 });
|
||||
const res = await move(r, { moveId: moveId("sto"), fromProofs: [fresh.token], toProof: staleTo.token });
|
||||
expect([res.statusCode, res.json()]).toEqual([403, { error: "proof_stale", proof: "to" }]);
|
||||
});
|
||||
|
||||
it("fromProofs naming two accounts is 403 proof_invalid; one account on both sides is 409 same_account", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const split = await move(r, { moveId: moveId("f"), fromProofs: [s.fromProof.token, s.toProof.token], toProof: s.toProof.token });
|
||||
expect([split.statusCode, split.json()]).toEqual([403, { error: "proof_invalid", proof: "from" }]);
|
||||
const twice = await proof(r, s.from, { stepUp: passkey });
|
||||
const same = await move(r, { moveId: moveId("g"), fromProofs: [s.fromProof.token], toProof: twice.token });
|
||||
expect(err(same)).toEqual([409, "same_account"]);
|
||||
expect(await held(r, s.from)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("the body is closed: a forward move needs toProof, a reversal takes no toProof or identityIds, ids are patterned", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const t = s.fromProof.token;
|
||||
for (const body of [
|
||||
{ moveId: moveId("h"), fromProofs: [t] },
|
||||
{ moveId: "short", fromProofs: [t], toProof: t },
|
||||
{ moveId: moveId("h"), fromProofs: [], toProof: t },
|
||||
{ moveId: moveId("h"), fromProofs: [t], toProof: t, reversesMoveId: moveId("i") },
|
||||
{ moveId: moveId("h"), fromProofs: [t], reversesMoveId: moveId("i"), identityIds: ["x"] },
|
||||
]) {
|
||||
expect((await move(r, body)).statusCode, JSON.stringify(Object.keys(body))).toBe(400);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("accounts come only from proofs", () => {
|
||||
it("a stray accountId in the body steers nothing", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const stranger = await acct(r, [["twitch"]]);
|
||||
const res = await move(r, { moveId: moveId("y"), fromProofs: [s.fromProof.token], toProof: s.toProof.token, accountId: stranger.account.id, toAccountId: stranger.account.id });
|
||||
expect([res.statusCode, res.json().accountId]).toEqual([200, s.to.account.id]);
|
||||
expect(await held(r, stranger)).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("which logins a proof moves", () => {
|
||||
async function multi(r: Rig) {
|
||||
const from = await acct(r, [["discord"], ["google"], ["twitch"]]);
|
||||
const to = await acct(r, [["patreon"]]);
|
||||
return { from, to, toProof: await proof(r, to) };
|
||||
}
|
||||
|
||||
it("a sign-in through login X moves X and cannot move the source's other logins", async () => {
|
||||
const r = await rig();
|
||||
const s = await multi(r);
|
||||
const [discord, google] = s.from.rows;
|
||||
const viaDiscord = await proof(r, s.from, { via: 0 });
|
||||
const all = await move(r, { moveId: moveId("j"), fromProofs: [viaDiscord.token], toProof: s.toProof.token });
|
||||
expect(err(all)).toEqual([403, "identity_not_proved"]);
|
||||
const other = await move(r, { moveId: moveId("j"), fromProofs: [viaDiscord.token], toProof: s.toProof.token, identityIds: [google!.id] });
|
||||
expect(err(other)).toEqual([403, "identity_not_proved"]);
|
||||
expect(await held(r, s.from)).toHaveLength(3);
|
||||
const only = await move(r, { moveId: moveId("j"), fromProofs: [viaDiscord.token], toProof: s.toProof.token, identityIds: [discord!.id] });
|
||||
expect([only.statusCode, only.json().movedIdentityIds]).toEqual([200, [discord!.id]]);
|
||||
expect((await held(r, s.from)).sort()).toEqual([google!.id, s.from.rows[2]!.id].sort());
|
||||
});
|
||||
|
||||
it("one proof per login moves them all; an asserted passkey covers the whole account; an email code covers only its own login", async () => {
|
||||
const r = await rig();
|
||||
let s = await multi(r);
|
||||
const perLogin = await Promise.all(s.from.rows.map((_, via) => proof(r, s.from, { via })));
|
||||
const res = await move(r, { moveId: moveId("k"), fromProofs: perLogin.map((p) => p.token), toProof: s.toProof.token });
|
||||
expect([res.statusCode, res.json().movedIdentityIds]).toHaveLength(2);
|
||||
expect(res.json().proof.from).toBe("weak");
|
||||
expect(await held(r, s.from)).toEqual([]);
|
||||
|
||||
s = await multi(r);
|
||||
const byPasskey = await proof(r, s.from, { stepUp: passkey });
|
||||
expect((await move(r, { moveId: moveId("l"), fromProofs: [byPasskey.token], toProof: s.toProof.token })).statusCode).toBe(200);
|
||||
|
||||
s = await multi(r);
|
||||
const byEmail = await proof(r, s.from, { stepUp: { method: "bifrost-email-code" } });
|
||||
const refused = await move(r, { moveId: moveId("m"), fromProofs: [byEmail.token], toProof: s.toProof.token });
|
||||
expect(err(refused)).toEqual([403, "identity_not_proved"]);
|
||||
expect(await held(r, s.from)).toHaveLength(3);
|
||||
});
|
||||
|
||||
it("a provider held on both sides is 409 provider_conflict naming only the provider, and nothing moves", async () => {
|
||||
const r = await rig();
|
||||
const from = await acct(r, [["discord"], ["google"]]);
|
||||
const to = await acct(r, [["discord"]]);
|
||||
const res = await move(r, { moveId: moveId("n"), fromProofs: [(await proof(r, from, { stepUp: passkey })).token], toProof: (await proof(r, to)).token });
|
||||
expect([res.statusCode, res.json()]).toEqual([409, { error: "provider_conflict", provider: "discord" }]);
|
||||
expect(res.body).not.toContain(from.account.id);
|
||||
expect(await held(r, from)).toHaveLength(2);
|
||||
expect(await held(r, to)).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("naming an identity the source does not hold is 404 identity_not_found", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const res = await move(r, { moveId: moveId("o"), fromProofs: [s.fromProof.token], toProof: s.toProof.token, identityIds: [s.to.rows[0]!.id] });
|
||||
expect(err(res)).toEqual([404, "identity_not_found"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("what a move leaves behind", () => {
|
||||
it("strips the moved credentials, expires the source's sessions, pending links and unredeemed completions, and leaves the destination live", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const linkInput = { appSlug: "bifrost" as const, provider: "discord" as const, providerUserId: "d-x", identity: { accountId: "x", provider: "discord" as const, providerUserId: "d-x", scopes: [], profileJson: {}, createdAt: now, updatedAt: now }, returnTo: "https://bifrost.gamecult.org/x", createdAt: now, expiresAt: "2099-01-01T00:00:00.000Z" };
|
||||
const srcLink = await r.store.createPendingLink({ ...linkInput, accountId: s.from.account.id });
|
||||
const dstLink = await r.store.createPendingLink({ ...linkInput, accountId: s.to.account.id });
|
||||
const completion = (accountId: string) =>
|
||||
r.store.createAuthCompletion({ appSlug: "bifrost", provider: "discord", mode: "sign_in", accountId, sessionId: "sess", returnTo: "https://bifrost.gamecult.org/x", createdAt: now, expiresAt: "2099-01-01T00:00:00.000Z", payloadJson: {} });
|
||||
const srcCompletion = await completion(s.from.account.id);
|
||||
const dstCompletion = await completion(s.to.account.id);
|
||||
const res = await move(r, { moveId: moveId("p"), fromProofs: [s.fromProof.token], toProof: s.toProof.token });
|
||||
expect(res.statusCode).toBe(200);
|
||||
const movedIds = new Set(s.from.rows.map((row) => row.id));
|
||||
for (const row of (await r.store.listStoredLinkedIdentitiesForAccount(s.to.account.id)).filter((row) => movedIds.has(row.id))) {
|
||||
expect(row.accessTokenEncrypted).toBeUndefined();
|
||||
expect(row.refreshTokenEncrypted).toBeUndefined();
|
||||
}
|
||||
const record = await r.store.findIdentityMove(moveId("p"));
|
||||
expect(record?.moved.map((m) => m.credentialStripped)).toEqual([true, true]);
|
||||
expect((await r.store.findSession("bifrost", s.fromProof.sid))!.accessRevision).toBe(2);
|
||||
expect((await r.store.findSession("bifrost", s.toProof.sid))!.accessRevision).toBe(1);
|
||||
expect(Date.parse((await r.store.findSession("bifrost", s.toProof.sid))!.expiresAt)).toBeGreaterThan(Date.now());
|
||||
expect(await r.store.consumePendingLink("bifrost", srcLink.id, s.from.account.id, new Date().toISOString())).toBeNull();
|
||||
expect(await r.store.consumePendingLink("bifrost", dstLink.id, s.to.account.id, new Date().toISOString())).not.toBeNull();
|
||||
expect(await r.store.consumeAuthCompletion("bifrost", srcCompletion.code, new Date().toISOString())).toBeNull();
|
||||
expect(await r.store.consumeAuthCompletion("bifrost", dstCompletion.code, new Date().toISOString())).not.toBeNull();
|
||||
});
|
||||
|
||||
it("revokes the source's live grants for the providers it no longer holds, leaves the destination's receipts, and a replay heals a crash after commit", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const grant = (accountId: string, provider: Provider) =>
|
||||
r.store.createConsentReceipt({ kind: "grant", accountId, appSlug: "bifrost", provider, createdAt: now, scopesAsked: ["identify"], scopesGranted: ["identify"], consentPageDigest: "d", consentText: "t" });
|
||||
await grant(s.from.account.id, "discord");
|
||||
await grant(s.to.account.id, "patreon");
|
||||
const receiptsOf = async (a: Acct) => (await r.store.listConsentReceipts(a.account.id)).map((x) => `${x.kind}:${x.provider}`);
|
||||
const body = { moveId: moveId("q"), fromProofs: [s.fromProof.token], toProof: s.toProof.token };
|
||||
vi.spyOn(r.store, "createConsentReceipt").mockRejectedValueOnce(new Error("crash after commit"));
|
||||
expect((await move(r, body)).statusCode).toBe(500);
|
||||
expect(await held(r, s.from), "the move itself committed").toEqual([]);
|
||||
expect(await receiptsOf(s.from)).toEqual(["grant:discord"]);
|
||||
const healed = await move(r, body);
|
||||
expect(healed.statusCode).toBe(200);
|
||||
expect(await receiptsOf(s.from)).toEqual(["grant:discord", "revocation:discord"]);
|
||||
expect(await receiptsOf(s.to)).toEqual(["grant:patreon"]);
|
||||
expect((await move(r, body)).body, "and it is idempotent").toBe(healed.body);
|
||||
expect(await receiptsOf(s.from)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("the destination never loses an identity, whatever is refused", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const before = (await held(r, s.to)).length;
|
||||
const refusals = [
|
||||
{ moveId: moveId("r1"), fromProofs: [s.fromProof.token], toProof: s.toProof.token, identityIds: ["nope"] },
|
||||
{ moveId: moveId("r2"), fromProofs: [s.fromProof.token], toProof: s.fromProof.token },
|
||||
{ moveId: moveId("r3"), fromProofs: [s.toProof.token], toProof: s.toProof.token },
|
||||
];
|
||||
for (const body of refusals) {
|
||||
await move(r, body);
|
||||
expect((await held(r, s.to)).length).toBeGreaterThanOrEqual(before);
|
||||
}
|
||||
expect((await move(r, { moveId: moveId("r4"), fromProofs: [s.fromProof.token], toProof: s.toProof.token })).statusCode).toBe(200);
|
||||
expect((await held(r, s.to)).length).toBeGreaterThanOrEqual(before);
|
||||
});
|
||||
|
||||
it("a sign-in through a moved login lands on the destination, with no alias lookup", async () => {
|
||||
const r = await rig("t-moved");
|
||||
const from = await acct(r, [["twitch", "t-moved"]]);
|
||||
const to = await acct(r, [["patreon"]]);
|
||||
const mv = await move(r, { moveId: moveId("s"), fromProofs: [(await proof(r, from, { stepUp: passkey })).token], toProof: (await proof(r, to)).token });
|
||||
expect(mv.statusCode).toBe(200);
|
||||
const started = await r.app.inject({ method: "POST", url: "/v1/oauth/twitch/start", payload: { appSlug: "streampixels", mode: "sign_in", returnTo: "https://streampixels.gamecult.org/signin/return" } });
|
||||
const flow = await launchFlow(r.app, started.json());
|
||||
const called = await r.app.inject({ method: "GET", url: `/v1/oauth/twitch/callback?code=c&state=${encodeURIComponent(flow.state)}`, headers: { cookie: flow.cookie, accept: "application/json" } });
|
||||
expect(called.statusCode).toBe(201);
|
||||
expect(called.json().account.id).toBe(to.account.id);
|
||||
});
|
||||
});
|
||||
|
||||
describe("aliases and reversal", () => {
|
||||
it("an emptied source is an alias; moving into or out of it is 409 already_moved", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
expect((await move(r, { moveId: moveId("t"), fromProofs: [s.fromProof.token], toProof: s.toProof.token })).statusCode).toBe(200);
|
||||
// A session can outlive its logins only by being minted for an account that holds none, which is how a stale caller would look.
|
||||
const aliasProof = await proof(r, { account: s.from.account, rows: [s.to.rows[0]!] }, { stepUp: passkey });
|
||||
const third = await acct(r, [["github"]]);
|
||||
const out = await move(r, { moveId: moveId("u"), fromProofs: [aliasProof.token], toProof: (await proof(r, third)).token });
|
||||
expect(err(out)).toEqual([409, "already_moved"]);
|
||||
const aliasTo = await proof(r, { account: s.from.account, rows: [s.to.rows[0]!] });
|
||||
const into = await move(r, { moveId: moveId("u2"), fromProofs: [(await proof(r, third, { stepUp: passkey })).token], toProof: aliasTo.token });
|
||||
expect(err(into)).toEqual([409, "already_moved"]);
|
||||
expect(await held(r, third)).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("a reversal through a moved login moves exactly those logins back; a second reversal is not_reversible; credentials stay stripped", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const sourceIds = await held(r, s.from);
|
||||
await move(r, { moveId: moveId("v"), fromProofs: [s.fromProof.token], toProof: s.toProof.token });
|
||||
const [discord, google] = s.from.rows;
|
||||
// The destination now holds the moved logins: a sign-in through one of them is a proof of the destination.
|
||||
const viaMoved = await proof(r, { account: s.to.account, rows: [discord!, google!] }, { via: 0 });
|
||||
const own = await proof(r, s.to, { via: 0 });
|
||||
const denied = await move(r, { moveId: moveId("w"), fromProofs: [own.token], reversesMoveId: moveId("v") });
|
||||
expect(err(denied), "the destination's own login does not speak for the moved ones").toEqual([403, "identity_not_proved"]);
|
||||
const viaBoth = [viaMoved, await proof(r, { account: s.to.account, rows: [discord!, google!] }, { via: 1 })];
|
||||
const back = await move(r, { moveId: moveId("w"), fromProofs: viaBoth.map((p) => p.token), reversesMoveId: moveId("v") });
|
||||
expect(back.statusCode, back.body).toBe(200);
|
||||
expect(back.json()).toEqual({ moveId: moveId("w"), accountId: s.from.account.id, movedIdentityIds: expect.arrayContaining(sourceIds), proof: { from: "weak", to: null }, reversesMoveId: moveId("v") });
|
||||
expect(await held(r, s.from)).toEqual(sourceIds);
|
||||
expect(await held(r, s.to)).toHaveLength(1);
|
||||
expect((await r.store.listStoredLinkedIdentitiesForAccount(s.from.account.id)).every((i) => i.accessTokenEncrypted === undefined)).toBe(true);
|
||||
const own2 = await proof(r, s.to, { via: 0 });
|
||||
const again = await move(r, { moveId: moveId("w2"), fromProofs: [own2.token], reversesMoveId: moveId("v") });
|
||||
expect(err(again)).toEqual([409, "not_reversible"]);
|
||||
const reverseTheReversal = await move(r, { moveId: moveId("w3"), fromProofs: [(await proof(r, s.from)).token], reversesMoveId: moveId("w") });
|
||||
expect(err(reverseTheReversal)).toEqual([409, "not_reversible"]);
|
||||
const unknown = await move(r, { moveId: moveId("w4"), fromProofs: [(await proof(r, s.from)).token], reversesMoveId: moveId("nothere") });
|
||||
expect(err(unknown)).toEqual([409, "not_reversible"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("proofTier", () => {
|
||||
it("a proof dated in the future proves nothing, whichever claim carries it", () => {
|
||||
const n = nowS();
|
||||
expect(proofTier({ auth_at: n + 5 }, n)).toBeNull();
|
||||
expect(proofTier({ step_up_at: n + 5 }, n)).toBeNull();
|
||||
expect(proofTier({ step_up_at: n + 5, auth_at: n }, n), "a future step-up does not hide a valid sign-in").toBe("weak");
|
||||
expect(proofTier({ step_up_at: n, auth_at: n - 9_999 }, n)).toBe("strong");
|
||||
});
|
||||
});
|
||||
|
||||
describe("the reversal's source must be the forward move's destination", () => {
|
||||
it("is refused as not_reversible before the proofs are judged, even for a stale proof", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
expect((await move(r, { moveId: moveId("fw"), fromProofs: [s.fromProof.token], toProof: s.toProof.token })).statusCode).toBe(200);
|
||||
const third = await acct(r, [["github"]]);
|
||||
const onward = await proof(r, s.to, { stepUp: passkey });
|
||||
expect((await move(r, { moveId: moveId("on"), fromProofs: [onward.token], toProof: (await proof(r, third)).token })).statusCode).toBe(200);
|
||||
const stale = await proof(r, third, { signedInAgo: 9_999 });
|
||||
const res = await move(r, { moveId: moveId("rv"), fromProofs: [stale.token], reversesMoveId: moveId("fw") });
|
||||
expect(err(res)).toEqual([409, "not_reversible"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("idempotency is by moveId", () => {
|
||||
it("a replayed reversal under another reversesMoveId is 409 move_id_conflict, not the stored receipt", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
await move(r, { moveId: moveId("fw2"), fromProofs: [s.fromProof.token], toProof: s.toProof.token });
|
||||
const [discord, google] = s.from.rows;
|
||||
const viaMoved = async (via: number) => (await proof(r, { account: s.to.account, rows: [discord!, google!] }, { via })).token;
|
||||
const body = { moveId: moveId("rv2"), fromProofs: [await viaMoved(0), await viaMoved(1)], reversesMoveId: moveId("fw2") };
|
||||
const back = await move(r, body);
|
||||
expect(back.statusCode, back.body).toBe(200);
|
||||
expect((await move(r, body)).body, "the same body replays").toBe(back.body);
|
||||
expect(err(await move(r, { ...body, reversesMoveId: moveId("other") }))).toEqual([409, "move_id_conflict"]);
|
||||
expect(await held(r, s.from)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("a replay with the same moveId and different identityIds returns the first receipt (steward ruling: the key is the moveId, a retry carries the same body)", async () => {
|
||||
const r = await rig();
|
||||
const from = await acct(r, [["discord"], ["google"]]);
|
||||
const to = await acct(r, [["patreon"]]);
|
||||
const fromProof = await proof(r, from, { stepUp: passkey });
|
||||
const toProof = await proof(r, to);
|
||||
const first = await move(r, { moveId: moveId("ids"), fromProofs: [fromProof.token], toProof: toProof.token, identityIds: [from.rows[0]!.id] });
|
||||
expect(first.json().movedIdentityIds).toEqual([from.rows[0]!.id]);
|
||||
const again = await move(r, { moveId: moveId("ids"), fromProofs: [fromProof.token], toProof: toProof.token, identityIds: [from.rows[1]!.id] });
|
||||
expect([again.statusCode, again.body]).toEqual([200, first.body]);
|
||||
expect(await held(r, from), "and the second selection did not move").toEqual([from.rows[1]!.id]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("what a refusal says", () => {
|
||||
it("no refusal body names an account id, an email, a name or an identity the caller did not send", async () => {
|
||||
const r = await rig();
|
||||
const s = await scene(r);
|
||||
const stranger = await acct(r, [["discord", "d-stranger"]]);
|
||||
const bodies = [
|
||||
await move(r, { moveId: moveId("x1"), fromProofs: [s.fromProof.token], toProof: "garbage" }),
|
||||
await move(r, { moveId: moveId("x2"), fromProofs: [(await proof(r, s.from, { via: 0 })).token], toProof: s.toProof.token }),
|
||||
await move(r, { moveId: moveId("x3"), fromProofs: [s.fromProof.token], toProof: s.toProof.token, identityIds: [stranger.rows[0]!.id] }),
|
||||
await move(r, { moveId: moveId("x4"), fromProofs: [s.toProof.token], toProof: s.toProof.token }),
|
||||
await move(r, { moveId: moveId("x5"), fromProofs: [s.fromProof.token], reversesMoveId: moveId("nothere") }),
|
||||
await move(r, { moveId: moveId("x6"), fromProofs: [(await proof(r, s.from, { signedInAgo: 9_999 })).token], toProof: s.toProof.token }),
|
||||
];
|
||||
const ids = [s.from, s.to, stranger].flatMap((a) => [a.account.id, ...a.rows.map((row) => row.id), ...a.rows.map((row) => row.providerUserId)]);
|
||||
for (const res of bodies) {
|
||||
expect(res.statusCode).toBeGreaterThanOrEqual(400);
|
||||
for (const id of ids) expect(res.body).not.toContain(id);
|
||||
expect(res.body).not.toMatch(/canary|DISPLAY/);
|
||||
expect(Object.keys(res.json()).every((k) => ["error", "detail", "proof", "provider"].includes(k))).toBe(true);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("claims: which sign-in a token came from", () => {
|
||||
const returnTo = "https://streampixels.gamecult.org/signin/return";
|
||||
async function twitchSignIn(r: Rig) {
|
||||
const started = await r.app.inject({ method: "POST", url: "/v1/oauth/twitch/start", payload: { appSlug: "streampixels", mode: "sign_in", returnTo } });
|
||||
const flow = await launchFlow(r.app, started.json());
|
||||
const called = await r.app.inject({ method: "GET", url: `/v1/oauth/twitch/callback?code=c&state=${encodeURIComponent(flow.state)}`, headers: { cookie: flow.cookie, accept: "application/json" } });
|
||||
expect(called.statusCode).toBe(201);
|
||||
const redeemed = await r.app.inject({ method: "POST", url: "/v1/apps/streampixels/auth-completions/redeem", payload: { completionCode: called.json().completion.code } });
|
||||
expect(redeemed.statusCode).toBe(201);
|
||||
return redeemed.json() as { refreshToken: string; claimSet: Record<string, unknown> };
|
||||
}
|
||||
|
||||
it("a sign_in stamps auth_at and the login it came through; a refresh does not renew them", async () => {
|
||||
const r = await rig("t-claims");
|
||||
const before = nowS();
|
||||
const signed = await twitchSignIn(r);
|
||||
const row = await r.store.findStoredLinkedIdentity("twitch", "t-claims");
|
||||
expect(signed.claimSet.auth_identity_id).toBe(row!.id);
|
||||
expect(signed.claimSet.auth_at).toBeGreaterThanOrEqual(before);
|
||||
expect(signed.claimSet.auth_at).toBeLessThanOrEqual(nowS());
|
||||
expect(signed.claimSet.step_up_at).toBeUndefined();
|
||||
const refreshed = await r.app.inject({ method: "POST", url: "/v1/apps/streampixels/sessions/refresh", payload: { refreshToken: signed.refreshToken } });
|
||||
expect(refreshed.statusCode).toBe(201);
|
||||
expect(refreshed.json().claimSet.auth_at).toBeUndefined();
|
||||
expect(refreshed.json().claimSet.auth_identity_id).toBeUndefined();
|
||||
});
|
||||
|
||||
it("a link callback mints no sign-in proof: no auth_at, no auth_identity_id", async () => {
|
||||
const r = await rig();
|
||||
const holder = await acct(r, [["twitch"]]);
|
||||
const started = await r.app.inject({ method: "POST", url: "/v1/oauth/discord/start", headers: appAuth, payload: { appSlug: "bifrost", mode: "link", initiatingAccountId: holder.account.id, returnTo: "https://bifrost.gamecult.org/x" } });
|
||||
expect(started.statusCode).toBe(201);
|
||||
const flow = await launchFlow(r.app, started.json());
|
||||
const called = await r.app.inject({ method: "GET", url: `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(flow.state)}`, headers: { cookie: flow.cookie, accept: "application/json" } });
|
||||
expect(called.statusCode).toBe(201);
|
||||
expect(called.json().claimSet.identities).toHaveLength(2);
|
||||
expect(called.json().claimSet.auth_at).toBeUndefined();
|
||||
expect(called.json().claimSet.auth_identity_id).toBeUndefined();
|
||||
expect(called.body).not.toMatch(/auth_at|auth_identity_id/);
|
||||
});
|
||||
|
||||
it("a connect callback mints no sign-in proof either", async () => {
|
||||
const r = await rig("t-connect");
|
||||
const started = await r.app.inject({ method: "POST", url: "/v1/oauth/twitch/start", headers: { "x-heimdall-app-secret": "streampixels-secret" }, payload: { appSlug: "streampixels", mode: "connect", returnTo: "https://streampixels.gamecult.org/signin/return", connection: { kind: "creator", targetId: "creator-1" } } });
|
||||
expect(started.statusCode, started.body).toBe(201);
|
||||
const flow = await launchFlow(r.app, started.json());
|
||||
const called = await r.app.inject({ method: "GET", url: `/v1/oauth/twitch/callback?code=c&state=${encodeURIComponent(flow.state)}`, headers: { cookie: flow.cookie, accept: "application/json" } });
|
||||
expect(called.statusCode, called.body).toBe(201);
|
||||
expect(called.body).toContain("claimSet");
|
||||
expect(called.body).not.toMatch(/auth_at|auth_identity_id/);
|
||||
});
|
||||
|
||||
it("an asserted step-up carries the bearer's auth claims through unchanged", async () => {
|
||||
const r = await rig();
|
||||
const a = await acct(r, [["discord"], ["google"]]);
|
||||
const p = await proof(r, a, { via: 1, signedInAgo: 30 });
|
||||
const res = await r.app.inject({ method: "POST", url: "/v1/apps/bifrost/step-up", headers: { ...appAuth, authorization: `Bearer ${p.token}` }, payload: { method: "bifrost-passkey", nonce: "n".repeat(32) } });
|
||||
expect(res.statusCode).toBe(201);
|
||||
expect(res.json().claimSet).toMatchObject({ auth_identity_id: a.rows[1]!.id, auth_at: nowS() - 30, step_up_method: "bifrost-passkey" });
|
||||
});
|
||||
});
|
||||
334
tests/identity-unlink.test.ts
Normal file
334
tests/identity-unlink.test.ts
Normal file
|
|
@ -0,0 +1,334 @@
|
|||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { buildApp } from "../src/app.js";
|
||||
import { issueAccessClaim } from "../src/claims.js";
|
||||
import { type Provider } from "../src/contracts.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { createRuntimeKeyMaterial, decodeJwt, signJwt, verifyJwt } from "../src/signing.js";
|
||||
import { IdentityHeldElsewhereError, InMemoryStore } from "../src/store/index.js";
|
||||
import { createTestConfig, launchFlow, launchState, stateOf } from "./oauth-flow.js";
|
||||
|
||||
// The member's identity surface: list what an account holds, and take one
|
||||
// identity off it. Taking one off is the account's own decision made with
|
||||
// fresh proof (a step-up sign-in inside the proof window), never the
|
||||
// bearer's alone. These tests drive both routes over HTTP as an app would.
|
||||
|
||||
const returnTo = "https://streampixels.gamecult.org/signin/return";
|
||||
const spAuth = { "x-heimdall-app-secret": "streampixels-secret" };
|
||||
const now = "2026-11-13T12:00:00.000Z";
|
||||
|
||||
function runtime(provider: "twitch" | "youtube", providerUserId: string): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return { accessToken: "at", refreshToken: "rt", tokenType: "Bearer", scope: ["user:read:email"], raw: {} };
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return { provider, providerUserId, username: providerUserId, profile: { id: providerUserId } };
|
||||
},
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), "heimdall-unlink-"));
|
||||
const config = { ...createTestConfig(), signingPrivateKeyPath: join(dir, "signing.pem"), bootstrapSigningPrivateKeyOnMissing: true };
|
||||
afterAll(() => rmSync(dir, { recursive: true, force: true }));
|
||||
|
||||
const apps: Awaited<ReturnType<typeof buildApp>>[] = [];
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
await Promise.all(apps.splice(0).map((app) => app.close()));
|
||||
});
|
||||
|
||||
async function rig() {
|
||||
const store = new InMemoryStore();
|
||||
const app = await buildApp({
|
||||
config,
|
||||
store,
|
||||
oauthRuntimes: { twitch: runtime("twitch", "t-1"), youtube: runtime("youtube", "y-1") },
|
||||
});
|
||||
apps.push(app);
|
||||
const keys = createRuntimeKeyMaterial({ ...config, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
return { app, store, keys };
|
||||
}
|
||||
type Rig = Awaited<ReturnType<typeof rig>>;
|
||||
|
||||
async function seedAccount(r: Rig, held: Array<[Provider, string]>) {
|
||||
const account = await r.store.createAccount({ createdAt: now, lastSeenAt: now });
|
||||
const rows = [];
|
||||
for (const [provider, providerUserId] of held) {
|
||||
rows.push(
|
||||
await r.store.upsertLinkedIdentity({
|
||||
accountId: account.id,
|
||||
provider,
|
||||
providerUserId,
|
||||
username: `${provider}-name`,
|
||||
displayName: `${provider} display`,
|
||||
primaryEmail: "secret@example.test",
|
||||
accessTokenEncrypted: "ACCESS-CIPHERTEXT",
|
||||
refreshTokenEncrypted: "REFRESH-CIPHERTEXT",
|
||||
scopes: ["identify"],
|
||||
profileJson: { raw: "PROFILE-CANARY" },
|
||||
createdAt: now,
|
||||
updatedAt: now,
|
||||
})
|
||||
);
|
||||
}
|
||||
return { account, rows };
|
||||
}
|
||||
|
||||
/** A real sign_in through twitch, as StreamPixels runs it, redeemed for the tokens. */
|
||||
async function signIn(r: Rig, stepUp: boolean) {
|
||||
const started = await r.app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/twitch/start",
|
||||
headers: stepUp ? spAuth : {},
|
||||
payload: { appSlug: "streampixels", mode: "sign_in", returnTo, ...(stepUp ? { stepUp: true } : {}) },
|
||||
});
|
||||
expect(started.statusCode).toBe(201);
|
||||
const flow = await launchFlow(r.app, started.json());
|
||||
const called = await r.app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/twitch/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie, accept: "application/json" },
|
||||
});
|
||||
expect(called.statusCode).toBe(201);
|
||||
const redeemed = await r.app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/apps/streampixels/auth-completions/redeem",
|
||||
payload: { completionCode: called.json().completion.code },
|
||||
});
|
||||
expect(redeemed.statusCode).toBe(201);
|
||||
return redeemed.json() as { accessToken: string; refreshToken: string; claimSet: Record<string, unknown> };
|
||||
}
|
||||
|
||||
const bearer = (token: string) => ({ authorization: `Bearer ${token}` });
|
||||
const list = (r: Rig, token?: string) => r.app.inject({ method: "GET", url: "/v1/me/identities", headers: token ? bearer(token) : {} });
|
||||
const unlink = (r: Rig, id: string, token?: string, payload?: unknown) =>
|
||||
r.app.inject({ method: "POST", url: `/v1/me/identities/${encodeURIComponent(id)}/unlink`, headers: token ? bearer(token) : {}, ...(payload !== undefined ? { payload: payload as object } : {}) });
|
||||
|
||||
describe("step_up_at on the access claim", () => {
|
||||
it("a step-up sign-in's claim carries it; an ordinary sign-in and a refresh do not", async () => {
|
||||
const r = await rig();
|
||||
await seedAccount(r, [["twitch", "t-1"], ["youtube", "y-1"]]);
|
||||
const before = Math.floor(Date.now() / 1000);
|
||||
const stepped = await signIn(r, true);
|
||||
expect(stepped.claimSet.step_up_at).toBeGreaterThanOrEqual(before);
|
||||
expect(stepped.claimSet.step_up_at).toBeLessThanOrEqual(Math.floor(Date.now() / 1000));
|
||||
expect(stepped.claimSet.step_up_method).toBe("provider:twitch");
|
||||
const plain = (await signIn(r, false)).claimSet;
|
||||
expect(plain.step_up_at).toBeUndefined();
|
||||
expect(plain.step_up_method).toBeUndefined();
|
||||
|
||||
const refreshed = await r.app.inject({ method: "POST", url: "/v1/apps/streampixels/sessions/refresh", payload: { refreshToken: stepped.refreshToken } });
|
||||
expect(refreshed.statusCode).toBe(201);
|
||||
expect(refreshed.json().claimSet.step_up_at, "a refresh never renews proof").toBeUndefined();
|
||||
expect(refreshed.json().claimSet.step_up_method).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("GET /v1/me/identities", () => {
|
||||
it("is 401 sign_in_required without a live bearer", async () => {
|
||||
const r = await rig();
|
||||
for (const token of [undefined, "not-a-token"]) {
|
||||
const res = await list(r, token);
|
||||
expect([res.statusCode, res.json().error]).toEqual([401, "sign_in_required"]);
|
||||
}
|
||||
});
|
||||
|
||||
it("lists the caller's identities and nothing that is a credential, a profile or an email", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"], ["discord", "d-9"]]);
|
||||
await seedAccount(r, [["youtube", "y-other"]]);
|
||||
const { accessToken } = await signIn(r, false);
|
||||
const res = await list(r, accessToken);
|
||||
expect(res.statusCode).toBe(200);
|
||||
expect(res.headers["cache-control"]).toBe("no-store");
|
||||
const body = res.json();
|
||||
expect(body.accountId).toBe(account.id);
|
||||
expect(body.identities).toEqual([
|
||||
// The sign-in above refreshed the twitch row from what the provider returned.
|
||||
{ id: rows[0]!.id, provider: "twitch", providerUserId: "t-1", username: "t-1", linkedAt: now, scopes: ["user:read:email"] },
|
||||
{ id: rows[1]!.id, provider: "discord", providerUserId: "d-9", username: "discord-name", displayName: "discord display", linkedAt: now, scopes: ["identify"] },
|
||||
]);
|
||||
expect(res.body).not.toMatch(/CIPHERTEXT|PROFILE-CANARY|secret@example|primary_email|primaryEmail/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("POST /v1/me/identities/:identityId/unlink", () => {
|
||||
it("is 401 without a live bearer", async () => {
|
||||
const r = await rig();
|
||||
const { rows } = await seedAccount(r, [["twitch", "t-1"], ["youtube", "y-1"]]);
|
||||
expect((await unlink(r, rows[1]!.id)).statusCode).toBe(401);
|
||||
expect((await unlink(r, rows[1]!.id, "garbage")).statusCode).toBe(401);
|
||||
});
|
||||
|
||||
it("is 403 step_up_required for a bearer with no proof, and for a refresh-issued one, and removes nothing", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"], ["youtube", "y-1"]]);
|
||||
const plain = await signIn(r, false);
|
||||
const denied = await unlink(r, rows[1]!.id, plain.accessToken);
|
||||
expect([denied.statusCode, denied.json().error]).toEqual([403, "step_up_required"]);
|
||||
expect(denied.json().detail).toMatch(/twitch, youtube and google/);
|
||||
|
||||
const stepped = await signIn(r, true);
|
||||
const refreshed = await r.app.inject({ method: "POST", url: "/v1/apps/streampixels/sessions/refresh", payload: { refreshToken: stepped.refreshToken } });
|
||||
const viaRefresh = await unlink(r, rows[1]!.id, refreshed.json().accessToken);
|
||||
expect([viaRefresh.statusCode, viaRefresh.json().error]).toEqual([403, "step_up_required"]);
|
||||
expect(await r.store.listStoredLinkedIdentitiesForAccount(account.id)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("is 403 for proof older than the window and for proof dated in the future; 599 s old still passes", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"], ["youtube", "y-1"], ["discord", "d-1"]]);
|
||||
const issueWith = async (stepUpAt: number) =>
|
||||
(await issueAccessClaim({
|
||||
config,
|
||||
keys: r.keys,
|
||||
store: r.store,
|
||||
input: { appSlug: "streampixels", accountId: account.id, linkedIdentities: [], facts: [], stepUpAt },
|
||||
})).accessToken;
|
||||
const nowS = Math.floor(Date.now() / 1000);
|
||||
for (const at of [nowS - 601, nowS + 120]) {
|
||||
const res = await unlink(r, rows[1]!.id, await issueWith(at));
|
||||
expect([res.statusCode, res.json().error], String(at - nowS)).toEqual([403, "step_up_required"]);
|
||||
}
|
||||
expect(await r.store.listStoredLinkedIdentitiesForAccount(account.id)).toHaveLength(3);
|
||||
const edge = await unlink(r, rows[1]!.id, await issueWith(nowS - 599));
|
||||
expect(edge.statusCode).toBe(200);
|
||||
});
|
||||
|
||||
it("a step-up sign-in's bearer unlinks: 200 with the remaining list, an audit event without credentials", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"], ["discord", "d-9"]]);
|
||||
const audit = vi.spyOn(r.store, "createAuditEvent");
|
||||
const { accessToken } = await signIn(r, true);
|
||||
const res = await unlink(r, rows[1]!.id, accessToken, null);
|
||||
expect(res.statusCode).toBe(200);
|
||||
expect(res.headers["cache-control"]).toBe("no-store");
|
||||
expect(res.json().unlinked).toEqual({ id: rows[1]!.id, provider: "discord", providerUserId: "d-9" });
|
||||
expect(res.json().identities.map((i: { id: string }) => i.id)).toEqual([rows[0]!.id]);
|
||||
expect(res.body).not.toMatch(/CIPHERTEXT|PROFILE-CANARY|secret@example/);
|
||||
expect(await r.store.listStoredLinkedIdentitiesForAccount(account.id)).toHaveLength(1);
|
||||
const event = audit.mock.calls.map(([e]) => e).find((e) => e.eventType === "identity_unlinked");
|
||||
expect(event?.accountId).toBe(account.id);
|
||||
expect(event?.eventPayloadJson).toEqual({ provider: "discord", identityId: rows[1]!.id, stepUpMethod: "provider:twitch" });
|
||||
});
|
||||
|
||||
it("the account's only identity is 409 last_identity and the row stays", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"]]);
|
||||
const { accessToken } = await signIn(r, true);
|
||||
const res = await unlink(r, rows[0]!.id, accessToken);
|
||||
expect([res.statusCode, res.json().error]).toEqual([409, "last_identity"]);
|
||||
expect(await r.store.listStoredLinkedIdentitiesForAccount(account.id)).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("another account's identity and a nonexistent one are the same 404", async () => {
|
||||
const r = await rig();
|
||||
await seedAccount(r, [["twitch", "t-1"], ["discord", "d-9"]]);
|
||||
const other = await seedAccount(r, [["youtube", "y-other"], ["github", "g-other"]]);
|
||||
const { accessToken } = await signIn(r, true);
|
||||
const foreign = await unlink(r, other.rows[0]!.id, accessToken);
|
||||
const missing = await unlink(r, "no-such-id", accessToken);
|
||||
expect([foreign.statusCode, foreign.json().error]).toEqual([404, "identity_not_found"]);
|
||||
expect([missing.statusCode, missing.body]).toEqual([404, foreign.body]);
|
||||
expect(await r.store.listStoredLinkedIdentitiesForAccount(other.account.id)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("an unlinked identity belongs to no one, and another account can then link it, but not before", async () => {
|
||||
const r = await rig();
|
||||
const mine = await seedAccount(r, [["twitch", "t-1"], ["discord", "d-9"]]);
|
||||
const theirs = await seedAccount(r, [["youtube", "y-other"]]);
|
||||
const input = { accountId: theirs.account.id, provider: "discord" as const, providerUserId: "d-9", scopes: [], profileJson: {}, createdAt: now, updatedAt: now };
|
||||
await expect(r.store.upsertLinkedIdentity(input)).rejects.toBeInstanceOf(IdentityHeldElsewhereError);
|
||||
const { accessToken } = await signIn(r, true);
|
||||
expect((await unlink(r, mine.rows[1]!.id, accessToken)).statusCode).toBe(200);
|
||||
await expect(r.store.upsertLinkedIdentity(input)).resolves.toMatchObject({ accountId: theirs.account.id });
|
||||
});
|
||||
|
||||
it("writes revocation receipts for the provider's live grants when its last identity goes, and not before", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"], ["youtube", "y-1"], ["youtube", "y-2"]]);
|
||||
const grant = async (provider: Provider) =>
|
||||
(await r.store.createConsentReceipt({ kind: "grant", accountId: account.id, appSlug: "streampixels", provider, createdAt: now, scopesAsked: ["a"], scopesGranted: ["a"], consentPageDigest: "d", consentText: "t" })).receipt;
|
||||
const ytGrant = await grant("youtube");
|
||||
const twGrant = await grant("twitch");
|
||||
const { accessToken } = await signIn(r, true);
|
||||
|
||||
// A second youtube identity remains: the grant's provider still holds a credential.
|
||||
expect((await unlink(r, rows[1]!.id, accessToken)).statusCode).toBe(200);
|
||||
expect((await r.store.listConsentReceipts(account.id)).filter((x) => x.kind === "revocation")).toHaveLength(0);
|
||||
|
||||
// The last youtube identity goes (twitch stays as the sign-in identity): youtube's grant is revoked, twitch's is not.
|
||||
const audit = vi.spyOn(r.store, "createAuditEvent");
|
||||
expect((await unlink(r, rows[2]!.id, accessToken)).statusCode).toBe(200);
|
||||
const revocations = (await r.store.listConsentReceipts(account.id)).filter((x) => x.kind === "revocation");
|
||||
expect(revocations.map((x) => x.kind === "revocation" && x.revokesReceiptId)).toEqual([ytGrant.id]);
|
||||
expect(revocations.map((x) => x.provider)).toEqual(["youtube"]);
|
||||
expect(twGrant.id).not.toBe(ytGrant.id);
|
||||
expect(audit.mock.calls.map(([e]) => e.eventType)).toEqual(expect.arrayContaining(["identity_unlinked", "consent_revoked"]));
|
||||
});
|
||||
|
||||
it("proof past the window refuses even a bearer that was fresh when issued", async () => {
|
||||
const r = await rig();
|
||||
const { rows } = await seedAccount(r, [["twitch", "t-1"], ["discord", "d-9"]]);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
const { accessToken } = await signIn(r, true);
|
||||
vi.setSystemTime(Date.now() + 601_000);
|
||||
const res = await unlink(r, rows[1]!.id, accessToken);
|
||||
expect([res.statusCode, res.json().error]).toEqual([403, "step_up_required"]);
|
||||
});
|
||||
|
||||
it("the proof window's edge: exactly 600 s old still passes, 601 s does not (frozen clock)", async () => {
|
||||
const r = await rig();
|
||||
const { account, rows } = await seedAccount(r, [["twitch", "t-1"], ["youtube", "y-1"], ["discord", "d-1"]]);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
vi.setSystemTime(new Date("2026-11-13T12:00:00.000Z"));
|
||||
const nowS = Math.floor(Date.now() / 1000);
|
||||
const issueWith = async (stepUpAt: number) =>
|
||||
(await issueAccessClaim({ config, keys: r.keys, store: r.store, input: { appSlug: "streampixels", accountId: account.id, linkedIdentities: [], facts: [], stepUpAt } })).accessToken;
|
||||
const tooOld = await unlink(r, rows[1]!.id, await issueWith(nowS - 601));
|
||||
expect([tooOld.statusCode, tooOld.json().error]).toEqual([403, "step_up_required"]);
|
||||
const edge = await unlink(r, rows[1]!.id, await issueWith(nowS - 600));
|
||||
expect(edge.statusCode).toBe(200);
|
||||
});
|
||||
|
||||
it("a one-identity bearer naming another account's identity gets 404, not 409", async () => {
|
||||
const r = await rig();
|
||||
await seedAccount(r, [["twitch", "t-1"]]);
|
||||
const other = await seedAccount(r, [["youtube", "y-other"], ["github", "g-other"]]);
|
||||
const { accessToken } = await signIn(r, true);
|
||||
const res = await unlink(r, other.rows[0]!.id, accessToken);
|
||||
expect([res.statusCode, res.json().error]).toEqual([404, "identity_not_found"]);
|
||||
});
|
||||
|
||||
it("a step_up state in a non-sign_in mode (forged, signed) yields no step_up_at", async () => {
|
||||
const r = await rig();
|
||||
const { account } = await seedAccount(r, [["twitch", "t-1"]]);
|
||||
const started = await r.app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/twitch/start",
|
||||
headers: spAuth,
|
||||
payload: { appSlug: "streampixels", mode: "link", initiatingAccountId: account.id, returnTo },
|
||||
});
|
||||
expect(started.statusCode).toBe(201);
|
||||
const verified = verifyJwt(stateOf(started.json()), r.keys.publicKey) as { valid: boolean; payload: Record<string, unknown> };
|
||||
expect(verified.valid).toBe(true);
|
||||
expect(verified.payload.mode).toBe("link");
|
||||
const flow = await launchState(r.app, signJwt({ ...verified.payload, step_up: true }, r.keys));
|
||||
const called = await r.app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/twitch/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie, accept: "application/json" },
|
||||
});
|
||||
expect(called.statusCode).toBe(201);
|
||||
expect(called.json().stepUpRequested, "the forged flag was read").toBe(true);
|
||||
const token = called.json().accessToken as string;
|
||||
expect(token, "the link completion minted an access token to inspect").toBeTruthy();
|
||||
expect(decodeJwt(token).payload.step_up_at).toBeUndefined();
|
||||
});
|
||||
});
|
||||
320
tests/idunn-boot.test.ts
Normal file
320
tests/idunn-boot.test.ts
Normal file
|
|
@ -0,0 +1,320 @@
|
|||
import { execFile, spawn, type ChildProcess } from "node:child_process";
|
||||
import { createPublicKey, createPrivateKey, verify } from "node:crypto";
|
||||
import dgram from "node:dgram";
|
||||
import { chmod, copyFile, mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
|
||||
import { closeSync, openSync } from "node:fs";
|
||||
import net from "node:net";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
import { promisify } from "node:util";
|
||||
|
||||
import { decode, encode } from "@msgpack/msgpack";
|
||||
import {
|
||||
RUNTIME_PRESENCE_SLOT,
|
||||
parseCultNetMessage,
|
||||
runtimePresenceActivationSigningMessage,
|
||||
runtimePresenceProviderSigningMessage,
|
||||
} from "cultnet-ts";
|
||||
import { afterAll, beforeAll, describe, expect, it } from "vitest";
|
||||
|
||||
import { startFakeIdunnRudp, type FakeIdunnRudp } from "./fixtures/fake-idunn-rudp.js";
|
||||
import { idunnRuntimeFixtures } from "./fixtures/presence-descriptors.js";
|
||||
|
||||
const run = promisify(execFile);
|
||||
|
||||
const GENERATION_UID = 61184;
|
||||
const STATE_GID = 4242;
|
||||
const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
|
||||
const PKCS8_ED25519_SEED_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
|
||||
|
||||
// The launch needs root (to pick the uid and bind a machine-id) and a mount
|
||||
// namespace (so the fixture machine-id does not replace the host's). The
|
||||
// stopgap's node container has both; anywhere else the test steps aside.
|
||||
const canLaunch =
|
||||
process.getuid?.() === 0 &&
|
||||
(await run("unshare", ["--mount", "--", "true"]).then(
|
||||
() => true,
|
||||
() => false
|
||||
));
|
||||
|
||||
/**
|
||||
* The artifact under test. By default the esbuild bundle `pnpm bundle` makes,
|
||||
* run by this process's node; a runbook proves a sealed release by naming its
|
||||
* bundle and node here instead.
|
||||
*/
|
||||
const bundleOverride = process.env.HEIMDALL_BOOT_BUNDLE;
|
||||
const nodeOverride = process.env.HEIMDALL_BOOT_NODE;
|
||||
|
||||
async function freePort(): Promise<number> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const probe = net.createServer();
|
||||
probe.once("error", reject);
|
||||
probe.listen(0, "127.0.0.1", () => {
|
||||
const { port } = probe.address() as net.AddressInfo;
|
||||
probe.close(() => resolve(port));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
interface Launch {
|
||||
child: ChildProcess;
|
||||
stderr: () => string;
|
||||
exited: Promise<number | null>;
|
||||
candidatePort: number;
|
||||
}
|
||||
|
||||
describe.skipIf(!canLaunch)("the bundle booted as Idunn launches it", () => {
|
||||
let base: string;
|
||||
let bundle: string;
|
||||
let node: string;
|
||||
let idunn: FakeIdunnRudp;
|
||||
let odin: dgram.Socket;
|
||||
let odinPort: number;
|
||||
const launched: ChildProcess[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
base = await mkdtemp(path.join(os.tmpdir(), "heimdall-boot-"));
|
||||
await chmod(base, 0o755);
|
||||
if (bundleOverride) {
|
||||
bundle = bundleOverride;
|
||||
} else {
|
||||
await run("corepack", ["pnpm", "bundle"], { cwd: path.join(import.meta.dirname, "..") });
|
||||
bundle = path.join(base, "heimdall.mjs");
|
||||
await copyFile(path.join(import.meta.dirname, "..", "dist", "heimdall"), bundle);
|
||||
await chmod(bundle, 0o644);
|
||||
}
|
||||
node = nodeOverride ?? process.execPath;
|
||||
idunn = await startFakeIdunnRudp();
|
||||
odin = dgram.createSocket("udp4");
|
||||
await new Promise<void>((resolve) => odin.bind(0, "127.0.0.1", resolve));
|
||||
odinPort = odin.address().port;
|
||||
}, 120_000);
|
||||
|
||||
afterAll(() => {
|
||||
for (const child of launched) child.kill("SIGKILL");
|
||||
idunn?.close();
|
||||
odin?.close();
|
||||
});
|
||||
|
||||
/** Credential files as Idunn holds them: readable only by the parent. */
|
||||
async function credentials(dir: string, identity: Buffer | undefined) {
|
||||
await mkdir(dir, { recursive: true });
|
||||
const seed = path.join(dir, "activation-key.seed");
|
||||
await copyFile(path.join(idunnRuntimeFixtures, "activation-key.seed"), seed);
|
||||
await chmod(seed, 0o400);
|
||||
let identityFile: string | undefined;
|
||||
if (identity) {
|
||||
identityFile = path.join(dir, "provider-identity.credential");
|
||||
await writeFile(identityFile, identity, { mode: 0o400 });
|
||||
}
|
||||
return { seed, identityFile };
|
||||
}
|
||||
|
||||
/** Start the bundle as the generation unit does, with the fixture machine-id bound over the host's. */
|
||||
async function launch(label: string, identity: Buffer | undefined): Promise<Launch> {
|
||||
const dir = path.join(base, label);
|
||||
await mkdir(dir, { recursive: true });
|
||||
await chmod(dir, 0o755);
|
||||
|
||||
// Idunn's runtime bundle: the two records, read-only.
|
||||
const bundleDir = path.join(dir, "bundle");
|
||||
await mkdir(bundleDir);
|
||||
for (const name of ["expected.cc", "activation.cc"]) {
|
||||
await copyFile(path.join(idunnRuntimeFixtures, name), path.join(bundleDir, name));
|
||||
await chmod(path.join(bundleDir, name), 0o444);
|
||||
}
|
||||
await chmod(bundleDir, 0o555);
|
||||
|
||||
const machineId = path.join(dir, "machine-id");
|
||||
await copyFile(path.join(idunnRuntimeFixtures, "machine-id"), machineId);
|
||||
await chmod(machineId, 0o444);
|
||||
|
||||
const stateRoot = path.join(dir, "state");
|
||||
await mkdir(stateRoot);
|
||||
await run("chown", [`0:${STATE_GID}`, stateRoot]);
|
||||
await chmod(stateRoot, 0o2770);
|
||||
|
||||
const heimdall = path.join(dir, "heimdall.mjs");
|
||||
await copyFile(bundle, heimdall);
|
||||
await chmod(heimdall, 0o444);
|
||||
|
||||
const files = await credentials(path.join(dir, "credentials"), identity);
|
||||
const candidatePort = await freePort();
|
||||
|
||||
const fds = [openSync(files.seed, "r")];
|
||||
const names = ["gamecult-idunn-runtime-activation-key"];
|
||||
if (files.identityFile) {
|
||||
fds.push(openSync(files.identityFile, "r"));
|
||||
names.push("gamecult-runtime-presence-identity");
|
||||
}
|
||||
|
||||
const env = {
|
||||
PATH: process.env.PATH ?? "",
|
||||
LISTEN_FDS: String(fds.length),
|
||||
LISTEN_FDNAMES: names.join(":"),
|
||||
GAMECULT_IDUNN_CANDIDATE_BIND: `127.0.0.1:${candidatePort}`,
|
||||
GAMECULT_IDUNN_RUNTIME_BUNDLE: bundleDir,
|
||||
GAMECULT_IDUNN_PROCESS_WRITE_LEASE: path.join(dir, "process-write-lease.cc"),
|
||||
GC_ACCESS_BASE_URL: "https://heimdall.test",
|
||||
GC_ACCESS_ISSUER: "https://heimdall.test",
|
||||
GC_ACCESS_STORAGE_BACKEND: "memory",
|
||||
GC_ACCESS_IDUNN_RUDP_HEALTH: `127.0.0.1:${idunn.port}`,
|
||||
GC_ACCESS_IDUNN_HEALTH_CONTRACT: "heimdall.cultnet-rudp-provider-health",
|
||||
GC_ACCESS_ODIN_CULTMESH_URI: `rudp://127.0.0.1:${odinPort}`,
|
||||
CULTMESH_URI_ODIN_RUDP: `rudp://127.0.0.1:${odinPort}`,
|
||||
GC_ACCESS_SIGNING_PRIVATE_KEY_BOOTSTRAP: "1",
|
||||
GC_ACCESS_SIGNING_PRIVATE_KEY_PATH: path.join(stateRoot, "signing.pem"),
|
||||
GC_ACCESS_SIGNING_KEY_ID: "boot-test",
|
||||
};
|
||||
|
||||
// uid, gid and umask as Idunn's DynamicUser unit gives them. The fixture
|
||||
// machine-id is bound only inside this mount namespace.
|
||||
const script =
|
||||
`mount --bind ${machineId} /etc/machine-id && ` +
|
||||
`exec setpriv --reuid ${GENERATION_UID} --regid ${STATE_GID} --clear-groups ` +
|
||||
`sh -c 'umask 0007; cd ${dir}; exec ${node} heimdall.mjs --state-root ${stateRoot}'`;
|
||||
const child = spawn("unshare", ["--mount", "--", "sh", "-c", script], {
|
||||
env,
|
||||
stdio: ["ignore", "ignore", "pipe", ...fds],
|
||||
});
|
||||
launched.push(child);
|
||||
fds.forEach((fd) => closeSync(fd));
|
||||
|
||||
let stderr = "";
|
||||
child.stderr!.on("data", (chunk: Buffer) => {
|
||||
stderr += chunk.toString();
|
||||
});
|
||||
const exited = new Promise<number | null>((resolve) => child.once("exit", (code) => resolve(code)));
|
||||
return { child, stderr: () => stderr, exited, candidatePort };
|
||||
}
|
||||
|
||||
async function answers(port: number): Promise<number | undefined> {
|
||||
return fetch(`http://127.0.0.1:${port}/.well-known/jwks.json`).then(
|
||||
(response) => response.status,
|
||||
() => undefined
|
||||
);
|
||||
}
|
||||
|
||||
it("signs warming presence on every pulse and answers HTTP", async () => {
|
||||
const credential = await readFile(path.join(idunnRuntimeFixtures, "provider-identity.credential"));
|
||||
const generation = await launch("signs", credential);
|
||||
|
||||
// Startup publication, then one per 10 s pulse. A publication fault is
|
||||
// reported as it is logged rather than after the frames never arrive.
|
||||
const publicationFault = new Promise<never>((_resolve, reject) => {
|
||||
const watch = setInterval(() => {
|
||||
if (generation.stderr().includes(" failed on ")) {
|
||||
clearInterval(watch);
|
||||
reject(new Error(`publication failed; stderr: ${generation.stderr()}`));
|
||||
}
|
||||
}, 200);
|
||||
void idunn.frame(2).then(() => clearInterval(watch));
|
||||
});
|
||||
const exitedEarly = generation.exited.then((code) => {
|
||||
throw new Error(`bundle exited ${code}; stderr: ${generation.stderr()}`);
|
||||
});
|
||||
// The first statement is the startup publication, which follows the listen
|
||||
// directly; the 10 s pulse loop has not yet fired.
|
||||
await Promise.race([
|
||||
idunn.frame(0),
|
||||
publicationFault,
|
||||
exitedEarly,
|
||||
new Promise<never>((_resolve, reject) =>
|
||||
setTimeout(() => reject(new Error(`no presence at startup; stderr: ${generation.stderr()}`)), 8_000)
|
||||
),
|
||||
]);
|
||||
await Promise.race([idunn.frame(2), publicationFault, exitedEarly]);
|
||||
|
||||
expect(await answers(generation.candidatePort)).toBe(200);
|
||||
|
||||
// Public keys of the two proofs, from the fixtures' test keys.
|
||||
const store = decode(credential) as unknown[][];
|
||||
const record = decode(store[0]![2] as Uint8Array) as unknown[];
|
||||
const providerKey = createPublicKey({
|
||||
key: Buffer.concat([ED25519_SPKI_PREFIX, Buffer.from(record[2] as number[])]),
|
||||
format: "der",
|
||||
type: "spki",
|
||||
});
|
||||
const activationKey = createPublicKey(
|
||||
createPrivateKey({
|
||||
key: Buffer.concat([
|
||||
PKCS8_ED25519_SEED_PREFIX,
|
||||
await readFile(path.join(idunnRuntimeFixtures, "activation-key.seed")),
|
||||
]),
|
||||
format: "der",
|
||||
type: "pkcs8",
|
||||
})
|
||||
);
|
||||
|
||||
let previousSequence = 0;
|
||||
for (const frame of idunn.frames.slice(0, 3)) {
|
||||
const message = parseCultNetMessage(decode(frame.payload), "cultnet.schema.v0");
|
||||
if (message.schemaVersion !== "cultnet.document_put_raw.v0") throw new Error("not a raw document put");
|
||||
const fields = decode(message.document.payload) as unknown[];
|
||||
expect(fields[RUNTIME_PRESENCE_SLOT.state]).toBe("warming");
|
||||
|
||||
const unsigned = [...fields];
|
||||
unsigned[RUNTIME_PRESENCE_SLOT.signature] = new Uint8Array();
|
||||
unsigned[RUNTIME_PRESENCE_SLOT.activationSignature] = new Uint8Array();
|
||||
const proof = encode(unsigned);
|
||||
expect(
|
||||
verify(
|
||||
null,
|
||||
runtimePresenceProviderSigningMessage(proof),
|
||||
providerKey,
|
||||
fields[RUNTIME_PRESENCE_SLOT.signature] as Uint8Array
|
||||
)
|
||||
).toBe(true);
|
||||
expect(
|
||||
verify(
|
||||
null,
|
||||
runtimePresenceActivationSigningMessage(proof),
|
||||
activationKey,
|
||||
fields[RUNTIME_PRESENCE_SLOT.activationSignature] as Uint8Array
|
||||
)
|
||||
).toBe(true);
|
||||
|
||||
const sequence = fields[RUNTIME_PRESENCE_SLOT.publisherSequence] as number;
|
||||
expect(sequence).toBeGreaterThan(previousSequence);
|
||||
previousSequence = sequence;
|
||||
}
|
||||
|
||||
expect(generation.stderr()).not.toContain("failed on startup");
|
||||
expect(generation.stderr()).not.toContain("failed on interval");
|
||||
generation.child.kill("SIGKILL");
|
||||
}, 90_000);
|
||||
|
||||
it.each([
|
||||
["the identity descriptor is not passed", undefined, "gamecult-runtime-presence-identity"],
|
||||
["the identity is damaged", "damaged", "identity id check"],
|
||||
])("exits before listening when %s", async (_name, damage, expected) => {
|
||||
const credential = await readFile(path.join(idunnRuntimeFixtures, "provider-identity.credential"));
|
||||
const store = decode(credential) as unknown[][];
|
||||
const record = decode(store[0]![2] as Uint8Array) as unknown[];
|
||||
const publicKey = [...(record[2] as number[])];
|
||||
const original = { publicKeyHex: Buffer.from(publicKey).toString("hex"), id: record[1] as string, binding: record[5] as string };
|
||||
let identity: Buffer | undefined;
|
||||
if (damage) {
|
||||
publicKey[0] = publicKey[0]! ^ 1;
|
||||
record[2] = publicKey;
|
||||
identity = Buffer.from(encode([[store[0]![0], store[0]![1], encode(record), store[0]![3], store[0]![4]]]));
|
||||
}
|
||||
const started = Date.now();
|
||||
const generation = await launch(damage ? "damaged" : "no-identity", identity);
|
||||
|
||||
const code = await Promise.race([
|
||||
generation.exited,
|
||||
new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 5_000)),
|
||||
]);
|
||||
|
||||
expect(code, generation.stderr()).not.toBe("timeout");
|
||||
expect(code).not.toBe(0);
|
||||
expect(Date.now() - started).toBeLessThan(6_000);
|
||||
expect(await answers(generation.candidatePort)).toBeUndefined();
|
||||
expect(generation.stderr()).toContain(expected);
|
||||
// No byte of the credential: not the key bytes, not the id, not the binding.
|
||||
expect(generation.stderr()).not.toContain(original.publicKeyHex);
|
||||
expect(generation.stderr()).not.toContain(original.id.slice(0, 16));
|
||||
expect(generation.stderr()).not.toContain(original.binding.slice(-16));
|
||||
}, 30_000);
|
||||
});
|
||||
|
|
@ -1,18 +1,12 @@
|
|||
import dgram from "node:dgram";
|
||||
import { mkdtemp } from "node:fs/promises";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
import { decode } from "@msgpack/msgpack";
|
||||
import {
|
||||
CultNetRudpSession,
|
||||
decodeRudpPacket,
|
||||
encodeRudpPacket,
|
||||
parseCultNetMessage,
|
||||
type CultNetTransportFrame,
|
||||
} from "cultnet-ts";
|
||||
import { parseCultNetMessage } from "cultnet-ts";
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import { loadConfig } from "../src/config.js";
|
||||
import { publishIdunnRudpHealth } from "../src/idunn-rudp-health.js";
|
||||
import { startFakeIdunnRudp } from "./fixtures/fake-idunn-rudp.js";
|
||||
|
||||
vi.mock("node:fs/promises", async (importOriginal) => {
|
||||
const original = await importOriginal<typeof import("node:fs/promises")>();
|
||||
|
|
@ -27,37 +21,12 @@ vi.mock("node:fs/promises", async (importOriginal) => {
|
|||
|
||||
describe("Heimdall Idunn health publication", () => {
|
||||
it("completes the canonical RUDP handshake before publishing its signed frame", async () => {
|
||||
const server = dgram.createSocket("udp4");
|
||||
const session = new CultNetRudpSession({
|
||||
connectionId: 0x1d0d0001,
|
||||
initialSequence: 1,
|
||||
resendDelayMs: 100,
|
||||
});
|
||||
let resolveFrame!: (frame: CultNetTransportFrame) => void;
|
||||
const frameReceived = new Promise<CultNetTransportFrame>((resolve) => {
|
||||
resolveFrame = resolve;
|
||||
});
|
||||
|
||||
server.on("message", (wire, remote) => {
|
||||
const packet = decodeRudpPacket(wire);
|
||||
if (packet.packetType === "connect") {
|
||||
server.send(encodeRudpPacket(session.acceptConnect(packet, Date.now())), remote.port, remote.address);
|
||||
return;
|
||||
}
|
||||
const result = session.receive(packet, Date.now());
|
||||
if (result.reply) server.send(encodeRudpPacket(result.reply), remote.port, remote.address);
|
||||
for (const frame of result.delivered) resolveFrame(frame);
|
||||
if (result.delivered.length > 0) {
|
||||
server.send(encodeRudpPacket(session.createAck()), remote.port, remote.address);
|
||||
}
|
||||
});
|
||||
await new Promise<void>((resolve) => server.bind(0, "127.0.0.1", resolve));
|
||||
const server = await startFakeIdunnRudp();
|
||||
|
||||
try {
|
||||
const tmp = await mkdtemp(path.join(os.tmpdir(), "heimdall-idunn-rudp-"));
|
||||
const address = server.address();
|
||||
const config = loadConfig({
|
||||
GC_ACCESS_IDUNN_RUDP_HEALTH: `127.0.0.1:${address.port}`,
|
||||
GC_ACCESS_IDUNN_RUDP_HEALTH: `127.0.0.1:${server.port}`,
|
||||
GC_ACCESS_PROVIDER_HEALTH_IDENTITY_PATH: path.join(tmp, "provider-health-identity.cc"),
|
||||
});
|
||||
const observedAt = "2026-08-22T00:45:00.000Z";
|
||||
|
|
@ -78,7 +47,7 @@ describe("Heimdall Idunn health publication", () => {
|
|||
observedAt,
|
||||
presence,
|
||||
});
|
||||
const frame = await frameReceived;
|
||||
const frame = await server.frame(0);
|
||||
const message = parseCultNetMessage(decode(frame.payload), "cultnet.schema.v0");
|
||||
|
||||
expect(frame.channelId).toBe("schema");
|
||||
|
|
|
|||
686
tests/joystick-consent.test.ts
Normal file
686
tests/joystick-consent.test.ts
Normal file
|
|
@ -0,0 +1,686 @@
|
|||
import { createHash, randomBytes } from "node:crypto";
|
||||
import { deflateRawSync } from "node:zlib";
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { type FastifyInstance } from "fastify";
|
||||
import { buildApp, getHeimdallRuntimeContext, startOAuthFlow } from "../src/app.js";
|
||||
import { resolveAppCaller } from "../src/app-caller.js";
|
||||
import { consentDigest, consentText, digestOfText, type ConsentAsk } from "../src/consent.js";
|
||||
import { decodeJwt, signJwt } from "../src/signing.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { providerCatalog } from "../src/providers.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { createTestConfig, setCookieOf, stateOf } from "./oauth-flow.js";
|
||||
|
||||
// Records the options of every inflate the app runs, so the bomb test can pin the output cap
|
||||
// itself instead of timing a refusal. Behaviour is the real inflate.
|
||||
const inflateCalls = vi.hoisted(() => [] as Array<{ maxOutputLength: number | undefined }>);
|
||||
vi.mock("node:zlib", async (importOriginal) => {
|
||||
const real = await importOriginal<typeof import("node:zlib")>();
|
||||
return {
|
||||
...real,
|
||||
inflateRawSync: ((buf: Parameters<typeof real.inflateRawSync>[0], opts?: Parameters<typeof real.inflateRawSync>[1]) => {
|
||||
inflateCalls.push({ maxOutputLength: opts?.maxOutputLength });
|
||||
return real.inflateRawSync(buf, opts);
|
||||
}) as typeof real.inflateRawSync,
|
||||
};
|
||||
});
|
||||
|
||||
// The consent cut for managed custody (docs/joystick-consent-flow.md): the ask,
|
||||
// the typed refusal, the receipt, and the signed-in page that lists and revokes.
|
||||
|
||||
const apps: FastifyInstance[] = [];
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
vi.restoreAllMocks();
|
||||
while (apps.length) await apps.pop()?.close();
|
||||
});
|
||||
|
||||
const defaultScopes = providerCatalog.joystick.defaultScopes;
|
||||
const secret = { "x-heimdall-app-secret": "streampixels-secret" };
|
||||
const form = { "content-type": "application/x-www-form-urlencoded" };
|
||||
|
||||
/** A Joystick that returns whatever `code-<user>` names, granting only `granted`. */
|
||||
function joystick(granted: string[] = ["identity:read", "stream:read"]): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode({ code }) {
|
||||
return { accessToken: `joy-access-${code}`, refreshToken: `joy-refresh-${code}`, tokenType: "Bearer", scope: granted, expiresAt: "2099-01-01T00:00:00.000Z", raw: {} };
|
||||
},
|
||||
async resolveIdentity({ accessToken }) {
|
||||
const id = accessToken.replace("joy-access-code-", "");
|
||||
return { provider: "joystick", providerUserId: `joy-${id}`, username: id, profile: { id } };
|
||||
},
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
async function newApp(options: { granted?: string[]; callbacks?: string[] } = {}) {
|
||||
const store = new InMemoryStore();
|
||||
const config = createTestConfig();
|
||||
if (options.callbacks) config.appBackendCallbacks = { streampixels: options.callbacks };
|
||||
const app = await buildApp({ config, store, oauthRuntimes: { joystick: joystick(options.granted) } });
|
||||
apps.push(app);
|
||||
return { app, store };
|
||||
}
|
||||
|
||||
async function startConnect(app: FastifyInstance, handoff: Record<string, unknown> = { kind: "browser_completion" }) {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/start",
|
||||
headers: secret,
|
||||
payload: {
|
||||
appSlug: "streampixels",
|
||||
mode: "connect",
|
||||
connection: { kind: "creator", targetId: "creator-1" },
|
||||
returnTo: "https://streampixels.gamecult.org/settings",
|
||||
handoff,
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(201);
|
||||
return stateOf(response.json());
|
||||
}
|
||||
|
||||
const launchUrl = (state: string) => `/v1/oauth/joystick/launch?state=${encodeURIComponent(state)}`;
|
||||
const cookieNamed = (prefix: string) => (response: { headers: Record<string, unknown> }) =>
|
||||
setCookieOf(response).find((value) => value.startsWith(prefix))?.split(";")[0];
|
||||
const askCookieOf = cookieNamed("__Host-heimdall-ask-");
|
||||
const bindingCookieOf = cookieNamed("__Host-heimdall-oauth-");
|
||||
|
||||
/** The browser is shown the ask. The cookie it keeps is the ask's, which binds nothing. */
|
||||
async function seeAsk(app: FastifyInstance, state: string) {
|
||||
const response = await app.inject({ method: "GET", url: launchUrl(state), headers: { accept: "text/html" } });
|
||||
expect(response.statusCode).toBe(200);
|
||||
expect(bindingCookieOf(response), "the ask must not set the launch binding").toBeUndefined();
|
||||
return { page: response, cookie: askCookieOf(response)! };
|
||||
}
|
||||
|
||||
function answer(app: FastifyInstance, state: string, decision: "continue" | "decline", cookie?: string, accept = "text/html") {
|
||||
return app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/consent",
|
||||
headers: { ...form, accept, ...(cookie ? { cookie } : {}) },
|
||||
payload: new URLSearchParams({ state, decision }).toString(),
|
||||
});
|
||||
}
|
||||
|
||||
function callback(app: FastifyInstance, state: string, cookie: string, query: string, accept = "application/json") {
|
||||
return app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?state=${encodeURIComponent(state)}&${query}`,
|
||||
headers: { cookie, accept },
|
||||
});
|
||||
}
|
||||
|
||||
/** Ask, accept, and complete as Joystick user `user`; returns the callback's JSON. */
|
||||
async function grantAs(app: FastifyInstance, user: string) {
|
||||
const state = await startConnect(app);
|
||||
const asked = await seeAsk(app, state);
|
||||
const go = await answer(app, state, "continue", asked.cookie);
|
||||
expect(go.statusCode).toBe(302);
|
||||
const done = await callback(app, state, bindingCookieOf(go)!, `code=code-${user}`);
|
||||
expect(done.statusCode).toBe(201);
|
||||
return done.json() as { accessToken: string; consentReceiptId: string; account: { id: string }; session: { accountId: string } };
|
||||
}
|
||||
|
||||
const bearer = (token: string) => ({ authorization: `Bearer ${token}` });
|
||||
const grantsOf = async (app: FastifyInstance, token: string) =>
|
||||
(await app.inject({ method: "GET", url: "/v1/me/grants", headers: bearer(token) })).json() as { grants: Array<Record<string, any>>; receipts: Array<Record<string, any>> };
|
||||
const resolveCredential = (app: FastifyInstance, accountId: string) =>
|
||||
app.inject({ method: "POST", url: "/v1/apps/streampixels/managed-credentials/resolve", headers: secret, payload: { accountId, provider: "joystick" } });
|
||||
|
||||
describe("the ask", () => {
|
||||
it("launch shows a Heimdall page naming app, provider, scopes and custody, and does not redirect", async () => {
|
||||
const { app } = await newApp();
|
||||
const { page } = await seeAsk(app, await startConnect(app));
|
||||
expect(page.headers.location).toBeUndefined();
|
||||
for (const needle of ["StreamPixels", "Joystick", ...defaultScopes, "refresh token", "streampixels.gamecult.org", "Continue to Joystick", "No, return to the app"]) {
|
||||
expect(page.body).toContain(needle);
|
||||
}
|
||||
expect(page.body).not.toContain("<script");
|
||||
expect(page.headers["content-security-policy"]).toContain("form-action 'self' https://joystick.tv");
|
||||
});
|
||||
|
||||
it("viewing the ask claims nothing: the launch is still spendable once after any number of views", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
await seeAsk(app, state);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
expect((await answer(app, state, "continue", cookie)).statusCode).toBe(302);
|
||||
const again = await answer(app, state, "continue", cookie, "application/json");
|
||||
expect(again.statusCode).toBe(400);
|
||||
expect(again.json()).toEqual({ error: "state_already_launched" });
|
||||
});
|
||||
|
||||
it("Continue sends exactly the scopes the page listed", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
const go = await answer(app, state, "continue", cookie);
|
||||
expect(go.statusCode).toBe(302);
|
||||
const target = new URL(go.headers.location as string);
|
||||
expect(target.origin).toBe("https://joystick.tv");
|
||||
expect(target.searchParams.get("scope")).toBe(defaultScopes.join(" "));
|
||||
});
|
||||
|
||||
it("a flow with no custody (sign-in through an identity provider) gets no ask and redirects as before", async () => {
|
||||
const { app } = await newApp();
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/twitch/start",
|
||||
headers: secret,
|
||||
payload: { appSlug: "streampixels", mode: "sign_in", returnTo: "https://streampixels.gamecult.org/", handoff: { kind: "browser_completion" } },
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const launch = await app.inject({ method: "GET", url: `/v1/oauth/twitch/launch?state=${encodeURIComponent(stateOf(start.json()))}`, headers: { accept: "text/html" } });
|
||||
expect(launch.statusCode).toBe(302);
|
||||
});
|
||||
|
||||
it("an answer without the cookie the ask set is refused and spends nothing", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
for (const decision of ["continue", "decline"] as const) {
|
||||
const stranger = await answer(app, state, decision, undefined, "application/json");
|
||||
expect(stranger.statusCode, decision).toBe(400);
|
||||
expect(stranger.json(), decision).toEqual({ error: "state_not_bound" });
|
||||
}
|
||||
expect((await answer(app, state, "continue", cookie)).statusCode).toBe(302);
|
||||
});
|
||||
|
||||
it("a stranger who only opens the launch URL is not bound to the state and cannot complete it", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const victim = await seeAsk(app, state);
|
||||
await answer(app, state, "continue", victim.cookie);
|
||||
// A fresh browser that holds the URL loads the ask and calls back with its own provider code.
|
||||
const stranger = await seeAsk(app, state);
|
||||
for (const cookie of [stranger.cookie, ""]) {
|
||||
const done = await callback(app, state, cookie, "code=code-attacker");
|
||||
expect(done.statusCode).toBe(400);
|
||||
expect(done.json()).toEqual({ error: "state_not_bound" });
|
||||
}
|
||||
});
|
||||
|
||||
it("only Continue sets the launch binding, and the ask's cookie is no binding: it cannot complete a callback", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const asked = await seeAsk(app, state);
|
||||
const done = await callback(app, state, asked.cookie, "code=code-a");
|
||||
expect(done.json()).toEqual({ error: "state_not_bound" });
|
||||
const go = await answer(app, state, "continue", asked.cookie);
|
||||
expect(bindingCookieOf(go)).toBeDefined();
|
||||
expect(bindingCookieOf(go)!.length).toBeLessThan(3500);
|
||||
});
|
||||
|
||||
it("a binding without the shown wording is refused with consent_text_missing before the state is spent", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const state = await startConnect(app);
|
||||
const { jti, exp } = decodeJwt(state).payload as { jti: string; exp: number };
|
||||
// A binding that names this state but carries no wording: what a launch from before the ask would leave.
|
||||
const bare = signJwt({ typ: "heimdall_oauth_binding", iss: ctx.config.issuer, jti, iat: exp - 600, exp }, ctx.keys);
|
||||
const done = await callback(app, state, `__Host-heimdall-oauth-${jti}=${bare}`, "code=code-a");
|
||||
expect(done.statusCode).toBe(400);
|
||||
expect(done.json()).toEqual({ error: "consent_text_missing" });
|
||||
expect(await store.findStoredLinkedIdentity("joystick", "joy-a"), "no credential is kept").toBeNull();
|
||||
// Neither use of the state was spent by the refusal.
|
||||
const usedAt = new Date().toISOString();
|
||||
const expiresAt = new Date(exp * 1000).toISOString();
|
||||
expect(await store.claimOAuthStateUse({ jti, phase: "callback", appSlug: "streampixels", usedAt, expiresAt })).toBe(true);
|
||||
});
|
||||
|
||||
describe("the wording a cookie may carry", () => {
|
||||
const signedAsk = (ctx: ReturnType<typeof getHeimdallRuntimeContext>, jti: string, exp: number, text: Buffer) =>
|
||||
signJwt({ typ: "heimdall_consent_ask", iss: ctx.config.issuer, jti, iat: exp - 600, exp, ct: deflateRawSync(text).toString("base64url") }, ctx.keys);
|
||||
|
||||
it("is read up to 16 KB and no further: one byte over is refused, and a bomb is inflated under that cap", async () => {
|
||||
const { app } = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const state = await startConnect(app);
|
||||
const { jti, exp } = decodeJwt(state).payload as { jti: string; exp: number };
|
||||
const answerWith = (text: Buffer, decision: "decline" | "continue" = "decline") =>
|
||||
answer(app, state, decision, `__Host-heimdall-ask-${jti}=${signedAsk(ctx, jti, exp, text)}`, "application/json");
|
||||
expect((await answerWith(Buffer.alloc(16 * 1024 + 1, 97))).json()).toEqual({ error: "state_not_bound" });
|
||||
// A bomb: far past the cap once inflated. It is refused, and the inflate that refused it was
|
||||
// handed the cap, so it never produced more than 16 KB (the property, not a wall-clock proxy).
|
||||
inflateCalls.length = 0;
|
||||
expect((await answerWith(Buffer.alloc(4 * 1024 * 1024))).json()).toEqual({ error: "state_not_bound" });
|
||||
expect(inflateCalls.length).toBeGreaterThan(0);
|
||||
expect(inflateCalls.every((c) => c.maxOutputLength !== undefined && c.maxOutputLength <= 16 * 1024)).toBe(true);
|
||||
// At the cap it is read.
|
||||
expect((await answerWith(Buffer.alloc(16 * 1024, 97))).json()).toMatchObject({ error: "consent_refused" });
|
||||
});
|
||||
|
||||
it("requested scopes are capped at 32 of 512 characters, at start", async () => {
|
||||
const { app } = await newApp();
|
||||
const startWith = (requestedScopes: string[]) =>
|
||||
app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/start",
|
||||
headers: secret,
|
||||
payload: { appSlug: "streampixels", mode: "connect", connection: { kind: "creator", targetId: "c" }, returnTo: "https://streampixels.gamecult.org/s", handoff: { kind: "browser_completion" }, requestedScopes },
|
||||
});
|
||||
const scopes = (n: number, len: number) => Array.from({ length: n }, (_, i) => `${i}`.padEnd(len, "x"));
|
||||
expect((await startWith(scopes(33, 10))).json()).toMatchObject({ error: "requested_scopes_too_large" });
|
||||
expect((await startWith(scopes(1, 513))).json()).toMatchObject({ error: "requested_scopes_too_large" });
|
||||
expect((await startWith(scopes(32, 512))).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("an ask the cookies could not carry is refused, not shown", async () => {
|
||||
const { app } = await newApp();
|
||||
const noise = Array.from({ length: 32 }, () => randomBytes(256).toString("hex")); // 32 x 512 incompressible
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/start",
|
||||
headers: secret,
|
||||
payload: { appSlug: "streampixels", mode: "connect", connection: { kind: "creator", targetId: "c" }, returnTo: "https://streampixels.gamecult.org/s", handoff: { kind: "browser_completion" }, requestedScopes: noise },
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const page = await app.inject({ method: "GET", url: launchUrl(stateOf(start.json())), headers: { accept: "text/html" } });
|
||||
expect(page.statusCode).toBe(400);
|
||||
expect(page.json()).toEqual({ error: "consent_ask_too_large" });
|
||||
expect(askCookieOf(page)).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
it("the consent route refuses a flow that has no ask", async () => {
|
||||
const { app } = await newApp();
|
||||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/twitch/start",
|
||||
headers: secret,
|
||||
payload: { appSlug: "streampixels", mode: "sign_in", returnTo: "https://streampixels.gamecult.org/", handoff: { kind: "browser_completion" } },
|
||||
});
|
||||
const state = stateOf(start.json());
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/twitch/consent",
|
||||
headers: form,
|
||||
payload: new URLSearchParams({ state, decision: "continue" }).toString(),
|
||||
});
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json()).toEqual({ error: "consent_not_required" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("the wording digest", () => {
|
||||
const ask: ConsentAsk = { appSlug: "streampixels", provider: "joystick", scopes: ["identity:read"], returnOrigin: "https://streampixels.gamecult.org" };
|
||||
it("is the sha-256 of the text shown, and moves with the app, provider, scopes and origin", () => {
|
||||
expect(consentDigest(ask)).toBe(createHash("sha256").update(consentText(ask), "utf8").digest("hex"));
|
||||
const variants: ConsentAsk[] = [
|
||||
{ ...ask, appSlug: "bifrost" },
|
||||
{ ...ask, provider: "twitch" },
|
||||
{ ...ask, scopes: ["identity:read", "chat:read"] },
|
||||
{ ...ask, returnOrigin: "https://elsewhere.example" },
|
||||
];
|
||||
for (const variant of variants) expect(consentDigest(variant)).not.toBe(consentDigest(ask));
|
||||
});
|
||||
});
|
||||
|
||||
describe("refusal", () => {
|
||||
it("declining yields consent_refused by the viewer, stores nothing, and spends the state", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
const no = await answer(app, state, "decline", cookie, "application/json");
|
||||
expect(no.statusCode).toBe(400);
|
||||
expect(no.json()).toMatchObject({ error: "consent_refused", by: "viewer", provider: "joystick" });
|
||||
|
||||
// Nothing launches or completes afterwards, and nothing was kept.
|
||||
expect((await answer(app, state, "continue", cookie, "application/json")).json()).toEqual({ error: "state_already_launched" });
|
||||
expect((await callback(app, state, cookie, "code=code-a")).json()).toEqual({ error: "state_not_bound" });
|
||||
expect(await store.findStoredLinkedIdentity("joystick", "joy-a")).toBeNull();
|
||||
const events = [...(store as unknown as { auditEvents: Map<string, { eventType: string; eventPayloadJson: unknown }> }).auditEvents.values()];
|
||||
expect(events.filter((event) => event.eventType === "consent_refused").map((event) => event.eventPayloadJson)).toEqual([
|
||||
{ provider: "joystick", mode: "connect", by: "viewer" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("the browser sees a 'Not Connected' page, not an authentication failure", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
const no = await answer(app, state, "decline", cookie);
|
||||
expect(no.statusCode).toBe(200);
|
||||
expect(no.body).toContain("Not Connected");
|
||||
expect(no.body).toContain("consent_refused");
|
||||
expect(no.body).not.toContain("Authentication Failed");
|
||||
});
|
||||
|
||||
it("an access_denied from the provider is consent_refused by the provider, distinct from provider_error", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const denied = await newFlow(app);
|
||||
const response = await callback(app, denied.state, denied.cookie, "error=access_denied");
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json()).toMatchObject({ error: "consent_refused", by: "provider" });
|
||||
|
||||
const faulty = await newFlow(app);
|
||||
expect((await callback(app, faulty.state, faulty.cookie, "error=server_error")).json().error).toBe("provider_error");
|
||||
const events = [...(store as unknown as { auditEvents: Map<string, { eventType: string }> }).auditEvents.values()];
|
||||
expect(events.filter((event) => event.eventType === "consent_refused")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("a backend_callback app is told, with who refused", async () => {
|
||||
const callbackUrl = "https://streampixels.gamecult.org/api/heimdall/callback";
|
||||
const { app } = await newApp({ callbacks: [callbackUrl] });
|
||||
const delivered: Array<Record<string, unknown>> = [];
|
||||
vi.spyOn(globalThis, "fetch").mockImplementation(async (_url, init) => {
|
||||
delivered.push(JSON.parse(String(init?.body)));
|
||||
return new Response("ok", { status: 200 });
|
||||
});
|
||||
const handoff = { kind: "backend_callback", callbackUrl, attemptId: "attempt-1" };
|
||||
|
||||
const byViewer = await startConnect(app, handoff);
|
||||
const { cookie } = await seeAsk(app, byViewer);
|
||||
await answer(app, byViewer, "decline", cookie);
|
||||
const byProvider = await startConnect(app, handoff);
|
||||
const second = await seeAsk(app, byProvider);
|
||||
const proceeded = await answer(app, byProvider, "continue", second.cookie);
|
||||
await callback(app, byProvider, bindingCookieOf(proceeded)!, "error=access_denied");
|
||||
|
||||
expect(delivered.map((payload) => [payload.status, payload.error, payload.by])).toEqual([
|
||||
["error", "consent_refused", "viewer"],
|
||||
["error", "consent_refused", "provider"],
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
/** What an app's landing page can read: the fragment on the page's "Return to the app" link. */
|
||||
function returnFragment(page: { body: string }): URLSearchParams {
|
||||
const href = /id="return-link" href="([^"]+)"/.exec(page.body)?.[1];
|
||||
expect(href, "the page carries a return link").toBeDefined();
|
||||
const url = new URL(href!);
|
||||
expect(url.origin + url.pathname).toBe("https://streampixels.gamecult.org/settings");
|
||||
return new URLSearchParams(url.hash.slice(1));
|
||||
}
|
||||
|
||||
describe("the refusal return contract", () => {
|
||||
const refusedFragment = (by: "viewer" | "provider") => ({
|
||||
heimdall_status: "error",
|
||||
heimdall_provider: "joystick",
|
||||
heimdall_handoff_kind: "browser_completion",
|
||||
heimdall_app_slug: "streampixels",
|
||||
heimdall_mode: "connect",
|
||||
heimdall_error: "consent_refused",
|
||||
heimdall_refused_by: by,
|
||||
});
|
||||
|
||||
it("a decline returns a fragment that says the viewer refused, with no completion code", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
const fragment = returnFragment(await answer(app, state, "decline", cookie));
|
||||
expect(Object.fromEntries(fragment)).toEqual(refusedFragment("viewer"));
|
||||
expect(fragment.has("heimdall_completion_code")).toBe(false);
|
||||
});
|
||||
|
||||
it("a provider access_denied returns a fragment that says the provider refused, with no completion code", async () => {
|
||||
const { app } = await newApp();
|
||||
const flow = await newFlow(app);
|
||||
const fragment = returnFragment(await callback(app, flow.state, flow.cookie, "error=access_denied", "text/html"));
|
||||
expect(Object.fromEntries(fragment)).toEqual(refusedFragment("provider"));
|
||||
expect(fragment.has("heimdall_completion_code")).toBe(false);
|
||||
});
|
||||
|
||||
it.each(["viewer", "provider"] as const)("a browser_completion attempt refused by the %s is named in the fragment", async (by) => {
|
||||
const { app, store } = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const attempt = await store.createAuthAttempt({
|
||||
handle: "attempt-refused",
|
||||
appSlug: "streampixels",
|
||||
provider: "joystick",
|
||||
mode: "connect",
|
||||
returnTo: "https://streampixels.gamecult.org/settings",
|
||||
createdAt: new Date().toISOString(),
|
||||
expiresAt: new Date(Date.now() + 600_000).toISOString(),
|
||||
});
|
||||
const caller = resolveAppCaller(ctx.config, "streampixels", secret);
|
||||
const started = await startOAuthFlow(
|
||||
ctx,
|
||||
"joystick",
|
||||
caller,
|
||||
{ appSlug: "streampixels", mode: "connect", connection: { kind: "creator", targetId: "creator-1" }, returnTo: "https://streampixels.gamecult.org/settings", handoff: { kind: "browser_completion" } },
|
||||
{ trustedBrowserAttemptId: attempt.handle }
|
||||
);
|
||||
expect(started.statusCode).toBe(201);
|
||||
const state = stateOf(started.body as Parameters<typeof stateOf>[0]);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
let page;
|
||||
if (by === "viewer") {
|
||||
page = await answer(app, state, "decline", cookie);
|
||||
} else {
|
||||
const go = await answer(app, state, "continue", cookie);
|
||||
page = await callback(app, state, bindingCookieOf(go)!, "error=access_denied", "text/html");
|
||||
}
|
||||
expect(Object.fromEntries(returnFragment(page))).toEqual({ ...refusedFragment(by), heimdall_attempt_id: "attempt-refused" });
|
||||
});
|
||||
});
|
||||
|
||||
async function newFlow(app: FastifyInstance) {
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
const go = await answer(app, state, "continue", cookie);
|
||||
expect(go.statusCode).toBe(302);
|
||||
return { state, cookie: bindingCookieOf(go)! };
|
||||
}
|
||||
|
||||
describe("the receipt", () => {
|
||||
it("a granted completion writes one receipt with asked and granted scopes and the digest of the wording shown", async () => {
|
||||
const { app, store } = await newApp({ granted: ["identity:read", "stream:read"] });
|
||||
const done = await grantAs(app, "a");
|
||||
const receipts = await store.listConsentReceipts(done.account.id);
|
||||
expect(receipts).toHaveLength(1);
|
||||
const ask: ConsentAsk = { appSlug: "streampixels", provider: "joystick", scopes: defaultScopes, returnOrigin: "https://streampixels.gamecult.org" };
|
||||
expect(receipts[0]).toMatchObject({
|
||||
id: done.consentReceiptId,
|
||||
kind: "grant",
|
||||
accountId: done.account.id,
|
||||
appSlug: "streampixels",
|
||||
provider: "joystick",
|
||||
scopesAsked: defaultScopes,
|
||||
scopesGranted: ["identity:read", "stream:read"],
|
||||
consentPageDigest: consentDigest(ask),
|
||||
});
|
||||
});
|
||||
|
||||
it("the receipt holds the wording the person was shown, and its digest is that wording's hash", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const asked = await seeAsk(app, state);
|
||||
const go = await answer(app, state, "continue", asked.cookie);
|
||||
const done = await callback(app, state, bindingCookieOf(go)!, "code=code-a");
|
||||
const [receipt] = await store.listConsentReceipts(done.json().account.id);
|
||||
if (receipt?.kind !== "grant") throw new Error("no grant");
|
||||
expect(receipt.consentPageDigest).toBe(digestOfText(receipt.consentText));
|
||||
const shown = asked.page.body.replace(/'/g, "'").replace(/"/g, '"').replace(/>/g, ">").replace(/</g, "<").replace(/&/g, "&");
|
||||
for (const line of receipt.consentText.split("\n")) expect(shown, line).toContain(line);
|
||||
expect(receipt.consentText).toContain("Continue to Joystick");
|
||||
expect(receipt.consentText).toContain("No, return to the app");
|
||||
});
|
||||
|
||||
it("a refusal leaves no receipt", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
await answer(app, state, "decline", cookie);
|
||||
expect(await store.listConsentReceipts("anyone")).toEqual([]);
|
||||
expect((await store.findStoredLinkedIdentity("joystick", "joy-a"))).toBeNull();
|
||||
});
|
||||
|
||||
it("the success page names the receipt", async () => {
|
||||
const { app } = await newApp();
|
||||
const state = await startConnect(app);
|
||||
const { cookie } = await seeAsk(app, state);
|
||||
const go = await answer(app, state, "continue", cookie);
|
||||
const page = await callback(app, state, bindingCookieOf(go)!, "code=code-a", "text/html");
|
||||
expect(page.statusCode).toBe(200);
|
||||
expect(page.body).toMatch(/receipt [0-9a-f-]{36}/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("my grants", () => {
|
||||
it("is closed to anyone without a live Heimdall access token", async () => {
|
||||
const { app } = await newApp();
|
||||
for (const headers of [{}, bearer("not-a-token")]) {
|
||||
const response = await app.inject({ method: "GET", url: "/v1/me/grants", headers });
|
||||
expect(response.statusCode).toBe(401);
|
||||
expect(response.json().error).toBe("sign_in_required");
|
||||
}
|
||||
const link = await app.inject({ method: "POST", url: "/v1/me/grants/link" });
|
||||
expect(link.statusCode).toBe(401);
|
||||
const revoke = await app.inject({ method: "POST", url: "/v1/me/grants/x/revoke" });
|
||||
expect(revoke.statusCode).toBe(401);
|
||||
});
|
||||
|
||||
it("lists the signed-in account's grants and receipts, and no one else's", async () => {
|
||||
const { app } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
const b = await grantAs(app, "b");
|
||||
const mine = await grantsOf(app, a.accessToken);
|
||||
expect(mine.grants).toHaveLength(1);
|
||||
expect(mine.grants[0]).toMatchObject({ id: a.consentReceiptId, status: "active", provider: "joystick", appSlug: "streampixels", scopesGranted: ["identity:read", "stream:read"] });
|
||||
expect(JSON.stringify(mine)).not.toContain(b.consentReceiptId);
|
||||
expect(mine.receipts.map((receipt) => receipt.accountId)).toEqual([a.account.id]);
|
||||
});
|
||||
|
||||
it("revoke takes effect on the next token use, edits no row, and receipts the revocation", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
expect((await resolveCredential(app, a.account.id)).statusCode).toBe(200);
|
||||
const before = await store.listConsentReceipts(a.account.id);
|
||||
|
||||
const revoke = await app.inject({ method: "POST", url: `/v1/me/grants/${a.consentReceiptId}/revoke`, headers: bearer(a.accessToken) });
|
||||
expect(revoke.statusCode).toBe(200);
|
||||
expect(revoke.json().revoked).toEqual([a.consentReceiptId]);
|
||||
|
||||
const next = await resolveCredential(app, a.account.id);
|
||||
expect(next.statusCode).toBe(410);
|
||||
expect(next.json().error).toBe("managed_credential_revoked");
|
||||
|
||||
const after = await store.listConsentReceipts(a.account.id);
|
||||
expect(after).toHaveLength(2);
|
||||
expect(after[0]).toEqual(before[0]);
|
||||
expect(after[1]).toMatchObject({ kind: "revocation", revokesReceiptId: a.consentReceiptId, accountId: a.account.id });
|
||||
const view = (await grantsOf(app, a.accessToken)).grants[0]!;
|
||||
expect(view).toMatchObject({ status: "revoked", revocationReceiptId: after[1]!.id });
|
||||
expect(view.revokedAt).toBe(after[1]!.createdAt);
|
||||
});
|
||||
|
||||
it("revoke is the owner's alone: another account's grant id is not found and its credential is untouched", async () => {
|
||||
const { app } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
const b = await grantAs(app, "b");
|
||||
const attempt = await app.inject({ method: "POST", url: `/v1/me/grants/${a.consentReceiptId}/revoke`, headers: bearer(b.accessToken) });
|
||||
expect(attempt.statusCode).toBe(404);
|
||||
expect((await resolveCredential(app, a.account.id)).statusCode).toBe(200);
|
||||
expect((await resolveCredential(app, b.account.id)).statusCode).toBe(200);
|
||||
});
|
||||
|
||||
it("revoking twice changes nothing the second time", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
const url = `/v1/me/grants/${a.consentReceiptId}/revoke`;
|
||||
await app.inject({ method: "POST", url, headers: bearer(a.accessToken) });
|
||||
const second = await app.inject({ method: "POST", url, headers: bearer(a.accessToken) });
|
||||
expect(second.statusCode).toBe(200);
|
||||
expect(second.json().revoked).toEqual([]);
|
||||
expect(await store.listConsentReceipts(a.account.id)).toHaveLength(2);
|
||||
const events = [...(store as unknown as { auditEvents: Map<string, { eventType: string }> }).auditEvents.values()];
|
||||
expect(events.filter((event) => event.eventType === "consent_revoked")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("a fresh connection after a revoke is a new grant, live again, and the old one stays revoked", async () => {
|
||||
const { app } = await newApp();
|
||||
const first = await grantAs(app, "a");
|
||||
await app.inject({ method: "POST", url: `/v1/me/grants/${first.consentReceiptId}/revoke`, headers: bearer(first.accessToken) });
|
||||
const second = await grantAs(app, "a");
|
||||
expect(second.consentReceiptId).not.toBe(first.consentReceiptId);
|
||||
expect((await resolveCredential(app, second.account.id)).statusCode).toBe(200);
|
||||
const grants = (await grantsOf(app, second.accessToken)).grants;
|
||||
expect(grants.map((grant) => [grant.id, grant.status])).toEqual([
|
||||
[first.consentReceiptId, "revoked"],
|
||||
[second.consentReceiptId, "active"],
|
||||
]);
|
||||
});
|
||||
|
||||
it("a browser with no session opens the page from a minted link and revokes with one form post", async () => {
|
||||
const { app } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
const link = await app.inject({ method: "POST", url: "/v1/me/grants/link", headers: bearer(a.accessToken) });
|
||||
expect(link.statusCode).toBe(201);
|
||||
const url = new URL(link.json().url as string);
|
||||
const page = await app.inject({ method: "GET", url: `${url.pathname}${url.search}`, headers: { accept: "text/html" } });
|
||||
expect(page.statusCode).toBe(200);
|
||||
expect(page.body).toContain(a.consentReceiptId);
|
||||
expect(page.body).toContain("Take this back");
|
||||
expect(page.body).not.toContain("<script");
|
||||
|
||||
const token = url.searchParams.get("t")!;
|
||||
const post = await app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/me/grants/${a.consentReceiptId}/revoke`,
|
||||
headers: { ...form, accept: "text/html" },
|
||||
payload: new URLSearchParams({ t: token }).toString(),
|
||||
});
|
||||
expect(post.statusCode).toBe(200);
|
||||
expect(post.body).toContain("Taken back.");
|
||||
expect((await resolveCredential(app, a.account.id)).statusCode).toBe(410);
|
||||
});
|
||||
|
||||
it("a page link is never renewed by being used: the forms on its page expire when the link does", async () => {
|
||||
const { app } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
const link = await app.inject({ method: "POST", url: "/v1/me/grants/link", headers: bearer(a.accessToken) });
|
||||
const url = new URL(link.json().url as string);
|
||||
const linkToken = url.searchParams.get("t")!;
|
||||
// Two minutes on, so a form token minted afresh would differ from the link's.
|
||||
vi.useFakeTimers({ toFake: ["Date"], now: Date.now() + 120_000 });
|
||||
const page = await app.inject({ method: "GET", url: `${url.pathname}${url.search}`, headers: { accept: "text/html" } });
|
||||
const formToken = /name="t" value="([^"]+)"/.exec(page.body)![1]!;
|
||||
expect(decodeJwt(formToken).payload.exp).toBe(decodeJwt(linkToken).payload.exp);
|
||||
// The same holds one hop on: the page a form post answers with.
|
||||
const post = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/me/grants/nope/revoke",
|
||||
headers: { ...form, accept: "text/html" },
|
||||
payload: new URLSearchParams({ t: formToken }).toString(),
|
||||
});
|
||||
expect(post.statusCode).toBe(404);
|
||||
// A bearer, by contrast, opens a fresh window.
|
||||
const fresh = await app.inject({ method: "GET", url: "/v1/me/grants", headers: { ...bearer(a.accessToken), accept: "text/html" } });
|
||||
const freshToken = /name="t" value="([^"]+)"/.exec(fresh.body)![1]!;
|
||||
expect(decodeJwt(freshToken).payload.exp).toBeGreaterThanOrEqual(decodeJwt(linkToken).payload.exp as number);
|
||||
});
|
||||
|
||||
it("two revokes at once take the grant back once: one revocation row, one audit event, one reporter", async () => {
|
||||
const { app, store } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
const url = `/v1/me/grants/${a.consentReceiptId}/revoke`;
|
||||
const [one, two] = await Promise.all([
|
||||
app.inject({ method: "POST", url, headers: bearer(a.accessToken) }),
|
||||
app.inject({ method: "POST", url, headers: bearer(a.accessToken) }),
|
||||
]);
|
||||
expect([one.json().revoked.length, two.json().revoked.length].sort()).toEqual([0, 1]);
|
||||
expect((await store.listConsentReceipts(a.account.id)).filter((r) => r.kind === "revocation")).toHaveLength(1);
|
||||
const events = [...(store as unknown as { auditEvents: Map<string, { eventType: string }> }).auditEvents.values()];
|
||||
expect(events.filter((event) => event.eventType === "consent_revoked")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("a page link proves only what it was minted for: an access token, a foreign token or none opens nothing", async () => {
|
||||
const { app } = await newApp();
|
||||
const a = await grantAs(app, "a");
|
||||
for (const t of [a.accessToken, "garbage", ""]) {
|
||||
const response = await app.inject({ method: "GET", url: `/v1/me/grants?t=${encodeURIComponent(t)}` });
|
||||
expect(response.statusCode, t).toBe(401);
|
||||
const revoke = await app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/me/grants/${a.consentReceiptId}/revoke`,
|
||||
headers: form,
|
||||
payload: new URLSearchParams({ t }).toString(),
|
||||
});
|
||||
expect(revoke.statusCode, t).toBe(401);
|
||||
}
|
||||
expect((await resolveCredential(app, a.account.id)).statusCode).toBe(200);
|
||||
});
|
||||
});
|
||||
284
tests/link-binding.test.ts
Normal file
284
tests/link-binding.test.ts
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { buildApp } from "../src/app.js";
|
||||
import { type HeimdallConfig } from "../src/config.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { createRuntimeKeyMaterial, signJwt, verifyJwt } from "../src/signing.js";
|
||||
import { IdentityHeldElsewhereError, InMemoryStore } from "../src/store/index.js";
|
||||
import { launchFlow } from "./oauth-flow.js";
|
||||
|
||||
function createTestConfig(): HeimdallConfig {
|
||||
return {
|
||||
serviceName: "heimdall",
|
||||
host: "127.0.0.1",
|
||||
port: 4100,
|
||||
workspaceRoot: "E:/Projects/Heimdall",
|
||||
dataRoot: "E:/Projects/Heimdall/.heimdall-data",
|
||||
cultCachePath: "E:/Projects/Heimdall/.heimdall-data/cultcache/heimdall.service.cc",
|
||||
publicBaseUrl: "https://heimdall.gamecult.org",
|
||||
issuer: "https://heimdall.gamecult.org",
|
||||
daemonId: "yggdrasil-heimdall",
|
||||
idunnRudpHealth: undefined,
|
||||
idunnHealthContract: "heimdall.cultnet-rudp-provider-health",
|
||||
providerHealthIdentityPath: "E:/Projects/Heimdall/.heimdall-data/provider-health-identity.cc",
|
||||
sessionTtlSeconds: 3600,
|
||||
refreshTtlSeconds: 60 * 60 * 24 * 30,
|
||||
stateTtlSeconds: 600,
|
||||
completionTtlSeconds: 300,
|
||||
bootstrapSigningPrivateKeyOnMissing: false,
|
||||
tokenEncryptionKeyBase64: Buffer.alloc(32, 7).toString("base64"),
|
||||
appSharedSecrets: {
|
||||
streampixels: "streampixels-secret",
|
||||
repixelizer: "repixelizer-secret",
|
||||
bifrost: "bifrost-secret",
|
||||
},
|
||||
appBackendCallbacks: {
|
||||
bifrost: ["https://bifrost.gamecult.org/auth/heimdall/callback"],
|
||||
repixelizer: ["https://repixelizer.gamecult.org/api/auth/heimdall/callback"],
|
||||
},
|
||||
storage: {
|
||||
backend: "memory",
|
||||
applySchemaOnStartup: true,
|
||||
},
|
||||
providers: {
|
||||
discord: { clientId: "discord-client", clientSecret: "discord-secret" },
|
||||
patreon: { clientId: "patreon-client", clientSecret: "patreon-secret" },
|
||||
github: { clientId: "github-client", clientSecret: "github-secret" },
|
||||
twitch: { clientId: "twitch-client", clientSecret: "twitch-secret" },
|
||||
youtube: { clientId: "youtube-client", clientSecret: "youtube-secret" },
|
||||
spotify: { clientId: "spotify-client", clientSecret: "spotify-secret" },
|
||||
joystick: { clientId: "joystick-client", clientSecret: "joystick-secret" },
|
||||
google: { clientId: "google-client", clientSecret: "google-secret" },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
// Link mode binds a provider identity to the account an authenticated app
|
||||
// named at start. These tests pin the three places that binding is decided:
|
||||
// the callback (initiator), the completion row (target), and redeem (caller,
|
||||
// target, replay).
|
||||
|
||||
const returnTo = "https://repixelizer.gamecult.org/app/";
|
||||
const appAuth = { "x-heimdall-app-secret": "repixelizer-secret" };
|
||||
|
||||
function discordRuntime(providerUserId: string): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return { accessToken: "at", refreshToken: "rt", tokenType: "Bearer", scope: ["identify"], raw: {} };
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return { provider: "discord", providerUserId, username: providerUserId, profile: { id: providerUserId } };
|
||||
},
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const apps: Awaited<ReturnType<typeof buildApp>>[] = [];
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
await Promise.all(apps.splice(0).map((app) => app.close()));
|
||||
});
|
||||
|
||||
async function rig(providerUserId: string, config: HeimdallConfig = createTestConfig()) {
|
||||
const store = new InMemoryStore();
|
||||
const app = await buildApp({ config, store, oauthRuntimes: { discord: discordRuntime(providerUserId) } });
|
||||
apps.push(app);
|
||||
const now = new Date().toISOString();
|
||||
const initiator = await store.createAccount({ createdAt: now, lastSeenAt: now });
|
||||
return { app, store, initiator };
|
||||
}
|
||||
|
||||
type Rig = Awaited<ReturnType<typeof rig>>;
|
||||
|
||||
function start(r: Rig, payload: Record<string, unknown>, headers: Record<string, string> = appAuth) {
|
||||
return r.app.inject({ method: "POST", url: "/v1/oauth/discord/start", headers, payload: { appSlug: "repixelizer", returnTo, ...payload } });
|
||||
}
|
||||
|
||||
/** The browser follows authorizationUrl through the launch hop, then returns with the state, or with `forged` in its place, and the cookie it was handed. */
|
||||
async function callback(r: Rig, started: { authorizationUrl: string }, forged?: (state: string) => string) {
|
||||
const flow = await launchFlow(r.app, started);
|
||||
const state = forged ? forged(flow.state) : flow.state;
|
||||
return r.app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
}
|
||||
|
||||
function redeem(r: Rig, payload: Record<string, unknown>, headers: Record<string, string> = {}) {
|
||||
return r.app.inject({ method: "POST", url: "/v1/apps/repixelizer/auth-completions/redeem", headers, payload });
|
||||
}
|
||||
|
||||
describe("link start names its initiator", () => {
|
||||
it("refuses an unauthenticated link start, a missing or unknown initiator, and an initiator outside link mode", async () => {
|
||||
const r = await rig("d-1");
|
||||
const mode = { mode: "link", initiatingAccountId: r.initiator.id };
|
||||
expect((await start(r, mode, {})).statusCode).toBe(401);
|
||||
expect((await start(r, mode, { "x-heimdall-app-secret": "wrong" })).statusCode).toBe(401);
|
||||
const missing = await start(r, { mode: "link" });
|
||||
expect([missing.statusCode, missing.json().error]).toEqual([400, "link_initiator_required"]);
|
||||
const unknown = await start(r, { mode: "link", initiatingAccountId: "no-such-account" });
|
||||
expect([unknown.statusCode, unknown.json().error]).toEqual([400, "link_initiator_unknown"]);
|
||||
const stray = await start(r, { mode: "sign_in", initiatingAccountId: r.initiator.id }, {});
|
||||
expect([stray.statusCode, stray.json().error]).toEqual([400, "initiator_only_in_link_mode"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("sign_in start carries no connection target", () => {
|
||||
it("refuses connection.targetId on sign_in with connection_not_allowed_in_sign_in, with or without app auth", async () => {
|
||||
const r = await rig("d-si");
|
||||
const connection = { kind: "creator", targetId: "victim-target" };
|
||||
for (const headers of [{}, appAuth]) {
|
||||
const res = await start(r, { mode: "sign_in", connection }, headers);
|
||||
expect([res.statusCode, res.json().error]).toEqual([400, "connection_not_allowed_in_sign_in"]);
|
||||
}
|
||||
expect((await start(r, { mode: "sign_in" }, {})).statusCode).toBe(201);
|
||||
});
|
||||
});
|
||||
|
||||
describe("link callback holds the provider identity to the initiator", () => {
|
||||
it("attaches an unlinked identity to the initiating account, not a new one", async () => {
|
||||
const r = await rig("d-new");
|
||||
const started = await start(r, { mode: "link", initiatingAccountId: r.initiator.id });
|
||||
expect(started.statusCode).toBe(201);
|
||||
const done = await callback(r, started.json());
|
||||
expect(done.statusCode).toBe(201);
|
||||
expect(done.json().account.id).toBe(r.initiator.id);
|
||||
expect((await r.store.findAccountByLinkedIdentity("discord", "d-new"))?.id).toBe(r.initiator.id);
|
||||
});
|
||||
|
||||
it("refuses with link_initiator_mismatch when the identity already belongs to another account, and mints nothing", async () => {
|
||||
const r = await rig("d-held");
|
||||
const now = new Date().toISOString();
|
||||
const other = await r.store.createAccount({ createdAt: now, lastSeenAt: now });
|
||||
await r.store.upsertLinkedIdentity({ accountId: other.id, provider: "discord", providerUserId: "d-held", scopes: [], profileJson: {}, createdAt: now, updatedAt: now });
|
||||
const started = await start(r, { mode: "link", initiatingAccountId: r.initiator.id });
|
||||
const done = await callback(r, started.json());
|
||||
expect(done.statusCode).toBe(403);
|
||||
expect(done.json().error).toBe("link_initiator_mismatch");
|
||||
expect(done.json().completion).toBeUndefined();
|
||||
expect(done.body).not.toContain("accessToken");
|
||||
expect((await r.store.findAccountByLinkedIdentity("discord", "d-held"))?.id).toBe(other.id);
|
||||
});
|
||||
|
||||
it("maps a store refusal of the move (a race past the check) to link_initiator_mismatch", async () => {
|
||||
const r = await rig("d-race");
|
||||
vi.spyOn(r.store, "upsertLinkedIdentity").mockRejectedValueOnce(new IdentityHeldElsewhereError());
|
||||
const started = await start(r, { mode: "link", initiatingAccountId: r.initiator.id });
|
||||
const done = await callback(r, started.json());
|
||||
expect([done.statusCode, done.json().error]).toEqual([403, "link_initiator_mismatch"]);
|
||||
expect(done.json().completion).toBeUndefined();
|
||||
});
|
||||
|
||||
it("refuses a link state that carries no initiator (forged or stripped), before attaching anything", async () => {
|
||||
const dir = mkdtempSync(join(tmpdir(), "heimdall-link-"));
|
||||
try {
|
||||
const config = { ...createTestConfig(), signingPrivateKeyPath: join(dir, "signing.pem"), bootstrapSigningPrivateKeyOnMissing: true };
|
||||
const r = await rig("d-forged", config);
|
||||
const keys = createRuntimeKeyMaterial({ ...config, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
const started = await start(r, { mode: "link", initiatingAccountId: r.initiator.id });
|
||||
const done = await callback(r, started.json(), (state) => {
|
||||
const verified = verifyJwt(state, keys.publicKey) as { valid: boolean; payload: Record<string, unknown> };
|
||||
expect(verified.valid).toBe(true);
|
||||
return signJwt({ ...verified.payload, initiator_account_id: null }, keys);
|
||||
});
|
||||
expect([done.statusCode, done.json().error]).toEqual([403, "link_initiator_missing"]);
|
||||
expect(await r.store.findAccountByLinkedIdentity("discord", "d-forged")).toBeNull();
|
||||
} finally {
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("redeem binds caller, target and replay", () => {
|
||||
async function linked(r: Rig, targetId: string | undefined) {
|
||||
const started = await start(r, {
|
||||
mode: "link",
|
||||
initiatingAccountId: r.initiator.id,
|
||||
...(targetId ? { connection: { kind: "account", targetId } } : {}),
|
||||
});
|
||||
const done = await callback(r, started.json());
|
||||
expect(done.statusCode).toBe(201);
|
||||
return done.json().completion.code as string;
|
||||
}
|
||||
|
||||
it("redeems a link completion only for the authenticated app, and a refused caller does not burn the code", async () => {
|
||||
const r = await rig("d-r1");
|
||||
const completionCode = await linked(r, undefined);
|
||||
const anonymous = await redeem(r, { completionCode });
|
||||
expect([anonymous.statusCode, anonymous.json().error]).toEqual([401, "app_auth_required"]);
|
||||
expect((await redeem(r, { completionCode }, { "x-heimdall-app-secret": "wrong" })).statusCode).toBe(401);
|
||||
expect((await redeem(r, { completionCode }, appAuth)).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("refuses a wrong or missing target with completion_target_mismatch without consuming the code", async () => {
|
||||
const r = await rig("d-r2");
|
||||
const completionCode = await linked(r, "target-a");
|
||||
for (const payload of [{ completionCode, targetId: "target-b" }, { completionCode }]) {
|
||||
const refused = await redeem(r, payload, appAuth);
|
||||
expect([refused.statusCode, refused.json().error]).toEqual([403, "completion_target_mismatch"]);
|
||||
expect(refused.json().accessToken).toBeUndefined();
|
||||
}
|
||||
expect((await redeem(r, { completionCode, targetId: "target-a" }, appAuth)).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("refuses a target named against a completion that recorded none, without consuming the code", async () => {
|
||||
const r = await rig("d-r2b");
|
||||
const completionCode = await linked(r, undefined);
|
||||
const refused = await redeem(r, { completionCode, targetId: "target-a" }, appAuth);
|
||||
expect([refused.statusCode, refused.json().error]).toEqual([403, "completion_target_mismatch"]);
|
||||
expect(refused.json().accessToken).toBeUndefined();
|
||||
expect((await r.store.findAuthCompletion("repixelizer", completionCode))?.consumedAt).toBeUndefined();
|
||||
expect((await redeem(r, { completionCode }, appAuth)).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("refuses a replayed completion", async () => {
|
||||
const r = await rig("d-r3");
|
||||
const completionCode = await linked(r, "target-a");
|
||||
expect((await redeem(r, { completionCode, targetId: "target-a" }, appAuth)).statusCode).toBe(201);
|
||||
expect((await redeem(r, { completionCode, targetId: "target-a" }, appAuth)).statusCode).toBe(410);
|
||||
});
|
||||
|
||||
it("refuses a completion at and after its expiry with 410, whatever the caller and target, and honours it just before", async () => {
|
||||
// completionTtlSeconds is 300. Only Date is faked: the app and store run on real timers.
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
const t0 = Date.parse("2026-11-03T00:00:00.000Z");
|
||||
const ttlMs = createTestConfig().completionTtlSeconds * 1000;
|
||||
const expired = { statusCode: 410, error: "invalid_or_expired_completion_code" };
|
||||
const outcome = async (r: Rig, payload: Record<string, unknown>) => {
|
||||
const res = await redeem(r, payload, appAuth);
|
||||
return { statusCode: res.statusCode, error: res.json().error };
|
||||
};
|
||||
|
||||
vi.setSystemTime(t0);
|
||||
const r = await rig("d-exp");
|
||||
const code = await linked(r, "target-a");
|
||||
const row = await r.store.findAuthCompletion("repixelizer", code);
|
||||
expect(row?.expiresAt).toBe(new Date(t0 + ttlMs).toISOString());
|
||||
|
||||
// Just before expiry the right caller and target redeem it.
|
||||
const early = await rig("d-exp-early");
|
||||
const earlyCode = await linked(early, "target-a");
|
||||
vi.setSystemTime(t0 + ttlMs - 1);
|
||||
expect((await redeem(early, { completionCode: earlyCode, targetId: "target-a" }, appAuth)).statusCode).toBe(201);
|
||||
|
||||
// At the expiry instant and after it: 410, for the right target and for a wrong one (not 403), unconsumed.
|
||||
for (const at of [t0 + ttlMs, t0 + ttlMs + 1]) {
|
||||
vi.setSystemTime(at);
|
||||
expect(await outcome(r, { completionCode: code, targetId: "target-a" })).toEqual(expired);
|
||||
expect(await outcome(r, { completionCode: code, targetId: "target-b" })).toEqual(expired);
|
||||
}
|
||||
expect((await r.store.findAuthCompletion("repixelizer", code))?.consumedAt).toBeUndefined();
|
||||
});
|
||||
|
||||
it("stores the target on the completion row", async () => {
|
||||
const r = await rig("d-r4");
|
||||
const completionCode = await linked(r, "target-a");
|
||||
expect((await r.store.findAuthCompletion("repixelizer", completionCode))?.targetId).toBe("target-a");
|
||||
});
|
||||
});
|
||||
|
|
@ -6,6 +6,7 @@ import { type HeimdallConfig } from "../src/config.js";
|
|||
import { type Provider } from "../src/contracts.js";
|
||||
import { createTokenCustody } from "../src/custody.js";
|
||||
import {
|
||||
MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS,
|
||||
MANAGED_CREDENTIAL_REFRESH_SKEW_MS,
|
||||
ManagedCredentialRefreshFailed,
|
||||
refreshManagedCredential,
|
||||
|
|
@ -14,6 +15,7 @@ import { createOAuthRuntimeRegistry } from "../src/oauth.js";
|
|||
import { providerCatalog } from "../src/providers.js";
|
||||
import { InMemoryStore, PostgresStore, type HeimdallStore } from "../src/store/index.js";
|
||||
import { type StoredLinkedIdentity } from "../src/store/types.js";
|
||||
import { launchFlow } from "./oauth-flow.js";
|
||||
|
||||
const originalFetch = globalThis.fetch;
|
||||
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
|
|
@ -418,17 +420,18 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
expect(Date.now() - started).toBeLessThan(5_000);
|
||||
|
||||
endpoint.mode = "normal";
|
||||
const outcome = await refreshManagedCredential(ctx, await rig.row());
|
||||
const afterBackoff = { ...ctx, clock: () => Date.now() + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS };
|
||||
const outcome = await refreshManagedCredential(afterBackoff, await rig.row());
|
||||
expect(outcome.kind).toBe("current");
|
||||
expect(rig.custody.decrypt(outcome.identity.accessTokenEncrypted!)).toBe("access-1");
|
||||
});
|
||||
|
||||
it("single flight: concurrent refreshes against a never-answering endpoint make one provider call per process, and every caller gets the typed failure", timeout, async () => {
|
||||
it("single flight: concurrent refreshes against a never-answering endpoint make one provider call across all processes, and every caller gets the typed failure", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = "hang";
|
||||
const snapshot = await rig.row();
|
||||
const ctxFor = (store: HeimdallStore) => ({ config: rig.config, store, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), timeoutMs: 150 });
|
||||
const ctxFor = (store: HeimdallStore, clock = Date.now) => ({ config: rig.config, store, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), timeoutMs: 150, clock });
|
||||
|
||||
const results = await Promise.allSettled(
|
||||
Array.from({ length: 12 }, (_, i) => refreshManagedCredential(ctxFor(rig.stores[i % rig.stores.length]!), snapshot))
|
||||
|
|
@ -438,14 +441,205 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
for (const result of results) {
|
||||
expect((result as PromiseRejectedResult).reason).toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
}
|
||||
expect(endpoint.calls).toBe(rig.stores.length);
|
||||
// The process that queued behind the failed holder reads the holder's marker under the lock and presents nothing.
|
||||
expect(endpoint.calls).toBe(1);
|
||||
expect(rig.custody.decrypt((await rig.row()).refreshTokenEncrypted!)).toBe("refresh-0");
|
||||
|
||||
// The burst is over: a later independent request tries again.
|
||||
// The burst is over and so is the backoff the failure left on the row: a later independent request tries again.
|
||||
endpoint.mode = "normal";
|
||||
const later = await refreshManagedCredential(ctxFor(rig.stores[0]!), await rig.row());
|
||||
const later = await refreshManagedCredential(ctxFor(rig.stores[0]!, () => Date.now() + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS), await rig.row());
|
||||
expect(later.kind).toBe("current");
|
||||
expect(endpoint.calls).toBe(rig.stores.length + 1);
|
||||
expect(endpoint.calls).toBe(2);
|
||||
});
|
||||
|
||||
it.each(["server_error", "hang"] as const)(
|
||||
"cross-process failed-refresh marker (%s): the failed attempt is recorded on the row, and another process does not present the token inside the backoff",
|
||||
timeout,
|
||||
async (mode) => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = mode;
|
||||
const t0 = Date.now();
|
||||
const ctxFor = (store: HeimdallStore, at: number) => ({
|
||||
config: rig.config, store, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), timeoutMs: 100, clock: () => at,
|
||||
});
|
||||
const snapshot = await rig.row();
|
||||
const first = rig.stores[0]!;
|
||||
const other = rig.stores[rig.stores.length - 1]!;
|
||||
|
||||
await expect(refreshManagedCredential(ctxFor(first, t0), snapshot)).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
const marked = await rig.row();
|
||||
expect(marked.refreshFailedAt).toBe(new Date(t0).toISOString());
|
||||
expect(marked.accessTokenEncrypted).toBe(snapshot.accessTokenEncrypted);
|
||||
expect(marked.refreshTokenEncrypted).toBe(snapshot.refreshTokenEncrypted);
|
||||
expect(marked.tokenExpiresAt).toBe(snapshot.tokenExpiresAt);
|
||||
|
||||
// Another process, holding the stale snapshot, one tick before the backoff ends: the locked row decides, and no token call is made.
|
||||
const backedOff = ctxFor(other, t0 + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS - 1);
|
||||
await expect(refreshManagedCredential(backedOff, snapshot)).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
// Being turned away does not extend the backoff.
|
||||
expect((await rig.row()).refreshFailedAt).toBe(marked.refreshFailedAt);
|
||||
expect(await rig.audit()).toEqual([]);
|
||||
}
|
||||
);
|
||||
|
||||
it("cross-process failed-refresh marker: the backoff ends exactly at its length, a success clears the marker, and a failure after it marks anew", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = "server_error";
|
||||
const t0 = Date.now();
|
||||
const ctxAt = (at: number) => ({ config: rig.config, store: rig.stores[0]!, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), clock: () => at });
|
||||
await expect(refreshManagedCredential(ctxAt(t0), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
|
||||
const retryAt = t0 + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS;
|
||||
await expect(refreshManagedCredential(ctxAt(retryAt), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(2);
|
||||
expect((await rig.row()).refreshFailedAt).toBe(new Date(retryAt).toISOString());
|
||||
|
||||
endpoint.mode = "normal";
|
||||
const laterAt = retryAt + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS;
|
||||
const outcome = await refreshManagedCredential(ctxAt(laterAt), await rig.row());
|
||||
expect(outcome.kind).toBe("current");
|
||||
expect(endpoint.calls).toBe(3);
|
||||
expect(rig.custody.decrypt(outcome.identity.accessTokenEncrypted!)).toBe("access-1");
|
||||
expect((await rig.row()).refreshFailedAt).toBeUndefined();
|
||||
});
|
||||
|
||||
it("cross-process failed-refresh marker: a revocation and a re-link both clear it", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = "server_error";
|
||||
const t0 = Date.now();
|
||||
const ctxAt = (at: number) => ({ config: rig.config, store: rig.stores[0]!, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), clock: () => at });
|
||||
await expect(refreshManagedCredential(ctxAt(t0), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect((await rig.row()).refreshFailedAt).toBeDefined();
|
||||
|
||||
endpoint.mode = "invalid_grant";
|
||||
const revoked = await refreshManagedCredential(ctxAt(t0 + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS), await rig.row());
|
||||
expect(revoked.kind).toBe("revoked");
|
||||
expect((await rig.row()).refreshFailedAt).toBeUndefined();
|
||||
|
||||
// A fresh consent after a failure replaces the whole credential, marker included.
|
||||
endpoint.mode = "server_error";
|
||||
const relinkSeed = await rig.row();
|
||||
await rig.stores[0]!.upsertLinkedIdentity({
|
||||
accountId: rig.accountId, provider, providerUserId: relinkSeed.providerUserId, scopes: ["identity:read"], profileJson: {},
|
||||
accessTokenEncrypted: rig.custody.encrypt("access-r"), refreshTokenEncrypted: rig.custody.encrypt("refresh-r"),
|
||||
tokenExpiresAt: new Date(t0 + 1000).toISOString(), createdAt: relinkSeed.createdAt, updatedAt: new Date(t0).toISOString(),
|
||||
});
|
||||
await expect(refreshManagedCredential(ctxAt(t0 + 2000), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect((await rig.row()).refreshFailedAt).toBeDefined();
|
||||
await rig.stores[0]!.upsertLinkedIdentity({
|
||||
accountId: rig.accountId, provider, providerUserId: relinkSeed.providerUserId, scopes: ["identity:read"], profileJson: {},
|
||||
accessTokenEncrypted: rig.custody.encrypt("access-s"), refreshTokenEncrypted: rig.custody.encrypt("refresh-s"),
|
||||
tokenExpiresAt: new Date(t0 + 3000).toISOString(), createdAt: relinkSeed.createdAt, updatedAt: new Date(t0 + 2500).toISOString(),
|
||||
});
|
||||
expect((await rig.row()).refreshFailedAt).toBeUndefined();
|
||||
});
|
||||
|
||||
it("cross-process failed-refresh marker: stamped with the time of the failure, so a slow failure does not eat the backoff", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = "server_error";
|
||||
const t0 = Date.now();
|
||||
// The provider call takes 9 s of the clock's time: the failure is known at t0 + 9 s, not at t0.
|
||||
const slowClock = () => t0 + (endpoint.calls > 0 ? 9_000 : 0);
|
||||
const ctx = (store: HeimdallStore, clock: () => number) => ({ config: rig.config, store, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), clock });
|
||||
const snapshot = await rig.row();
|
||||
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[0]!, slowClock), snapshot)).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect((await rig.row()).refreshFailedAt).toBe(new Date(t0 + 9_000).toISOString());
|
||||
|
||||
// 51 s after the failure, 60 s after the attempt began: still inside the backoff.
|
||||
const other = rig.stores[rig.stores.length - 1]!;
|
||||
await expect(refreshManagedCredential(ctx(other, () => t0 + MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS), snapshot)).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
});
|
||||
|
||||
it("cross-process failed-refresh marker: a failure after the provider answered still leaves the marker (the provider may have consumed the token)", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
const snapshot = await rig.row();
|
||||
const throwingCustody = {
|
||||
...rig.custody,
|
||||
encrypt: (plaintext: string) => {
|
||||
if (plaintext === "access-1") throw new Error("CANARY custody encrypt failed");
|
||||
return rig.custody.encrypt(plaintext);
|
||||
},
|
||||
};
|
||||
const ctx = (store: HeimdallStore, tokenCustody: typeof rig.custody) => ({ config: rig.config, store, tokenCustody, oauthRuntimes: createOAuthRuntimeRegistry() });
|
||||
|
||||
const failure = await refreshManagedCredential(ctx(rig.stores[0]!, throwingCustody), snapshot).then(() => undefined, (error: unknown) => error);
|
||||
expect(failure).toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(String(failure) + JSON.stringify(failure)).not.toContain("CANARY");
|
||||
expect(endpoint.calls).toBe(1);
|
||||
const marked = await rig.row();
|
||||
expect(marked.refreshFailedAt).toBeDefined();
|
||||
expect(marked.refreshTokenEncrypted).toBe(snapshot.refreshTokenEncrypted);
|
||||
|
||||
// Another process inside the backoff does not present the old token again.
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[rig.stores.length - 1]!, rig.custody), snapshot)).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
});
|
||||
|
||||
it.skipIf(!live)("cross-process failed-refresh marker: a rotation the database refuses to write still leaves the marker", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
const snapshot = await rig.row();
|
||||
const db = new Pool({ connectionString: rig.databaseUrl!, max: 1 });
|
||||
db.on("error", () => undefined);
|
||||
try {
|
||||
await db.query(`CREATE FUNCTION refuse_rotation() RETURNS trigger AS $$ BEGIN RAISE EXCEPTION 'CANARY rotation write refused'; END $$ LANGUAGE plpgsql`);
|
||||
await db.query(`CREATE TRIGGER refuse_rotation BEFORE UPDATE ON linked_identities FOR EACH ROW WHEN (NEW.access_token_encrypted IS DISTINCT FROM OLD.access_token_encrypted) EXECUTE FUNCTION refuse_rotation()`);
|
||||
const ctx = (store: HeimdallStore) => ({ config: rig.config, store, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry() });
|
||||
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[0]!), snapshot)).rejects.toThrow();
|
||||
expect(endpoint.calls).toBe(1);
|
||||
const marked = await rig.row();
|
||||
expect(marked.refreshFailedAt).toBeDefined();
|
||||
if (providerCatalog[provider].rotatesRefreshTokens) {
|
||||
// The provider consumed the token: nothing replayable is left on the row, so the backoff ending presents nothing.
|
||||
expect(marked.refreshTokenEncrypted).toBeUndefined();
|
||||
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[rig.stores.length - 1]!), snapshot)).resolves.toBeDefined();
|
||||
const afterBackoff = { ...ctx(rig.stores[0]!), clock: () => Date.now() + 5 * 60_000 };
|
||||
await expect(refreshManagedCredential(afterBackoff, snapshot)).resolves.toBeDefined();
|
||||
expect(endpoint.calls).toBe(1);
|
||||
} else {
|
||||
// A non-rotating provider keeps the token valid: a transient write failure must not strand the link.
|
||||
expect(marked.refreshTokenEncrypted).toBe(snapshot.refreshTokenEncrypted);
|
||||
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[rig.stores.length - 1]!), snapshot)).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
await db.query("DROP TRIGGER refuse_rotation ON linked_identities");
|
||||
// The fake endpoint rotates on every refresh; Twitch does not, so its answer left refresh-0 valid.
|
||||
endpoint.live = "refresh-0";
|
||||
const afterBackoff = { ...ctx(rig.stores[0]!), clock: () => Date.now() + 5 * 60_000 };
|
||||
const outcome = await refreshManagedCredential(afterBackoff, snapshot);
|
||||
expect(outcome.kind).toBe("current");
|
||||
expect(endpoint.calls).toBe(2);
|
||||
}
|
||||
} finally {
|
||||
await db.end();
|
||||
}
|
||||
});
|
||||
|
||||
it("cross-process failed-refresh marker: a writer's clock skewed by under the backoff still holds the reader off, and by the backoff or more does not", timeout, async () => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = "server_error";
|
||||
const t0 = Date.now();
|
||||
const ctxAt = (at: number) => ({ config: rig.config, store: rig.stores[0]!, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry(), clock: () => at });
|
||||
await expect(refreshManagedCredential(ctxAt(t0), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
|
||||
// The marker is in this reader's future: a writer ahead of it. A bounded wait, not a refusal for as long as the skew.
|
||||
await expect(refreshManagedCredential(ctxAt(t0 - MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS + 1), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(1);
|
||||
await expect(refreshManagedCredential(ctxAt(t0 - MANAGED_CREDENTIAL_REFRESH_BACKOFF_MS), await rig.row())).rejects.toBeInstanceOf(ManagedCredentialRefreshFailed);
|
||||
expect(endpoint.calls).toBe(2);
|
||||
});
|
||||
|
||||
it("a snapshot taken before another caller's refresh does not decide: the locked row does", timeout, async () => {
|
||||
|
|
@ -486,6 +680,38 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
{ eventType: "managed_credential_revoked", payload: { provider, reason: "rotation_missing" } },
|
||||
]);
|
||||
});
|
||||
|
||||
it.skipIf(!live).each(["no_refresh_token", "empty_refresh_token"] as const)(
|
||||
"rotation-fails-closed: when the revoke the provider's answer called for cannot be written (%s), the marker is still left",
|
||||
timeout,
|
||||
async (mode) => {
|
||||
const rig = await makeRig(provider);
|
||||
const endpoint = installTokenEndpoint(provider, "refresh-0");
|
||||
endpoint.mode = mode;
|
||||
const snapshot = await rig.row();
|
||||
const db = new Pool({ connectionString: rig.databaseUrl!, max: 1 });
|
||||
db.on("error", () => undefined);
|
||||
try {
|
||||
await db.query(`CREATE FUNCTION refuse_revoke() RETURNS trigger AS $$ BEGIN RAISE EXCEPTION 'CANARY revoke write refused'; END $$ LANGUAGE plpgsql`);
|
||||
await db.query(`CREATE TRIGGER refuse_revoke BEFORE UPDATE ON linked_identities FOR EACH ROW WHEN (NEW.access_token_encrypted IS DISTINCT FROM OLD.access_token_encrypted) EXECUTE FUNCTION refuse_revoke()`);
|
||||
const ctx = (store: HeimdallStore) => ({ config: rig.config, store, tokenCustody: rig.custody, oauthRuntimes: createOAuthRuntimeRegistry() });
|
||||
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[0]!), snapshot)).rejects.toThrow();
|
||||
expect(endpoint.calls).toBe(1);
|
||||
const marked = await rig.row();
|
||||
expect(marked.refreshFailedAt).toBeDefined();
|
||||
// The provider consumed the token: nothing replayable is left on the row, so the backoff ending presents nothing.
|
||||
expect(marked.refreshTokenEncrypted).toBeUndefined();
|
||||
|
||||
await expect(refreshManagedCredential(ctx(rig.stores[rig.stores.length - 1]!), snapshot)).resolves.toBeDefined();
|
||||
const afterBackoff = { ...ctx(rig.stores[0]!), clock: () => Date.now() + 5 * 60_000 };
|
||||
await expect(refreshManagedCredential(afterBackoff, snapshot)).resolves.toBeDefined();
|
||||
expect(endpoint.calls).toBe(1);
|
||||
} finally {
|
||||
await db.end();
|
||||
}
|
||||
}
|
||||
);
|
||||
} else {
|
||||
it.each(["no_refresh_token", "empty_refresh_token"] as const)("a response with %s keeps the old one for a non-rotating provider", timeout, async (mode) => {
|
||||
const rig = await makeRig(provider);
|
||||
|
|
@ -531,6 +757,7 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
tokenExpiresAt: past,
|
||||
scopes: locked.scopes,
|
||||
updatedAt: past,
|
||||
consumedRefreshToken: false,
|
||||
}));
|
||||
expect((await rig.resolve()).statusCode).toBe(200);
|
||||
expect(endpoint.calls).toBe(2);
|
||||
|
|
@ -579,17 +806,19 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
|
||||
async function flow(rig: Rig, provider: "joystick" | "twitch" | "youtube", mode: "connect" | "sign_in") {
|
||||
const app = rig.apps[0]!;
|
||||
const start = await app.inject({ method: "POST", url: `/v1/oauth/${provider}/start`, payload: { appSlug: "streampixels", mode, returnTo, ...(mode === "connect" ? { connection: { kind: "creator", targetId: "creator-1" } } : {}) } });
|
||||
const start = await app.inject({ method: "POST", url: `/v1/oauth/${provider}/start`, headers: mode === "connect" ? { "x-heimdall-app-secret": "streampixels-secret" } : {}, payload: { appSlug: "streampixels", mode, returnTo, ...(mode === "connect" ? { connection: { kind: "creator", targetId: "creator-1" } } : {}) } });
|
||||
expect(start.statusCode).toBe(201);
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/${provider}/callback?code=c&state=${encodeURIComponent(start.json().stateToken as string)}`,
|
||||
url: `/v1/oauth/${provider}/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBe(201);
|
||||
const redeem = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/apps/streampixels/auth-completions/redeem",
|
||||
payload: { completionCode: callback.json().completion.code as string },
|
||||
payload: { completionCode: callback.json().completion.code as string, ...(mode === "connect" ? { targetId: "creator-1" } : {}) },
|
||||
});
|
||||
expect(redeem.statusCode).toBe(201);
|
||||
return { callback, redeem };
|
||||
|
|
@ -630,12 +859,15 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
const start = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/joystick/start",
|
||||
headers: { "x-heimdall-app-secret": "streampixels-secret" },
|
||||
payload: { appSlug: "streampixels", mode: "connect", returnTo, connection: { kind: "creator", targetId: "creator-1" } },
|
||||
});
|
||||
expect(start.statusCode).toBe(201);
|
||||
const flow = await launchFlow(app, start.json());
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(start.json().stateToken as string)}`,
|
||||
url: `/v1/oauth/joystick/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie },
|
||||
});
|
||||
expect(callback.statusCode).toBeGreaterThanOrEqual(400);
|
||||
expect(callback.body).not.toContain("tok-access");
|
||||
|
|
@ -705,6 +937,7 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
tokenExpiresAt: "2999-01-01T00:00:00.000Z",
|
||||
scopes: ["a", "b"],
|
||||
updatedAt: "2999-01-02T00:00:00.000Z",
|
||||
consumedRefreshToken: false,
|
||||
}));
|
||||
expect(rotated).toEqual({
|
||||
...before,
|
||||
|
|
@ -788,6 +1021,7 @@ for (const { kind, live } of rigKinds) describe.skipIf(live && !adminUrl)(`manag
|
|||
tokenExpiresAt: new Date(Date.now() + 3600_000).toISOString(),
|
||||
scopes: locked.scopes,
|
||||
updatedAt: new Date().toISOString(),
|
||||
consumedRefreshToken: false,
|
||||
};
|
||||
})
|
||||
)
|
||||
|
|
@ -1066,6 +1300,7 @@ describe("refresh answer classification", () => {
|
|||
tokenExpiresAt: new Date().toISOString(),
|
||||
scopes: locked.scopes,
|
||||
updatedAt: new Date().toISOString(),
|
||||
consumedRefreshToken: false,
|
||||
})))!;
|
||||
const calls = answer(JSON.stringify({ access_token: "access-1", refresh_token: "refresh-1", ...extra }), 200);
|
||||
let skew = 0;
|
||||
|
|
@ -1098,6 +1333,7 @@ describe("refresh answer classification", () => {
|
|||
tokenExpiresAt: dueAt,
|
||||
scopes: ["s"],
|
||||
updatedAt: dueAt,
|
||||
consumedRefreshToken: false,
|
||||
}));
|
||||
const calls = answer(JSON.stringify({ access_token: "access-2", expires_in: 3600 }), 200);
|
||||
await refreshManagedCredential(ctxFor(store), snapshot);
|
||||
|
|
|
|||
158
tests/oauth-flow.ts
Normal file
158
tests/oauth-flow.ts
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
import { expect } from "vitest";
|
||||
import { type FastifyInstance } from "fastify";
|
||||
import { type HeimdallConfig } from "../src/config.js";
|
||||
import { entitlementFacts } from "../src/facts.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { decodeJwt } from "../src/signing.js";
|
||||
|
||||
export function createTestConfig(): HeimdallConfig {
|
||||
return {
|
||||
serviceName: "heimdall",
|
||||
host: "127.0.0.1",
|
||||
port: 4100,
|
||||
workspaceRoot: "E:/Projects/Heimdall",
|
||||
dataRoot: "E:/Projects/Heimdall/.heimdall-data",
|
||||
cultCachePath: "E:/Projects/Heimdall/.heimdall-data/cultcache/heimdall.service.cc",
|
||||
publicBaseUrl: "https://heimdall.gamecult.org",
|
||||
issuer: "https://heimdall.gamecult.org",
|
||||
daemonId: "yggdrasil-heimdall",
|
||||
idunnRudpHealth: undefined,
|
||||
idunnHealthContract: "heimdall.cultnet-rudp-provider-health",
|
||||
providerHealthIdentityPath: "E:/Projects/Heimdall/.heimdall-data/provider-health-identity.cc",
|
||||
sessionTtlSeconds: 3600,
|
||||
refreshTtlSeconds: 60 * 60 * 24 * 30,
|
||||
stateTtlSeconds: 600,
|
||||
completionTtlSeconds: 300,
|
||||
bootstrapSigningPrivateKeyOnMissing: false,
|
||||
tokenEncryptionKeyBase64: Buffer.alloc(32, 7).toString("base64"),
|
||||
appSharedSecrets: {
|
||||
streampixels: "streampixels-secret",
|
||||
repixelizer: "repixelizer-secret",
|
||||
bifrost: "bifrost-secret",
|
||||
},
|
||||
appBackendCallbacks: {
|
||||
bifrost: ["https://bifrost.gamecult.org/auth/heimdall/callback"],
|
||||
repixelizer: ["https://repixelizer.gamecult.org/api/auth/heimdall/callback"],
|
||||
},
|
||||
storage: {
|
||||
backend: "memory",
|
||||
applySchemaOnStartup: true,
|
||||
},
|
||||
providers: {
|
||||
discord: { clientId: "discord-client", clientSecret: "discord-secret" },
|
||||
patreon: { clientId: "patreon-client", clientSecret: "patreon-secret" },
|
||||
github: { clientId: "github-client", clientSecret: "github-secret" },
|
||||
twitch: { clientId: "twitch-client", clientSecret: "twitch-secret" },
|
||||
youtube: { clientId: "youtube-client", clientSecret: "youtube-secret" },
|
||||
spotify: { clientId: "spotify-client", clientSecret: "spotify-secret" },
|
||||
joystick: { clientId: "joystick-client", clientSecret: "joystick-secret" },
|
||||
google: { clientId: "google-client", clientSecret: "google-secret" },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function createMockDiscordRuntime(): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return {
|
||||
accessToken: "discord-access-token",
|
||||
refreshToken: "discord-refresh-token",
|
||||
tokenType: "Bearer",
|
||||
scope: ["identify", "guilds.members.read"],
|
||||
expiresAt: "2026-04-26T13:00:00.000Z",
|
||||
raw: { source: "test" },
|
||||
};
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return {
|
||||
provider: "discord",
|
||||
providerUserId: "discord-user-123",
|
||||
username: "meta",
|
||||
displayName: "Meta",
|
||||
primaryEmail: "meta@gamecult.org",
|
||||
profile: { id: "discord-user-123", username: "meta" },
|
||||
};
|
||||
},
|
||||
async evaluateEntitlements({ callback }) {
|
||||
return {
|
||||
facts: [entitlementFacts.appAccess],
|
||||
snapshots: [
|
||||
{
|
||||
accountId: callback.accountId,
|
||||
provider: "discord",
|
||||
scope: "repixelizer:discord_role_access:gamecult-guild",
|
||||
evaluatedAt: "2026-04-26T12:00:00.000Z",
|
||||
isAllowed: true,
|
||||
reasonCode: "matched_role",
|
||||
reasonDetail: "Matched Repixelizer access role.",
|
||||
rawSummaryJson: {
|
||||
guildId: "gamecult-guild",
|
||||
matchedRoles: ["role-repixelizer"],
|
||||
},
|
||||
},
|
||||
],
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** What a start returns that the browser needs: the launch URL, whose query carries the signed state. */
|
||||
export interface StartBody {
|
||||
authorizationUrl: string;
|
||||
}
|
||||
|
||||
export function stateOf(start: StartBody): string {
|
||||
return new URL(start.authorizationUrl).searchParams.get("state") ?? "";
|
||||
}
|
||||
|
||||
export interface LaunchedFlow {
|
||||
state: string;
|
||||
/** The `name=value` pair a browser sends back to the callback. */
|
||||
cookie: string;
|
||||
}
|
||||
|
||||
export function setCookieOf(response: { headers: Record<string, unknown> }): string[] {
|
||||
return [response.headers["set-cookie"]].flat().filter((value): value is string => typeof value === "string");
|
||||
}
|
||||
|
||||
async function followLaunch(app: FastifyInstance, state: string): Promise<LaunchedFlow & { providerUrl: URL }> {
|
||||
const provider = decodeJwt(state).payload.provider as string;
|
||||
let response = await app.inject({ method: "GET", url: `/v1/oauth/${provider}/launch?state=${encodeURIComponent(state)}` });
|
||||
if (response.statusCode === 200) {
|
||||
// Heimdall's ask (managed custody): the person says Continue, with the cookie the ask set.
|
||||
const asked = setCookieOf(response).find((value) => value.startsWith("__Host-heimdall-ask-"));
|
||||
expect(asked, "the ask sets its own cookie").toBeDefined();
|
||||
response = await app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/oauth/${provider}/consent`,
|
||||
headers: { "content-type": "application/x-www-form-urlencoded", cookie: (asked as string).split(";")[0] as string },
|
||||
payload: new URLSearchParams({ state, decision: "continue" }).toString(),
|
||||
});
|
||||
}
|
||||
expect(response.statusCode, "launch").toBe(302);
|
||||
const set = setCookieOf(response).find((value) => value.startsWith("__Host-heimdall-oauth-"));
|
||||
expect(set, "launch sets the binding cookie").toBeDefined();
|
||||
return { state, cookie: (set as string).split(";")[0] as string, providerUrl: new URL(response.headers.location as string) };
|
||||
}
|
||||
|
||||
/** What a browser does with a state it was handed: open the launch hop for the state's provider and keep the cookie it sets. */
|
||||
export async function launchState(app: FastifyInstance, state: string): Promise<LaunchedFlow> {
|
||||
const { providerUrl: _providerUrl, ...flow } = await followLaunch(app, state);
|
||||
return flow;
|
||||
}
|
||||
|
||||
/** Drives what a user's browser does after a start: follow authorizationUrl to the launch hop and keep its cookie. */
|
||||
export function launchFlow(app: FastifyInstance, start: StartBody): Promise<LaunchedFlow> {
|
||||
return launchState(app, stateOf(start));
|
||||
}
|
||||
|
||||
/** The launch hop's answer in full: the cookie the browser keeps and the provider URL it is redirected to. */
|
||||
export async function launchWithRedirect(app: FastifyInstance, start: StartBody): Promise<LaunchedFlow & { url: URL }> {
|
||||
const { providerUrl, ...flow } = await followLaunch(app, stateOf(start));
|
||||
return { ...flow, url: providerUrl };
|
||||
}
|
||||
|
||||
/** The provider URL a browser is redirected to once it has followed authorizationUrl through the launch hop. */
|
||||
export async function providerRedirect(app: FastifyInstance, start: StartBody): Promise<URL> {
|
||||
return (await followLaunch(app, stateOf(start))).providerUrl;
|
||||
}
|
||||
596
tests/oauth-state-binding.test.ts
Normal file
596
tests/oauth-state-binding.test.ts
Normal file
|
|
@ -0,0 +1,596 @@
|
|||
import { generateKeyPairSync, randomUUID } from "node:crypto";
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { type FastifyInstance } from "fastify";
|
||||
import { buildApp, getHeimdallRuntimeContext, startOAuthFlow } from "../src/app.js";
|
||||
import { resolveAppCaller } from "../src/app-caller.js";
|
||||
import { decodeJwt, signJwt } from "../src/signing.js";
|
||||
import { OAUTH_STATE_PRUNE_BATCH, OAUTH_STATE_PRUNE_MARGIN_MS, OAUTH_STATE_SKEW_MS } from "../src/store/types.js";
|
||||
import { createMockDiscordRuntime, createTestConfig, launchFlow, setCookieOf, stateOf } from "./oauth-flow.js";
|
||||
|
||||
// Heimdall's OAuth states complete once, only in the browser that launched
|
||||
// them (finding state-replay). Soul's attack: a Bifrost state is readable in
|
||||
// the URL the victim's browser is sent to, so an attacker who sees it opens it
|
||||
// in their own browser, finishes the provider login as themselves, and hands
|
||||
// the victim the resulting completion code.
|
||||
|
||||
const apps: FastifyInstance[] = [];
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
while (apps.length) {
|
||||
await apps.pop()?.close();
|
||||
}
|
||||
});
|
||||
|
||||
const victimAttempt = "VICTIM-ATTEMPT-NONCE";
|
||||
const bifrostReturn = `https://bifrost.gamecult.org/auth/heimdall/complete?attempt=${victimAttempt}`;
|
||||
|
||||
async function newApp() {
|
||||
const app = await buildApp({ config: createTestConfig(), oauthRuntimes: { discord: createMockDiscordRuntime() } });
|
||||
apps.push(app);
|
||||
return app;
|
||||
}
|
||||
|
||||
async function bifrostStart(app: FastifyInstance, extra: Record<string, unknown> = {}) {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
headers: { "x-heimdall-app-secret": "bifrost-secret" },
|
||||
payload: { appSlug: "bifrost", mode: "sign_in", returnTo: bifrostReturn, handoff: { kind: "browser_completion" }, ...extra },
|
||||
});
|
||||
expect(response.statusCode).toBe(201);
|
||||
return response.json() as { authorizationUrl: string };
|
||||
}
|
||||
|
||||
function launchUrl(start: { authorizationUrl: string }): string {
|
||||
const url = new URL(start.authorizationUrl);
|
||||
return `${url.pathname}${url.search}`;
|
||||
}
|
||||
|
||||
function callback(app: FastifyInstance, state: string, cookie?: string, query = "code=attacker-code") {
|
||||
return app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?${query}&state=${encodeURIComponent(state)}`,
|
||||
...(cookie ? { headers: { cookie } } : {}),
|
||||
});
|
||||
}
|
||||
|
||||
describe("OAuth state binding", () => {
|
||||
it("Soul's replay fails: one state, at most one completion code, and only for the browser that launched it", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app);
|
||||
const state = stateOf(start);
|
||||
|
||||
const victim = await launchFlow(app, start);
|
||||
|
||||
// The attacker holds the same state. A second launch yields no cookie and no redirect.
|
||||
const attackerLaunch = await app.inject({ method: "GET", url: launchUrl(start) });
|
||||
expect(attackerLaunch.statusCode).toBe(400);
|
||||
expect(attackerLaunch.json()).toEqual({ error: "state_already_launched" });
|
||||
expect(setCookieOf(attackerLaunch)).toEqual([]);
|
||||
expect(attackerLaunch.headers.location).toBeUndefined();
|
||||
|
||||
// Without the cookie the callback refuses and mints nothing.
|
||||
const attackerCallback = await callback(app, state);
|
||||
expect(attackerCallback.statusCode).toBe(400);
|
||||
expect(attackerCallback.json()).toEqual({ error: "state_not_bound" });
|
||||
expect(attackerCallback.body).not.toContain("completion");
|
||||
|
||||
// The victim's callback still completes, once.
|
||||
const victimCallback = await callback(app, state, victim.cookie, "code=victim-code");
|
||||
expect(victimCallback.statusCode).toBe(201);
|
||||
const completionCode = victimCallback.json().completion.code as string;
|
||||
const redeem = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/apps/bifrost/auth-completions/redeem",
|
||||
payload: { completionCode },
|
||||
});
|
||||
expect(redeem.statusCode).toBe(201);
|
||||
expect(redeem.json()).toEqual(expect.objectContaining({ status: "success", appSlug: "bifrost" }));
|
||||
|
||||
const second = await callback(app, state, victim.cookie, "code=victim-code");
|
||||
expect(second.statusCode).toBe(400);
|
||||
expect(second.json()).toEqual({ error: "state_already_used" });
|
||||
expect(second.body).not.toContain("completion");
|
||||
});
|
||||
|
||||
it("a stranger's callback needs no launch to be refused: no cookie, no completion code", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app);
|
||||
|
||||
const response = await callback(app, stateOf(start));
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json()).toEqual({ error: "state_not_bound" });
|
||||
expect(response.body).not.toContain("completion");
|
||||
});
|
||||
|
||||
it("a cookie for another flow, another key, another type, or the wrong lifetime does not bind", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const own = await bifrostStart(app);
|
||||
const attackerFlow = await app.inject({
|
||||
method: "POST",
|
||||
url: "/v1/oauth/discord/start",
|
||||
payload: { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" },
|
||||
});
|
||||
const attackerStart = attackerFlow.json() as { authorizationUrl: string };
|
||||
const attackerCookie = (await launchFlow(app, attackerStart)).cookie;
|
||||
const ownState = stateOf(own);
|
||||
const ownJti = decodeJwt(ownState).payload.jti as string;
|
||||
const name = `__Host-heimdall-oauth-${ownJti}`;
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
const binding = (overrides: Record<string, unknown>, keys = ctx.keys) =>
|
||||
signJwt({ typ: "heimdall_oauth_binding", iss: ctx.config.issuer, jti: ownJti, iat: now, exp: now + 300, ...overrides }, keys);
|
||||
const foreignKeys = (() => {
|
||||
const pair = generateKeyPairSync("ed25519");
|
||||
return { ...ctx.keys, privateKey: pair.privateKey, publicKey: pair.publicKey };
|
||||
})();
|
||||
|
||||
const forged: Record<string, string> = {
|
||||
"another flow's binding under this flow's cookie name": `${name}=${attackerCookie.split("=")[1]}`,
|
||||
"a binding signed with a different key": `${name}=${binding({}, foreignKeys)}`,
|
||||
"a binding for a different jti": `${name}=${binding({ jti: "someone-else" })}`,
|
||||
"a binding of another type": `${name}=${binding({ typ: "heimdall_oauth_state" })}`,
|
||||
"a binding from another issuer": `${name}=${binding({ iss: "https://elsewhere.example" })}`,
|
||||
"an expired binding": `${name}=${binding({ exp: now - 5 })}`,
|
||||
"the state token used as the cookie": `${name}=${ownState}`,
|
||||
"a binding whose exp is a string": `${name}=${binding({ exp: String(now + 300) })}`,
|
||||
"an empty cookie": `${name}=`,
|
||||
};
|
||||
for (const [label, cookie] of Object.entries(forged)) {
|
||||
const response = await callback(app, ownState, cookie);
|
||||
expect(response.statusCode, label).toBe(400);
|
||||
expect(response.json(), label).toEqual({ error: "state_not_bound" });
|
||||
}
|
||||
|
||||
// A correctly signed binding for this jti is the one thing that binds.
|
||||
const good = await callback(app, ownState, `${name}=${binding({})}`);
|
||||
expect(good.statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("the cookie is checked before the state is consumed: a stranger cannot burn or deny the victim's flow", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const attempt = await ctx.store.createAuthAttempt({
|
||||
handle: "attempt-1",
|
||||
appSlug: "repixelizer",
|
||||
provider: "discord",
|
||||
mode: "sign_in",
|
||||
returnTo: "https://repixelizer.gamecult.org/app/",
|
||||
createdAt: new Date().toISOString(),
|
||||
expiresAt: new Date(Date.now() + 600_000).toISOString(),
|
||||
});
|
||||
const caller = resolveAppCaller(ctx.config, "repixelizer", { "x-heimdall-app-secret": "repixelizer-secret" });
|
||||
const started = await startOAuthFlow(
|
||||
ctx,
|
||||
"discord",
|
||||
caller,
|
||||
{ appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/", handoff: { kind: "browser_completion" } },
|
||||
{ trustedBrowserAttemptId: attempt.handle }
|
||||
);
|
||||
expect(started.statusCode).toBe(201);
|
||||
const start = started.body as unknown as { authorizationUrl: string };
|
||||
const victim = await launchFlow(app, start);
|
||||
|
||||
// A cookieless provider error, which would deny the attempt, and a cookieless code: both refused.
|
||||
for (const query of ["error=access_denied", "code=attacker-code", ""]) {
|
||||
const stranger = await callback(app, victim.state, undefined, query);
|
||||
expect(stranger.statusCode, query).toBe(400);
|
||||
expect(stranger.json(), query).toEqual({ error: "state_not_bound" });
|
||||
}
|
||||
|
||||
// The state is still unclaimed, so the launcher's cookie still completes it...
|
||||
const response = await callback(app, victim.state, victim.cookie, "code=victim-code");
|
||||
expect(response.statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("a callback with no binding denies the attempt its state names, once, and never a completed one", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const make = async (handle: string) => {
|
||||
await ctx.store.createAuthAttempt({
|
||||
handle,
|
||||
appSlug: "repixelizer",
|
||||
provider: "discord",
|
||||
mode: "sign_in",
|
||||
returnTo: "https://repixelizer.gamecult.org/app/",
|
||||
createdAt: new Date().toISOString(),
|
||||
expiresAt: new Date(Date.now() + 600_000).toISOString(),
|
||||
});
|
||||
const caller = resolveAppCaller(ctx.config, "repixelizer", { "x-heimdall-app-secret": "repixelizer-secret" });
|
||||
const started = await startOAuthFlow(
|
||||
ctx,
|
||||
"discord",
|
||||
caller,
|
||||
{ appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/", handoff: { kind: "browser_completion" } },
|
||||
{ trustedBrowserAttemptId: handle }
|
||||
);
|
||||
return started.body as unknown as { authorizationUrl: string };
|
||||
};
|
||||
|
||||
// Lapsed cookie: the launcher launched, then its cookie is gone at the callback.
|
||||
const lapsed = await make("lapsed");
|
||||
await launchFlow(app, lapsed);
|
||||
const refused = await callback(app, stateOf(lapsed), undefined, "code=c");
|
||||
expect(refused.json()).toEqual({ error: "state_not_bound" });
|
||||
const denied = await ctx.store.findAuthAttempt("repixelizer", "lapsed");
|
||||
expect(denied?.status).toBe("denied");
|
||||
expect(denied?.denialCode).toBe("state_not_bound");
|
||||
|
||||
// A completed attempt stays completed under a later cookieless callback.
|
||||
const done = await make("done");
|
||||
const launched = await launchFlow(app, done);
|
||||
expect((await callback(app, launched.state, launched.cookie, "code=c")).statusCode).toBe(201);
|
||||
await callback(app, launched.state, undefined, "code=c");
|
||||
expect(["completed", "consumed"]).toContain((await ctx.store.findAuthAttempt("repixelizer", "done"))?.status);
|
||||
});
|
||||
|
||||
it("a state with no jti is refused as invalid and names no attempt to deny", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const original = decodeJwt(stateOf(await bifrostStart(app))).payload;
|
||||
const { jti: _jti, ...rest } = original;
|
||||
const token = signJwt(rest, ctx.keys);
|
||||
const response = await callback(app, token, undefined, "code=c");
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json()).toEqual({ error: "invalid_state" });
|
||||
});
|
||||
|
||||
describe("a browser refused for its binding gets a page back to the app, not bare JSON", () => {
|
||||
const html = { accept: "text/html" };
|
||||
const get = (app: FastifyInstance, url: string, cookie?: string) =>
|
||||
app.inject({ method: "GET", url, headers: { ...html, ...(cookie ? { cookie } : {}) } });
|
||||
|
||||
it("on a cookieless callback, a lapsed cookie and a reloaded launch", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app);
|
||||
const state = stateOf(start);
|
||||
|
||||
const reloadBeforeLaunch = await get(app, `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(state)}`);
|
||||
expect(reloadBeforeLaunch.statusCode).toBe(400);
|
||||
expect(reloadBeforeLaunch.headers["content-type"]).toContain("text/html");
|
||||
expect(reloadBeforeLaunch.body).toContain("state_not_bound");
|
||||
expect(reloadBeforeLaunch.body).toContain("https://bifrost.gamecult.org/auth/heimdall/complete");
|
||||
|
||||
const victim = await launchFlow(app, start);
|
||||
const reloaded = await get(app, launchUrl(start));
|
||||
expect(reloaded.statusCode).toBe(400);
|
||||
expect(reloaded.headers["content-type"]).toContain("text/html");
|
||||
expect(reloaded.body).toContain("state_already_launched");
|
||||
expect(setCookieOf(reloaded)).toEqual([]);
|
||||
|
||||
// Handoff reload: the page after a completed callback, loaded again.
|
||||
expect((await get(app, `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(victim.state)}`, victim.cookie)).statusCode).toBeLessThan(300);
|
||||
const reload = await get(app, `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(victim.state)}`, victim.cookie);
|
||||
expect(reload.statusCode).toBe(400);
|
||||
expect(reload.headers["content-type"]).toContain("text/html");
|
||||
expect(reload.body).toContain("state_already_used");
|
||||
});
|
||||
|
||||
it("never links to an origin the app does not own, and JSON stays JSON without Accept", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const original = decodeJwt(stateOf(await bifrostStart(app))).payload;
|
||||
const token = signJwt({ ...original, return_to: "https://evil.example/steal" }, ctx.keys);
|
||||
const evil = await get(app, `/v1/oauth/discord/callback?code=c&state=${encodeURIComponent(token)}`);
|
||||
expect(evil.statusCode).toBe(400);
|
||||
expect(evil.json()).toEqual({ error: "state_not_bound" });
|
||||
expect(evil.body).not.toContain("evil.example");
|
||||
|
||||
const plain = await callback(app, stateOf(await bifrostStart(app)));
|
||||
expect(plain.json()).toEqual({ error: "state_not_bound" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("use-record retention", () => {
|
||||
// Only Date is faked: the routes stamp each claim with the clock, and the rest of the event loop stays real.
|
||||
const clockAt = (ms: number) => vi.useFakeTimers({ toFake: ["Date"], now: ms });
|
||||
const seedStale = async (app: FastifyInstance, count: number, beforeMs: number) => {
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
for (let i = 0; i < count; i += 1) {
|
||||
const expiresAt = new Date(beforeMs - i).toISOString();
|
||||
await ctx.store.claimOAuthStateUse({ jti: `stale-${i}`, phase: "launch", appSlug: "bifrost", usedAt: expiresAt, expiresAt });
|
||||
}
|
||||
};
|
||||
|
||||
it("later claims never prune a live state: its launch and callback replays stay refused", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app);
|
||||
const victim = await launchFlow(app, start);
|
||||
const exp = decodeJwt(victim.state).payload.exp as number;
|
||||
|
||||
// More stale records than one batch, then another user's flow, whose claims do the pruning.
|
||||
const staleBefore = Date.now() - OAUTH_STATE_SKEW_MS - OAUTH_STATE_PRUNE_MARGIN_MS;
|
||||
await seedStale(app, OAUTH_STATE_PRUNE_BATCH + 10, staleBefore);
|
||||
await launchFlow(app, await bifrostStart(app));
|
||||
|
||||
const launchReplay = await app.inject({ method: "GET", url: launchUrl(start) });
|
||||
expect(launchReplay.json()).toEqual({ error: "state_already_launched" });
|
||||
|
||||
// The callback is not pruned either: it completes once, and its replay is refused.
|
||||
expect((await callback(app, victim.state, victim.cookie, "code=victim-code")).statusCode).toBe(201);
|
||||
expect((await callback(app, victim.state, victim.cookie, "code=victim-code")).json()).toEqual({ error: "state_already_used" });
|
||||
|
||||
// Inside exp + skew the state still verifies, and the record still refuses it.
|
||||
clockAt((exp + OAUTH_STATE_SKEW_MS / 1000 - 1) * 1000);
|
||||
await launchFlow(app, await bifrostStart(app));
|
||||
const lateReplay = await app.inject({ method: "GET", url: launchUrl(start) });
|
||||
expect(lateReplay.json()).toEqual({ error: "state_already_launched" });
|
||||
|
||||
});
|
||||
|
||||
it("once its records are pruned, an expired state is refused as state_expired, by the state and not the record", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const start = await bifrostStart(app);
|
||||
const victim = await launchFlow(app, start);
|
||||
const exp = decodeJwt(victim.state).payload.exp as number;
|
||||
|
||||
// Past exp + skew + margin the victim's launch record is prunable; a new claim removes it.
|
||||
const pruneAt = (exp + (OAUTH_STATE_SKEW_MS + OAUTH_STATE_PRUNE_MARGIN_MS) / 1000 + 1) * 1000;
|
||||
clockAt(pruneAt);
|
||||
await launchFlow(app, await bifrostStart(app));
|
||||
const record = {
|
||||
jti: decodeJwt(victim.state).payload.jti as string,
|
||||
phase: "launch" as const,
|
||||
appSlug: "bifrost" as const,
|
||||
usedAt: new Date(pruneAt).toISOString(),
|
||||
expiresAt: new Date(exp * 1000).toISOString(),
|
||||
};
|
||||
// The record is gone, as the store (not the route) would now let the claim through ...
|
||||
expect(await ctx.store.claimOAuthStateUse(record)).toBe(true);
|
||||
// ... yet the routes refuse the state itself.
|
||||
const launchReplay = await app.inject({ method: "GET", url: launchUrl(start) });
|
||||
expect(launchReplay.statusCode).toBe(400);
|
||||
expect(launchReplay.json()).toEqual({ error: "state_expired" });
|
||||
expect((await callback(app, victim.state, victim.cookie)).json()).toEqual({ error: "state_expired" });
|
||||
});
|
||||
});
|
||||
|
||||
it("a provider refusal from the launching browser still denies the attempt, once", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app);
|
||||
const victim = await launchFlow(app, start);
|
||||
|
||||
const denied = await callback(app, victim.state, victim.cookie, "error=access_denied");
|
||||
expect(denied.statusCode).toBe(400);
|
||||
expect(denied.json().error).toBe("consent_refused");
|
||||
expect(denied.json().by).toBe("provider");
|
||||
const replay = await callback(app, victim.state, victim.cookie, "error=access_denied");
|
||||
expect(replay.json()).toEqual({ error: "state_already_used" });
|
||||
});
|
||||
|
||||
// The private command plane's completeAuth answers a denied attempt with
|
||||
// attempt.denialCode as its error (private-command-plane.ts, completeAuth), so
|
||||
// these two codes are what Bifrost, Repixelizer and Ghostlight poll for.
|
||||
it.each([
|
||||
["bifrost", "https://bifrost.gamecult.org/auth/heimdall/complete?attempt=a1", "access_denied", "consent_refused"],
|
||||
["repixelizer", "https://repixelizer.gamecult.org/app/", "access_denied", "consent_refused"],
|
||||
["repixelizer", "https://repixelizer.gamecult.org/app/", "server_error", "provider_error"],
|
||||
] as const)("a %s attempt whose provider answers %s is denied with %s", async (appSlug, returnTo, providerError, denialCode) => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const attempt = await ctx.store.createAuthAttempt({
|
||||
handle: `attempt-${providerError}`,
|
||||
appSlug,
|
||||
provider: "discord",
|
||||
mode: "sign_in",
|
||||
returnTo,
|
||||
createdAt: new Date().toISOString(),
|
||||
expiresAt: new Date(Date.now() + 600_000).toISOString(),
|
||||
});
|
||||
const caller = resolveAppCaller(ctx.config, appSlug, { "x-heimdall-app-secret": `${appSlug}-secret` });
|
||||
const started = await startOAuthFlow(
|
||||
ctx,
|
||||
"discord",
|
||||
caller,
|
||||
{ appSlug, mode: "sign_in", returnTo, handoff: { kind: "browser_completion" } },
|
||||
{ trustedBrowserAttemptId: attempt.handle }
|
||||
);
|
||||
const flow = await launchFlow(app, started.body as unknown as { authorizationUrl: string });
|
||||
await callback(app, flow.state, flow.cookie, `error=${providerError}`);
|
||||
expect(await ctx.store.findAuthAttempt(appSlug, attempt.handle)).toMatchObject({ status: "denied", denialCode });
|
||||
});
|
||||
|
||||
describe("a state that is expired, foreign or tampered is refused at launch and at callback", () => {
|
||||
it.each([
|
||||
["expired beyond the skew", { exp: Math.floor(Date.now() / 1000) - 100 }, "state_expired"],
|
||||
["not yet valid", { nbf: Math.floor(Date.now() / 1000) + 100 }, "state_expired"],
|
||||
["another issuer", { iss: "https://elsewhere.example" }, "invalid_state"],
|
||||
["another provider in aud", { aud: "patreon" }, "state_provider_mismatch"],
|
||||
["another provider in provider", { provider: "patreon", aud: "patreon" }, "state_provider_mismatch"],
|
||||
["a wrong type", { typ: "heimdall_refresh" }, "invalid_state"],
|
||||
])("%s", async (_label, change, error) => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const start = await bifrostStart(app);
|
||||
const original = decodeJwt(stateOf(start)).payload;
|
||||
const token = signJwt({ ...original, ...change }, ctx.keys);
|
||||
const launch = await app.inject({ method: "GET", url: `/v1/oauth/discord/launch?state=${encodeURIComponent(token)}` });
|
||||
expect(launch.statusCode).toBe(400);
|
||||
expect(launch.json()).toEqual({ error });
|
||||
expect(setCookieOf(launch)).toEqual([]);
|
||||
|
||||
const cookie = `__Host-heimdall-oauth-${original.jti as string}=${signJwt({ typ: "heimdall_oauth_binding", iss: ctx.config.issuer, jti: original.jti, iat: 0, exp: 4_000_000_000 }, ctx.keys)}`;
|
||||
const response = await callback(app, token, cookie);
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json()).toEqual({ error });
|
||||
expect(response.body).not.toContain(token.slice(20, 60));
|
||||
});
|
||||
|
||||
it("a state inside the 30 s skew still works, as a refresh token does", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const start = await bifrostStart(app);
|
||||
const original = decodeJwt(stateOf(start)).payload;
|
||||
const token = signJwt({ ...original, exp: Math.floor(Date.now() / 1000) - 10 }, ctx.keys);
|
||||
const launch = await app.inject({ method: "GET", url: `/v1/oauth/discord/launch?state=${encodeURIComponent(token)}` });
|
||||
expect(launch.statusCode).toBe(302);
|
||||
});
|
||||
|
||||
it("a tampered signature, a malformed token and a provider that is not the route's", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app);
|
||||
const state = stateOf(start);
|
||||
const tampered = `${state.slice(0, -4)}AAAA`;
|
||||
for (const token of [tampered, "not-a-jwt", "a.b"]) {
|
||||
const launch = await app.inject({ method: "GET", url: `/v1/oauth/discord/launch?state=${encodeURIComponent(token)}` });
|
||||
expect(launch.statusCode).toBe(400);
|
||||
expect(launch.json()).toEqual({ error: "invalid_state" });
|
||||
expect(launch.body).not.toContain(token);
|
||||
}
|
||||
const wrongRoute = await app.inject({ method: "GET", url: `/v1/oauth/patreon/launch?state=${encodeURIComponent(state)}` });
|
||||
expect(wrongRoute.statusCode).toBe(400);
|
||||
expect(wrongRoute.json()).toEqual({ error: "state_provider_mismatch" });
|
||||
});
|
||||
});
|
||||
|
||||
it("the launch response and the binding cookie carry the protections the binding relies on", async () => {
|
||||
const app = await newApp();
|
||||
const start = await bifrostStart(app, { requestedScopes: ["identify", "email"] });
|
||||
const jti = decodeJwt(stateOf(start)).payload.jti as string;
|
||||
|
||||
const launch = await app.inject({ method: "GET", url: launchUrl(start) });
|
||||
expect(launch.statusCode).toBe(302);
|
||||
const cookies = setCookieOf(launch);
|
||||
expect(cookies).toHaveLength(1);
|
||||
const cookie = cookies[0] as string;
|
||||
expect(cookie.startsWith(`__Host-heimdall-oauth-${jti}=`)).toBe(true);
|
||||
const attributes = cookie.split(";").slice(1).map((part) => part.trim());
|
||||
expect(attributes).toEqual(expect.arrayContaining(["Path=/", "Secure", "HttpOnly", "SameSite=Lax"]));
|
||||
expect(attributes.some((attribute) => /^domain=/i.test(attribute))).toBe(false);
|
||||
const maxAge = Number(attributes.find((attribute) => attribute.startsWith("Max-Age="))?.slice("Max-Age=".length));
|
||||
expect(maxAge).toBeGreaterThan(0);
|
||||
expect(maxAge).toBeLessThanOrEqual(600);
|
||||
|
||||
const location = new URL(launch.headers.location as string);
|
||||
expect(location.origin + location.pathname).toBe("https://discord.com/oauth2/authorize");
|
||||
expect(location.searchParams.get("state")).toBe(stateOf(start));
|
||||
expect(location.searchParams.get("scope")).toBe("identify email");
|
||||
expect(location.searchParams.get("client_id")).toBe("discord-client");
|
||||
expect(location.searchParams.get("redirect_uri")).toBe("https://heimdall.gamecult.org/v1/oauth/discord/callback");
|
||||
expect(launch.headers["cache-control"]).toBe("no-store");
|
||||
expect(launch.headers["referrer-policy"]).toBe("no-referrer");
|
||||
|
||||
const done = await callback(app, stateOf(start), cookie.split(";")[0], "code=c");
|
||||
expect(done.statusCode).toBe(201);
|
||||
const cleared = setCookieOf(done).find((value) => value.startsWith(`__Host-heimdall-oauth-${jti}=`));
|
||||
expect(cleared).toBeDefined();
|
||||
expect(cleared).toMatch(/Max-Age=0/);
|
||||
expect(cleared?.startsWith(`__Host-heimdall-oauth-${jti}=;`)).toBe(true);
|
||||
});
|
||||
|
||||
it("a launch for a provider with no client id is 503 and burns nothing", async () => {
|
||||
const config = { ...createTestConfig(), providers: { ...createTestConfig().providers } };
|
||||
const app = await buildApp({ config, oauthRuntimes: { discord: createMockDiscordRuntime() } });
|
||||
apps.push(app);
|
||||
const start = await bifrostStart(app);
|
||||
config.providers.discord = { clientId: undefined, clientSecret: undefined } as unknown as typeof config.providers.discord;
|
||||
const refused = await app.inject({ method: "GET", url: launchUrl(start) });
|
||||
expect(refused.statusCode).toBe(503);
|
||||
expect(refused.json().error).toBe("provider_not_configured");
|
||||
expect(setCookieOf(refused)).toEqual([]);
|
||||
});
|
||||
|
||||
it("every start returns Heimdall's launch URL and no state token", async () => {
|
||||
const app = await newApp();
|
||||
for (const [headers, payload] of [
|
||||
[{}, { appSlug: "repixelizer", mode: "sign_in", returnTo: "https://repixelizer.gamecult.org/app/" }],
|
||||
[
|
||||
{ "x-heimdall-app-secret": "bifrost-secret" },
|
||||
{ appSlug: "bifrost", mode: "sign_in", returnTo: bifrostReturn },
|
||||
],
|
||||
] as const) {
|
||||
const response = await app.inject({ method: "POST", url: "/v1/oauth/discord/start", headers, payload });
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = response.json();
|
||||
expect(body.stateToken).toBeUndefined();
|
||||
expect(new URL(body.authorizationUrl).origin + new URL(body.authorizationUrl).pathname).toBe(
|
||||
"https://heimdall.gamecult.org/v1/oauth/discord/launch"
|
||||
);
|
||||
expect(body.stateExpiresAt).toEqual(expect.any(String));
|
||||
}
|
||||
});
|
||||
|
||||
it("claims the launch and the callback of a state under their own phases, until the state's expiry", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const spy = vi.spyOn(ctx.store, "claimOAuthStateUse");
|
||||
const start = await bifrostStart(app);
|
||||
const { jti, exp } = decodeJwt(stateOf(start)).payload as { jti: string; exp: number };
|
||||
|
||||
const victim = await launchFlow(app, start);
|
||||
expect((await callback(app, victim.state, victim.cookie, "code=victim-code")).statusCode).toBe(201);
|
||||
|
||||
const expiresAt = new Date(exp * 1000).toISOString();
|
||||
expect(spy.mock.calls.map(([claim]) => claim)).toEqual([
|
||||
{ jti, phase: "launch", appSlug: "bifrost", usedAt: expect.any(String), expiresAt },
|
||||
{ jti, phase: "callback", appSlug: "bifrost", usedAt: expect.any(String), expiresAt },
|
||||
]);
|
||||
});
|
||||
|
||||
it("the launch route validates its provider and its state parameter", async () => {
|
||||
const app = await newApp();
|
||||
for (const url of ["/v1/oauth/discord/launch", "/v1/oauth/discord/launch?state=", "/v1/oauth/bogus/launch?state=abc"]) {
|
||||
const response = await app.inject({ method: "GET", url });
|
||||
expect(response.statusCode, url).toBe(400);
|
||||
expect(response.json().error, url).toBe("invalid_request");
|
||||
}
|
||||
});
|
||||
|
||||
it("a state's requested scopes are null, absent, or a list of strings, and nothing else", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const start = await bifrostStart(app);
|
||||
const original = decodeJwt(stateOf(start)).payload;
|
||||
const launchWith = async (change: Record<string, unknown>) => {
|
||||
const rest = { ...original };
|
||||
delete rest.requested_scopes;
|
||||
const token = signJwt({ ...rest, jti: randomUUID(), ...change }, ctx.keys);
|
||||
return app.inject({ method: "GET", url: `/v1/oauth/discord/launch?state=${encodeURIComponent(token)}` });
|
||||
};
|
||||
|
||||
for (const [label, change] of [
|
||||
["absent", {}],
|
||||
["null", { requested_scopes: null }],
|
||||
["a list", { requested_scopes: ["identify"] }],
|
||||
] as const) {
|
||||
expect((await launchWith(change)).statusCode, label).toBe(302);
|
||||
}
|
||||
for (const [label, change] of [
|
||||
["a string", { requested_scopes: "identify" }],
|
||||
["a list with a number", { requested_scopes: ["identify", 7] }],
|
||||
["a list of numbers", { requested_scopes: [1, 2] }],
|
||||
["an object", { requested_scopes: { 0: "identify" } }],
|
||||
] as const) {
|
||||
const response = await launchWith(change);
|
||||
expect(response.statusCode, label).toBe(400);
|
||||
expect(response.json(), label).toEqual({ error: "invalid_state" });
|
||||
}
|
||||
});
|
||||
|
||||
it("the time windows hold to the second: a state from nbf - 30 s to exp + 30 s, a binding until its exp", async () => {
|
||||
const app = await newApp();
|
||||
const ctx = getHeimdallRuntimeContext(app);
|
||||
const start = await bifrostStart(app);
|
||||
const original = decodeJwt(stateOf(start)).payload;
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
const now = 1_900_000_000;
|
||||
vi.setSystemTime(now * 1000);
|
||||
const stateWith = (change: Record<string, unknown>) =>
|
||||
signJwt({ ...original, jti: randomUUID(), nbf: now - 1, exp: now + 600, ...change }, ctx.keys);
|
||||
const launch = (token: string) =>
|
||||
app.inject({ method: "GET", url: `/v1/oauth/discord/launch?state=${encodeURIComponent(token)}` });
|
||||
|
||||
expect((await launch(stateWith({ exp: now - 30 }))).json()).toEqual({ error: "state_expired" });
|
||||
expect((await launch(stateWith({ exp: now - 29 }))).statusCode).toBe(302);
|
||||
expect((await launch(stateWith({ nbf: now + 31 }))).json()).toEqual({ error: "state_expired" });
|
||||
expect((await launch(stateWith({ nbf: now + 30 }))).statusCode).toBe(302);
|
||||
|
||||
const token = stateWith({});
|
||||
const jti = decodeJwt(token).payload.jti as string;
|
||||
const bindingWith = (exp: number) =>
|
||||
`__Host-heimdall-oauth-${jti}=${signJwt({ typ: "heimdall_oauth_binding", iss: ctx.config.issuer, jti, iat: now - 5, exp }, ctx.keys)}`;
|
||||
expect((await callback(app, token, bindingWith(now))).json()).toEqual({ error: "state_not_bound" });
|
||||
expect((await callback(app, token, bindingWith(now + 1))).statusCode).toBe(201);
|
||||
});
|
||||
});
|
||||
|
|
@ -1,18 +1,17 @@
|
|||
import { access, mkdtemp, readFile, writeFile } from "node:fs/promises";
|
||||
import { openSync, closeSync } from "node:fs";
|
||||
import { openSync } from "node:fs";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
|
||||
import { encode } from "@msgpack/msgpack";
|
||||
import { SingleFileMessagePackBackingStore } from "@gamecult/cultcache-ts";
|
||||
import { decode, encode } from "@msgpack/msgpack";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import {
|
||||
openOrEnrollProviderHealthIdentity,
|
||||
openProviderHealthIdentity,
|
||||
passedDescriptor,
|
||||
providerHealthPublicIdentity,
|
||||
} from "../src/provider-health-identity.js";
|
||||
import { fixtureMachineId, idunnRuntimeFixtures } from "./fixtures/presence-descriptors.js";
|
||||
|
||||
const machineIdAvailable = await readFile("/etc/machine-id", "utf8").then(
|
||||
() => true,
|
||||
|
|
@ -23,59 +22,79 @@ const machineIdAvailable = await readFile("/etc/machine-id", "utf8").then(
|
|||
* The identity is machine-id bound, so enrolment only works where a machine-id
|
||||
* exists. These run on Linux and are skipped elsewhere.
|
||||
*/
|
||||
describe.skipIf(!machineIdAvailable)("presence identity from a passed descriptor", () => {
|
||||
it("reads an Idunn-written store, not a cultcache-ts one", async () => {
|
||||
/** Name the presence descriptor so it lands on whatever fd open() returned. */
|
||||
function presenceEnv(fd: number): NodeJS.ProcessEnv {
|
||||
// The lookup maps a name index onto 3 + index, so the name list is padded
|
||||
// until the presence entry lands on the descriptor open() actually returned.
|
||||
// Assuming it is 3 is how this passes on one machine and reads the wrong
|
||||
// descriptor on another.
|
||||
const names = [
|
||||
...Array.from({ length: fd - 3 }, (_, i) => `pad-${i}`),
|
||||
"gamecult-runtime-presence-identity",
|
||||
].join(":");
|
||||
return { LISTEN_FDNAMES: names, LISTEN_PID: String(process.pid) };
|
||||
}
|
||||
|
||||
describe("presence identity from a passed descriptor", () => {
|
||||
it("decodes the Rust owner's record, whose key fields are integer arrays", async () => {
|
||||
const dir = await mkdtemp(path.join(os.tmpdir(), "heimdall-presence-"));
|
||||
const fd = openSync(path.join(idunnRuntimeFixtures, "provider-identity.credential"), "r");
|
||||
|
||||
// Enrol with the TypeScript client to get a genuine machine-bound payload,
|
||||
// then re-wrap that payload the way cultcache-rs writes a store: a bare
|
||||
// array of positional [key, type, payload, stored_at, schema_id] envelopes.
|
||||
// Idunn writes with the Rust client, and cultcache-ts cannot read that
|
||||
// layout, so wrapping it here is what makes this test resemble reality.
|
||||
const tsStore = path.join(dir, "ts-enrolled.cc");
|
||||
const enrolled = await openOrEnrollProviderHealthIdentity(tsStore);
|
||||
const records = await new SingleFileMessagePackBackingStore(tsStore).pullAll();
|
||||
expect(records).toHaveLength(1);
|
||||
|
||||
const idunnStore = path.join(dir, "runtime-presence-identity.cc");
|
||||
await writeFile(
|
||||
idunnStore,
|
||||
encode([
|
||||
[
|
||||
"gamecult-provider-health-identity",
|
||||
"gamecult.provider_health_identity.private.v1",
|
||||
records[0]!.payload,
|
||||
"2026-09-06T00:00:00.000Z",
|
||||
"gamecult.provider_health_identity.private.v1",
|
||||
],
|
||||
])
|
||||
const opened = await openProviderHealthIdentity(
|
||||
path.join(dir, "would-be-self-enrolled.cc"),
|
||||
presenceEnv(fd),
|
||||
fixtureMachineId
|
||||
);
|
||||
|
||||
const fd = openSync(idunnStore, "r");
|
||||
try {
|
||||
// The lookup maps a name index onto 3 + index, so the name list is padded
|
||||
// until the presence entry lands on whatever descriptor open() actually
|
||||
// returned. Assuming it is 3 is how this passes on one machine and reads
|
||||
// the wrong descriptor on another.
|
||||
const names = [
|
||||
...Array.from({ length: fd - 3 }, (_, i) => `pad-${i}`),
|
||||
"gamecult-runtime-presence-identity",
|
||||
].join(":");
|
||||
// The fixture's own public key means it came from the descriptor. A fresh
|
||||
// self-enrolment would produce a different key, which is exactly the failure
|
||||
// that makes Idunn refuse this daemon's health and stall promotion.
|
||||
const store = decode(await readFile(path.join(idunnRuntimeFixtures, "provider-identity.credential"))) as unknown[][];
|
||||
const record = decode(store[0]![2] as Uint8Array) as unknown[];
|
||||
expect(providerHealthPublicIdentity(opened).publicKeyHex).toBe(
|
||||
Buffer.from(record[2] as number[]).toString("hex")
|
||||
);
|
||||
await expect(access(path.join(dir, "would-be-self-enrolled.cc"))).rejects.toMatchObject({ code: "ENOENT" });
|
||||
});
|
||||
|
||||
const opened = await openProviderHealthIdentity(
|
||||
path.join(dir, "would-be-self-enrolled.cc"),
|
||||
{ LISTEN_FDNAMES: names, LISTEN_PID: String(process.pid) }
|
||||
);
|
||||
it("refuses a bin-shaped record on the descriptor path, naming the key-shape check and no value", async () => {
|
||||
const dir = await mkdtemp(path.join(os.tmpdir(), "heimdall-presence-bin-"));
|
||||
const store = decode(await readFile(path.join(idunnRuntimeFixtures, "provider-identity.credential"))) as unknown[][];
|
||||
const record = decode(store[0]![2] as Uint8Array) as unknown[];
|
||||
// What this process's own enroller writes: the same record with bin key fields.
|
||||
const binRecord = record.map((field, index) =>
|
||||
index === 2 || index === 3 ? Uint8Array.from(field as number[]) : field
|
||||
);
|
||||
const binStore = path.join(dir, "bin-shaped.cc");
|
||||
await writeFile(binStore, encode([[store[0]![0], store[0]![1], encode(binRecord), store[0]![3], store[0]![4]]]));
|
||||
const fd = openSync(binStore, "r");
|
||||
|
||||
// Same key means it came from the descriptor. A fresh self-enrolment
|
||||
// would produce a different key -- which is exactly the failure that
|
||||
// makes Idunn refuse this daemon's health and stall promotion.
|
||||
expect(providerHealthPublicIdentity(opened).publicKeyHex).toBe(
|
||||
providerHealthPublicIdentity(enrolled).publicKeyHex
|
||||
);
|
||||
} finally {
|
||||
closeSync(fd);
|
||||
}
|
||||
const failure = await openProviderHealthIdentity(path.join(dir, "x.cc"), presenceEnv(fd), fixtureMachineId).then(
|
||||
() => undefined,
|
||||
(error: Error) => error
|
||||
);
|
||||
|
||||
expect(failure?.message).toContain("key shape check");
|
||||
expect(failure?.message).not.toContain((record[1] as string).slice(0, 16));
|
||||
});
|
||||
|
||||
it.each([
|
||||
["schema", 0, "bogus", "schema check"],
|
||||
["protector", 4, "bogus", "protector check"],
|
||||
["binding", 5, "bogus", "binding check"],
|
||||
["version", 6, "v9", "version check"],
|
||||
])("a record failing only the %s check is refused by that check", async (_name, index, replacement, check) => {
|
||||
const dir = await mkdtemp(path.join(os.tmpdir(), "heimdall-presence-check-"));
|
||||
const store = decode(await readFile(path.join(idunnRuntimeFixtures, "provider-identity.credential"))) as unknown[][];
|
||||
const record = decode(store[0]![2] as Uint8Array) as unknown[];
|
||||
record[index] = replacement;
|
||||
const damaged = path.join(dir, "damaged.cc");
|
||||
await writeFile(damaged, encode([[store[0]![0], store[0]![1], encode(record), store[0]![3], store[0]![4]]]));
|
||||
const fd = openSync(damaged, "r");
|
||||
|
||||
await expect(
|
||||
openProviderHealthIdentity(path.join(dir, "x.cc"), presenceEnv(fd), fixtureMachineId)
|
||||
).rejects.toThrow(check);
|
||||
});
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import { type HeimdallConfig } from "../src/config.js";
|
|||
import { startHeimdallPrivateCommandPlane } from "../src/private-command-plane.js";
|
||||
import { openPrivateEnvelope, sealPrivateEnvelope, type HeimdallPrivateEnvelope } from "../src/private-command-security.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { launchState } from "./oauth-flow.js";
|
||||
|
||||
const secret = "ghostlight-private-command-secret";
|
||||
const resources: Array<{ close(): Promise<unknown> }> = [];
|
||||
|
|
@ -30,7 +31,7 @@ function config(): HeimdallConfig {
|
|||
bootstrapSigningPrivateKeyOnMissing: false, tokenEncryptionKeyBase64: Buffer.alloc(32, 7).toString("base64"),
|
||||
appSharedSecrets: { ghostlight: secret }, appRuntimeIds: { ghostlight: ["yggdrasil-ghostlight"] }, appBackendCallbacks: {},
|
||||
storage: { backend: "memory", applySchemaOnStartup: true },
|
||||
providers: { discord: { clientId: "discord-client", clientSecret: "discord-secret" }, patreon: {}, github: {}, twitch: {}, youtube: {}, spotify: {}, joystick: {} },
|
||||
providers: { discord: { clientId: "discord-client", clientSecret: "discord-secret" }, patreon: {}, github: {}, twitch: {}, youtube: {}, spotify: {}, joystick: {}, google: {} },
|
||||
} as HeimdallConfig;
|
||||
}
|
||||
|
||||
|
|
@ -73,10 +74,11 @@ async function refreshAgainst(refreshAnswer: () => Response) {
|
|||
const begin = open(await command(plane.endpoint, "heimdall.auth.begin", "heimdall.auth_begin_command.v1", "k1",
|
||||
{ provider: "discord", mode: "sign_in", returnTo: "https://yggdrasil.gamecult.org/ghostlight/", entitlementPolicy: policy }));
|
||||
const state = new URL(String((begin.navigation as { url: string }).url)).searchParams.get("state")!;
|
||||
const { cookie } = await launchState(app, state);
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=c1&state=${encodeURIComponent(state)}`,
|
||||
headers: { accept: "application/json" },
|
||||
headers: { accept: "application/json", cookie },
|
||||
});
|
||||
expect(callback.statusCode, callback.body).toBe(201);
|
||||
const done = open(await command(plane.endpoint, "heimdall.auth.complete", "heimdall.auth_complete_command.v1", "k2", { handle: begin.handle }));
|
||||
|
|
@ -133,10 +135,11 @@ it("keeps the completion code out of the audit trail when the plane redeems by a
|
|||
const begin = open(await command(plane.endpoint, "heimdall.auth.begin", "heimdall.auth_begin_command.v1", "k1",
|
||||
{ provider: "discord", mode: "sign_in", returnTo: "https://yggdrasil.gamecult.org/ghostlight/", entitlementPolicy: policy }));
|
||||
const state = new URL(String((begin.navigation as { url: string }).url)).searchParams.get("state")!;
|
||||
const { cookie } = await launchState(app, state);
|
||||
const callback = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/discord/callback?code=c1&state=${encodeURIComponent(state)}`,
|
||||
headers: { accept: "application/json" },
|
||||
headers: { accept: "application/json", cookie },
|
||||
});
|
||||
const code = (callback.json().completion as { code: string }).code;
|
||||
const done = open(await command(plane.endpoint, "heimdall.auth.complete", "heimdall.auth_complete_command.v1", "k2", { handle: begin.handle }));
|
||||
|
|
|
|||
|
|
@ -1,17 +1,12 @@
|
|||
import { mkdtemp, readdir, readFile, writeFile } from "node:fs/promises";
|
||||
import { mkdtemp, readdir, writeFile } from "node:fs/promises";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import { loadConfig } from "../src/config.js";
|
||||
import { PublisherSequence, buildPresenceStatement } from "../src/runtime-presence.js";
|
||||
import { bundleFacts, openPresenceDescriptors, writePresenceFixtures } from "./fixtures/presence-descriptors.js";
|
||||
|
||||
const machineIdAvailable = await readFile("/etc/machine-id", "utf8").then(
|
||||
() => true,
|
||||
() => false
|
||||
);
|
||||
import { PublisherSequence, openPresenceAuthority } from "../src/runtime-presence.js";
|
||||
import { fixtureMachineId, openPresenceDescriptors, writePresenceFixtures } from "./fixtures/presence-descriptors.js";
|
||||
|
||||
describe("PublisherSequence", () => {
|
||||
it("starts at the observed millis", () => {
|
||||
|
|
@ -51,10 +46,11 @@ describe("PublisherSequence", () => {
|
|||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!machineIdAvailable)("presence publication and the state root", () => {
|
||||
it("touches no path under dataRoot", async () => {
|
||||
describe("the presence authority", () => {
|
||||
it("opens once, touches no path under dataRoot, and signs every pulse after its descriptors are gone", async () => {
|
||||
const dir = await mkdtemp(path.join(os.tmpdir(), "heimdall-nodataroot-"));
|
||||
await writePresenceFixtures(path.join(dir, "fixtures"));
|
||||
const fixtures = path.join(dir, "fixtures");
|
||||
await writePresenceFixtures(fixtures);
|
||||
// A regular file as dataRoot: opening anything beneath it fails with
|
||||
// ENOTDIR for every uid, root included.
|
||||
const dataRoot = path.join(dir, "not-a-directory");
|
||||
|
|
@ -64,21 +60,21 @@ describe.skipIf(!machineIdAvailable)("presence publication and the state root",
|
|||
GC_ACCESS_DATA_ROOT: dataRoot,
|
||||
});
|
||||
|
||||
const descriptors = openPresenceDescriptors(path.join(dir, "fixtures"));
|
||||
const descriptors = openPresenceDescriptors(fixtures);
|
||||
try {
|
||||
const authority = await openPresenceAuthority(
|
||||
{ ...config, idunnRuntimeBundlePath: fixtures },
|
||||
descriptors.env,
|
||||
fixtureMachineId,
|
||||
);
|
||||
// The descriptors were read whole and closed: a second read would find
|
||||
// nothing, so signing again proves the authority holds what it decoded.
|
||||
const observedAtUnixMillis = Date.parse("2026-10-23T12:00:00.000Z");
|
||||
const statement = await buildPresenceStatement({
|
||||
bundle: bundleFacts,
|
||||
state: "warming",
|
||||
detail: "probe",
|
||||
boundEndpoint: null,
|
||||
writeLeaseSha256: null,
|
||||
observedAtUnixMillis,
|
||||
publisherSequence: new PublisherSequence().next(observedAtUnixMillis),
|
||||
providerHealthIdentityPath: config.providerHealthIdentityPath,
|
||||
env: descriptors.env,
|
||||
});
|
||||
expect(statement.target).toBe("heimdall");
|
||||
const first = authority.sign("warming", "probe", observedAtUnixMillis);
|
||||
const second = authority.sign("warming", "probe", observedAtUnixMillis);
|
||||
expect(first.target).toBe("streampixels-web");
|
||||
expect(second.target).toBe("streampixels-web");
|
||||
expect(Buffer.from(second.payload).equals(Buffer.from(first.payload))).toBe(false);
|
||||
} finally {
|
||||
descriptors.close();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -225,4 +225,27 @@ describe("Idunn recipe secret declarations", () => {
|
|||
expect(serviceNames).toContain(`${name}_FILE`);
|
||||
}
|
||||
});
|
||||
|
||||
it("declares every other name loadConfig reads, or says why a binding never sets it", () => {
|
||||
// Idunn refuses a binding that sets an undeclared name, so an undeclared
|
||||
// name is a setting no Idunn-admitted generation can ever change.
|
||||
const neverBound = new Set([
|
||||
// The listen socket is the candidate bind under Idunn, and the command port follows it.
|
||||
"HOST",
|
||||
"PORT",
|
||||
// The state root is the --state-root argument; the paths below it are Heimdall's own layout.
|
||||
"GC_ACCESS_DATA_ROOT",
|
||||
"GC_ACCESS_CULTCACHE_PATH",
|
||||
"GC_ACCESS_PROVIDER_HEALTH_IDENTITY_PATH",
|
||||
// The daemon id is the host's name for this process, fixed by the code's default.
|
||||
"GC_ACCESS_IDUNN_DAEMON",
|
||||
]);
|
||||
const declared = new Set(everyDeclaredName);
|
||||
const unreachable = [...explored.names]
|
||||
.filter((name) => !secretNames.includes(name) && !name.endsWith("_FILE"))
|
||||
.filter((name) => !declared.has(name) && !neverBound.has(name));
|
||||
expect(unreachable).toEqual([]);
|
||||
// An exemption for a name nothing reads would hide the next real gap.
|
||||
expect([...neverBound].filter((name) => !explored.names.has(name))).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ function createTestConfig(overrides: Partial<HeimdallConfig> = {}): HeimdallConf
|
|||
youtube: {},
|
||||
spotify: {},
|
||||
joystick: {},
|
||||
google: {},
|
||||
},
|
||||
...overrides,
|
||||
};
|
||||
|
|
|
|||
435
tests/step-up-assertion.test.ts
Normal file
435
tests/step-up-assertion.test.ts
Normal file
|
|
@ -0,0 +1,435 @@
|
|||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { buildApp, STEP_UP_ASSERT_LIMITS } from "../src/app.js";
|
||||
import { builtInAppProfiles } from "../src/app-profiles.js";
|
||||
import { issueAccessClaim } from "../src/claims.js";
|
||||
import { type Provider } from "../src/contracts.js";
|
||||
import { createRuntimeKeyMaterial, signJwt, verifyJwt } from "../src/signing.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { type CreateAuditEventInput } from "../src/store/types.js";
|
||||
import { createTestConfig } from "./oauth-flow.js";
|
||||
|
||||
// An app asserting a step-up proof for its member: POST /v1/apps/{app}/step-up.
|
||||
// Driven over HTTP through the real Fastify app, the way Bifrost would call it,
|
||||
// with the unlink route as the consumer of the proof it mints.
|
||||
|
||||
const now = "2026-11-13T12:00:00.000Z";
|
||||
const secret = "bifrost-secret";
|
||||
const appAuth = { "x-heimdall-app-secret": secret };
|
||||
const nonce = (tag: string) => `nonce-${tag.replace(/[^A-Za-z0-9_-]/g, "_")}-`.padEnd(32, "x");
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), "heimdall-stepup-assert-"));
|
||||
const config = { ...createTestConfig(), signingPrivateKeyPath: join(dir, "signing.pem"), bootstrapSigningPrivateKeyOnMissing: true };
|
||||
afterAll(() => rmSync(dir, { recursive: true, force: true }));
|
||||
|
||||
const apps: Awaited<ReturnType<typeof buildApp>>[] = [];
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
vi.restoreAllMocks();
|
||||
await Promise.all(apps.splice(0).map((app) => app.close()));
|
||||
});
|
||||
|
||||
async function rig() {
|
||||
const store = new InMemoryStore();
|
||||
const audit: CreateAuditEventInput[] = [];
|
||||
const realAudit = store.createAuditEvent.bind(store);
|
||||
store.createAuditEvent = async (input) => {
|
||||
audit.push(structuredClone(input));
|
||||
return realAudit(input);
|
||||
};
|
||||
const app = await buildApp({ config, store });
|
||||
apps.push(app);
|
||||
const keys = createRuntimeKeyMaterial({ ...config, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
return { app, store, keys, audit };
|
||||
}
|
||||
type Rig = Awaited<ReturnType<typeof rig>>;
|
||||
|
||||
/** A member with the given identities and a live Heimdall session for `appSlug`, as a sign-in would have left them. */
|
||||
let seq = 0;
|
||||
async function member(r: Rig, appSlug = "bifrost", held?: Array<[Provider, string]>, accountId?: string) {
|
||||
seq += 1;
|
||||
held ??= [["discord", `d-${seq}`], ["google", `g-${seq}`]];
|
||||
const account = accountId ? { id: accountId } : await r.store.createAccount({ createdAt: now, lastSeenAt: now });
|
||||
const rows = [];
|
||||
if (!accountId) {
|
||||
for (const [provider, providerUserId] of held) {
|
||||
rows.push(await r.store.upsertLinkedIdentity({ accountId: account.id, provider, providerUserId, scopes: [], profileJson: {}, createdAt: now, updatedAt: now }));
|
||||
}
|
||||
}
|
||||
const issued = await issueAccessClaim({
|
||||
config,
|
||||
keys: r.keys,
|
||||
store: r.store,
|
||||
input: { appSlug, accountId: account.id, linkedIdentities: held.map(([provider, providerUserId]) => ({ provider, providerUserId })), facts: [] },
|
||||
});
|
||||
return { account, rows, issued, token: issued.accessToken, sid: issued.session.sessionId };
|
||||
}
|
||||
|
||||
const bearer = (token?: string) => (token ? { authorization: `Bearer ${token}` } : {});
|
||||
const assertStepUp = (r: Rig, o: { app?: string; headers?: Record<string, string>; token?: string | undefined; method?: string; nonce?: string; payload?: object } = {}) =>
|
||||
r.app.inject({
|
||||
method: "POST",
|
||||
url: `/v1/apps/${o.app ?? "bifrost"}/step-up`,
|
||||
headers: { ...(o.headers ?? appAuth), ...bearer(o.token) },
|
||||
payload: o.payload ?? { method: o.method ?? "bifrost-passkey", nonce: o.nonce ?? nonce("a") },
|
||||
});
|
||||
const unlink = (r: Rig, id: string, token: string) =>
|
||||
r.app.inject({ method: "POST", url: `/v1/me/identities/${encodeURIComponent(id)}/unlink`, headers: bearer(token) });
|
||||
const refused = (res: { statusCode: number; json(): { error?: string } }) => [res.statusCode, res.json().error];
|
||||
const claimsOf = (token: string, r: Rig) => {
|
||||
const v = verifyJwt(token, r.keys.publicKey);
|
||||
expect(v.valid).toBe(true);
|
||||
return v.valid ? v.payload : {};
|
||||
};
|
||||
const nowS = () => Math.floor(Date.now() / 1000);
|
||||
const auditOf = (r: Rig, type: string) => r.audit.filter((e) => e.eventType === type);
|
||||
|
||||
describe("the proof it mints", () => {
|
||||
it("returns a new access token for the same session and account, with step_up_at now and the method, and no refresh token", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const before = nowS();
|
||||
const res = await assertStepUp(r, { token: m.token });
|
||||
expect(res.statusCode).toBe(201);
|
||||
expect(res.headers["cache-control"]).toBe("no-store");
|
||||
const body = res.json();
|
||||
expect(Object.keys(body).sort()).toEqual(["accessToken", "claimSet", "stepUp"]);
|
||||
expect(res.body).not.toContain(m.issued.refreshToken);
|
||||
const original = claimsOf(m.token, r);
|
||||
const minted = claimsOf(body.accessToken, r);
|
||||
expect(minted.step_up_method).toBe("bifrost-passkey");
|
||||
expect(minted.step_up_at).toBeGreaterThanOrEqual(before);
|
||||
expect(minted.step_up_at).toBeLessThanOrEqual(nowS());
|
||||
expect(body.claimSet).toEqual(minted);
|
||||
expect(body.stepUp).toEqual({ at: minted.step_up_at, method: "bifrost-passkey", validForSeconds: 600 });
|
||||
expect(minted.jti).not.toBe(original.jti);
|
||||
// Everything else is the bearer's own: it adds proof, not capability, and does not move the session.
|
||||
const { jti, iat, nbf, step_up_at, step_up_method, ...rest } = minted;
|
||||
const { jti: _j, iat: _i, nbf: _n, ...originalRest } = original;
|
||||
expect(rest).toEqual(originalRest);
|
||||
expect([jti, iat, nbf, step_up_at, step_up_method].every((v) => v !== undefined)).toBe(true);
|
||||
expect(minted.sid).toBe(m.sid);
|
||||
expect(minted.account_id).toBe(m.account.id);
|
||||
expect(minted.aud).toBe("bifrost");
|
||||
});
|
||||
|
||||
it("the unlink check passes with the returned bearer and fails 403 step_up_required with the original", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
expect(refused(await unlink(r, m.rows[1]!.id, m.token))).toEqual([403, "step_up_required"]);
|
||||
const minted = (await assertStepUp(r, { token: m.token })).json().accessToken;
|
||||
expect((await unlink(r, m.rows[1]!.id, m.token)).statusCode, "the original bearer gains nothing").toBe(403);
|
||||
const done = await unlink(r, m.rows[1]!.id, minted);
|
||||
expect(done.statusCode).toBe(200);
|
||||
expect(done.json().unlinked.id).toBe(m.rows[1]!.id);
|
||||
const unlinkEvent = auditOf(r, "identity_unlinked")[0]!;
|
||||
expect(unlinkEvent.eventPayloadJson).toMatchObject({ provider: "google", stepUpMethod: "bifrost-passkey" });
|
||||
});
|
||||
|
||||
it("does not extend the lifetime: exp stays the bearer's, the session row is untouched, no refresh is minted", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const sessionBefore = await r.store.findSession("bifrost", m.sid);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
vi.setSystemTime(Date.now() + 1_500_000);
|
||||
const res = await assertStepUp(r, { token: m.token });
|
||||
expect(res.statusCode).toBe(201);
|
||||
const original = claimsOf(m.token, r);
|
||||
const minted = claimsOf(res.json().accessToken, r);
|
||||
expect(minted.exp).toBe(original.exp);
|
||||
expect(minted.iat).toBeGreaterThan(original.iat as number);
|
||||
expect(await r.store.findSession("bifrost", m.sid)).toEqual(sessionBefore);
|
||||
});
|
||||
|
||||
it("a refresh after an assertion carries neither step_up_at nor step_up_method", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
expect((await assertStepUp(r, { token: m.token })).statusCode).toBe(201);
|
||||
const refreshed = await r.app.inject({ method: "POST", url: "/v1/apps/bifrost/sessions/refresh", payload: { refreshToken: m.issued.refreshToken } });
|
||||
expect(refreshed.statusCode).toBe(201);
|
||||
const claims = claimsOf(refreshed.json().accessToken, r);
|
||||
expect(claims).not.toHaveProperty("step_up_at");
|
||||
expect(claims).not.toHaveProperty("step_up_method");
|
||||
expect(refreshed.json().claimSet).not.toHaveProperty("step_up_at");
|
||||
expect(refreshed.json().claimSet).not.toHaveProperty("step_up_method");
|
||||
});
|
||||
|
||||
it("the proof is good for 599 s and not for 601 s, as for any step-up", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r, "bifrost", [["discord", "d-w"], ["google", "g-w"], ["patreon", "p-w"]]);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
const minted = (await assertStepUp(r, { token: m.token })).json().accessToken;
|
||||
vi.setSystemTime(Date.now() + 601_000);
|
||||
expect(refused(await unlink(r, m.rows[1]!.id, minted))).toEqual([403, "step_up_required"]);
|
||||
vi.setSystemTime(Date.now() - 2_000);
|
||||
expect((await unlink(r, m.rows[1]!.id, minted)).statusCode).toBe(200);
|
||||
});
|
||||
|
||||
it("the provider step-up callback labels its proof provider:<name>", async () => {
|
||||
// The sign_in path itself is proved in identity-unlink.test.ts; here the claim input is the contract.
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const issued = await issueAccessClaim({
|
||||
config, keys: r.keys, store: r.store,
|
||||
input: { appSlug: "bifrost", accountId: m.account.id, linkedIdentities: [], facts: [], stepUpAt: nowS(), stepUpMethod: "provider:google" },
|
||||
});
|
||||
expect(issued.claimSet.step_up_method).toBe("provider:google");
|
||||
});
|
||||
});
|
||||
|
||||
describe("it is never issuable without both credentials", () => {
|
||||
it("401 app_auth_required for a missing, wrong, or another app's secret, even with a good bearer; nothing is written", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
for (const headers of [{}, { "x-heimdall-app-secret": "wrong" }, { "x-heimdall-app-secret": "streampixels-secret" }, { "x-heimdall-app-secret": "" }]) {
|
||||
const res = await assertStepUp(r, { headers, token: m.token });
|
||||
expect(res.statusCode).toBe(401);
|
||||
expect(res.json()).toEqual({ error: "app_auth_required" });
|
||||
}
|
||||
expect(r.audit.filter((e) => e.eventType.startsWith("step_up"))).toEqual([]);
|
||||
});
|
||||
|
||||
it("401 sign_in_required for a missing, garbage, expired, foreign-signed, revoked-session or unknown-session bearer; the same answer for each", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const claims = claimsOf(m.token, r);
|
||||
const past = nowS() - 10;
|
||||
const other = createRuntimeKeyMaterial({ ...config, signingPrivateKeyPath: join(dir, "other.pem"), bootstrapSigningPrivateKeyOnMissing: true });
|
||||
const bad: Array<[string, string | undefined]> = [
|
||||
["missing", undefined],
|
||||
["garbage", "not-a-token"],
|
||||
["expired", signJwt({ ...claims, iat: past - 100, nbf: past - 100, exp: past }, r.keys)],
|
||||
["foreign key", signJwt(claims, other)],
|
||||
["unknown session", signJwt({ ...claims, sid: "no-such-session" }, r.keys)],
|
||||
["wrong account for the session", signJwt({ ...claims, account_id: "someone-else" }, r.keys)],
|
||||
["refresh token as bearer", m.issued.refreshToken],
|
||||
];
|
||||
for (const [label, token] of bad) {
|
||||
const res = await assertStepUp(r, { token, nonce: nonce(label) });
|
||||
expect([label, ...refused(res)]).toEqual([label, 401, "sign_in_required"]);
|
||||
expect(res.body).not.toContain("account");
|
||||
}
|
||||
// A revoked session: the row is closed and its revision moved on.
|
||||
expect(await r.store.revokeSession("bifrost", m.sid, m.account.id, 1, now)).not.toBeNull();
|
||||
const revoked = await assertStepUp(r, { token: m.token, nonce: nonce("revoked") });
|
||||
expect(refused(revoked)).toEqual([401, "sign_in_required"]);
|
||||
expect(r.audit.some((e) => e.eventType === "step_up_asserted")).toBe(false);
|
||||
});
|
||||
|
||||
it("a bearer issued to another app is 403 bearer_app_mismatch, never a proof, and says nothing about the account", async () => {
|
||||
const r = await rig();
|
||||
const sp = await member(r, "streampixels");
|
||||
const res = await assertStepUp(r, { token: sp.token });
|
||||
expect(refused(res)).toEqual([403, "bearer_app_mismatch"]);
|
||||
expect(res.body).not.toContain(sp.account.id);
|
||||
// A token for a session that does not exist is indistinguishable from garbage, whatever app it names.
|
||||
const ghost = signJwt({ ...claimsOf(sp.token, r), sid: "ghost" }, r.keys);
|
||||
expect(refused(await assertStepUp(r, { token: ghost }))).toEqual([401, "sign_in_required"]);
|
||||
});
|
||||
|
||||
it("only a profile that grants it may assert: every other app is 403 with its own secret and a live bearer", async () => {
|
||||
expect(Object.values(builtInAppProfiles).filter((p) => p.stepUpAssertion).map((p) => p.slug)).toEqual(["bifrost"]);
|
||||
const r = await rig();
|
||||
for (const [slug, appSecret] of [["streampixels", "streampixels-secret"], ["repixelizer", "repixelizer-secret"]] as const) {
|
||||
const m = await member(r, slug);
|
||||
const res = await assertStepUp(r, { app: slug, headers: { "x-heimdall-app-secret": appSecret }, token: m.token });
|
||||
expect([slug, ...refused(res)]).toEqual([slug, 403, "step_up_assertion_not_permitted"]);
|
||||
expect(res.json()).not.toHaveProperty("accessToken");
|
||||
}
|
||||
// Another app's secret on bifrost's route is still app_auth_required, not the flag.
|
||||
const b = await member(r);
|
||||
expect(refused(await assertStepUp(r, { headers: { "x-heimdall-app-secret": "streampixels-secret" }, token: b.token }))).toEqual([401, "app_auth_required"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the method and the nonce", () => {
|
||||
it("rejects a method outside the profile's closed set with 400, names the set, and does not spend the nonce", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
for (const method of ["passkey", "provider:google", "streampixels-passkey", "BIFROST-PASSKEY", "bifrost-passkey "]) {
|
||||
const res = await assertStepUp(r, { token: m.token, method, nonce: nonce("m") });
|
||||
expect([method, ...refused(res)]).toEqual([method, 400, "unknown_step_up_method"]);
|
||||
expect(res.json().methods).toEqual(["bifrost-passkey", "bifrost-email-code"]);
|
||||
}
|
||||
expect((await assertStepUp(r, { token: m.token, method: "bifrost-email-code", nonce: nonce("m") })).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("malformed bodies are 400 before anything is minted", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
for (const payload of [{}, { method: "bifrost-passkey" }, { nonce: nonce("a") }, { method: "bifrost-passkey", nonce: "short" }, { method: "bifrost-passkey", nonce: "has a space in it, 16+ chars" }, { method: "bifrost-passkey", nonce: `${"a".repeat(20)}\ud800` }, { method: "bifrost-passkey", nonce: "a".repeat(129) }, { method: "bifrost-passkey", nonce: "ok-looking-nonce-é-ünï" }, { method: 7, nonce: nonce("a") }]) {
|
||||
expect((await assertStepUp(r, { token: m.token, payload })).statusCode, JSON.stringify(payload)).toBe(400);
|
||||
}
|
||||
expect(auditOf(r, "step_up_asserted")).toEqual([]);
|
||||
});
|
||||
|
||||
it("a nonce is single-use per session: the second try is 409, another session may use the same value", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const second = await member(r, "bifrost", [], m.account.id);
|
||||
expect((await assertStepUp(r, { token: m.token })).statusCode).toBe(201);
|
||||
const replay = await assertStepUp(r, { token: m.token });
|
||||
expect(refused(replay)).toEqual([409, "step_up_nonce_replayed"]);
|
||||
expect(replay.json()).not.toHaveProperty("accessToken");
|
||||
// The replay does not depend on which method rides with it.
|
||||
expect(refused(await assertStepUp(r, { token: m.token, method: "bifrost-email-code" }))).toEqual([409, "step_up_nonce_replayed"]);
|
||||
expect((await assertStepUp(r, { token: second.token })).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("a nonce is retained to the session's expiry as of the claim plus the 10.5 min prune horizon; a refresh slides the session past that and the nonce can be reused (documented limit)", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
const t0 = Date.now();
|
||||
const R = config.refreshTtlSeconds * 1000;
|
||||
expect((await assertStepUp(r, { token: m.token, nonce: nonce("N") })).statusCode).toBe(201);
|
||||
vi.setSystemTime(t0 + R - 60_000);
|
||||
const refreshed = await r.app.inject({ method: "POST", url: "/v1/apps/bifrost/sessions/refresh", payload: { refreshToken: m.issued.refreshToken } });
|
||||
expect(refreshed.statusCode).toBe(201);
|
||||
const token = refreshed.json().accessToken as string;
|
||||
expect(refused(await assertStepUp(r, { token, nonce: nonce("N") })).join()).toBe("409,step_up_nonce_replayed");
|
||||
// 10 min past the old expiry: a claim runs the prune, and N is still inside the 10.5 min horizon (10 min margin + 30 s skew).
|
||||
vi.setSystemTime(t0 + R + 10 * 60_000);
|
||||
expect((await assertStepUp(r, { token, nonce: nonce("M") })).statusCode).toBe(201);
|
||||
expect(refused(await assertStepUp(r, { token, nonce: nonce("N") }))).toEqual([409, "step_up_nonce_replayed"]);
|
||||
// Past the horizon the next claim prunes N (lazily, with the claim) while the session lives on.
|
||||
vi.setSystemTime(t0 + R + 10 * 60_000 + 31_000 + 2_000);
|
||||
expect((await assertStepUp(r, { token, nonce: nonce("K") })).statusCode).toBe(201);
|
||||
expect((await assertStepUp(r, { token, nonce: nonce("N") })).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("a nonce stays spent for the session's life, past the access token's own expiry, and across a restart of the process", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
expect((await assertStepUp(r, { token: m.token })).statusCode).toBe(201);
|
||||
// A second app instance over the same store has no memory of the first: the store carries the claim.
|
||||
const again = await buildApp({ config, store: r.store });
|
||||
apps.push(again);
|
||||
const res = await again.inject({ method: "POST", url: "/v1/apps/bifrost/step-up", headers: { ...appAuth, ...bearer(m.token) }, payload: { method: "bifrost-passkey", nonce: nonce("a") } });
|
||||
expect(refused(res)).toEqual([409, "step_up_nonce_replayed"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("rate limits", () => {
|
||||
it("trips per account, leaves other accounts alone, and turns over with the window", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const other = await member(r);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
for (let i = 0; i < STEP_UP_ASSERT_LIMITS.account.max; i += 1) {
|
||||
expect((await assertStepUp(r, { token: m.token, nonce: nonce(`r${i}`) })).statusCode, `attempt ${i}`).toBe(201);
|
||||
}
|
||||
const tripped = await assertStepUp(r, { token: m.token, nonce: nonce("over") });
|
||||
expect(refused(tripped)).toEqual([429, "step_up_rate_limited"]);
|
||||
expect(tripped.json().retryAfterSeconds).toBeGreaterThan(0);
|
||||
expect(tripped.json()).not.toHaveProperty("accessToken");
|
||||
expect((await assertStepUp(r, { token: other.token })).statusCode).toBe(201);
|
||||
vi.setSystemTime(Date.now() + STEP_UP_ASSERT_LIMITS.account.windowMs + 1000);
|
||||
expect((await assertStepUp(r, { token: m.token, nonce: nonce("after") })).statusCode).toBe(201);
|
||||
// The tripped attempt did not spend its nonce.
|
||||
expect((await assertStepUp(r, { token: m.token, nonce: nonce("over") })).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("trips per app across accounts, counting attempts that failed their bearer", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
for (let i = 0; i < STEP_UP_ASSERT_LIMITS.app.max; i += 1) {
|
||||
expect((await assertStepUp(r, { token: "garbage", nonce: nonce(`g${i}`) })).statusCode).toBe(401);
|
||||
}
|
||||
expect(refused(await assertStepUp(r, { token: m.token }))).toEqual([429, "step_up_rate_limited"]);
|
||||
vi.setSystemTime(Date.now() + STEP_UP_ASSERT_LIMITS.app.windowMs + 1000);
|
||||
expect((await assertStepUp(r, { token: m.token })).statusCode).toBe(201);
|
||||
});
|
||||
});
|
||||
|
||||
describe("flood handling", () => {
|
||||
it("the not-permitted budget is per app: one app's flood neither blocks bifrost's own call nor another ungranted app's first refusal", async () => {
|
||||
const r = await rig();
|
||||
const sp = await member(r, "streampixels");
|
||||
const rp = await member(r, "repixelizer");
|
||||
const b = await member(r);
|
||||
const as = (app: string, appSecret: string, token: string, i: number) => assertStepUp(r, { app, headers: { "x-heimdall-app-secret": appSecret }, token, nonce: nonce(`i${i}`) });
|
||||
for (let i = 0; i < 50; i += 1) await as("streampixels", "streampixels-secret", sp.token, i);
|
||||
expect((await as("streampixels", "streampixels-secret", sp.token, 99)).statusCode).toBe(429);
|
||||
expect(refused(await as("repixelizer", "repixelizer-secret", rp.token, 1))).toEqual([403, "step_up_assertion_not_permitted"]);
|
||||
expect((await assertStepUp(r, { token: b.token })).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("a flood is not an audit flood: an app without the grant is audited once per window, a tripped budget once per window", async () => {
|
||||
const r = await rig();
|
||||
const sp = await member(r, "streampixels");
|
||||
vi.useFakeTimers({ toFake: ["Date"] });
|
||||
const codes: Record<number, number> = {};
|
||||
for (let i = 0; i < 500; i += 1) {
|
||||
const res = await assertStepUp(r, { app: "streampixels", headers: { "x-heimdall-app-secret": "streampixels-secret" }, token: sp.token, nonce: nonce(`f${i}`) });
|
||||
codes[res.statusCode] = (codes[res.statusCode] ?? 0) + 1;
|
||||
}
|
||||
expect(codes).toEqual({ 403: STEP_UP_ASSERT_LIMITS.notPermitted.max, 429: 500 - STEP_UP_ASSERT_LIMITS.notPermitted.max });
|
||||
const rows = (code: string) => auditOf(r, "step_up_assertion_refused").filter((e) => e.eventPayloadJson.code === code);
|
||||
expect(rows("step_up_assertion_not_permitted")).toHaveLength(1);
|
||||
expect(rows("step_up_rate_limited")).toHaveLength(1);
|
||||
expect(rows("step_up_rate_limited")[0]!.eventPayloadJson.budget).toBe("notPermitted");
|
||||
vi.setSystemTime(Date.now() + STEP_UP_ASSERT_LIMITS.notPermitted.windowMs + 1000);
|
||||
await assertStepUp(r, { app: "streampixels", headers: { "x-heimdall-app-secret": "streampixels-secret" }, token: sp.token });
|
||||
expect(rows("step_up_assertion_not_permitted")).toHaveLength(2);
|
||||
|
||||
// The same for the granted app's per-app and per-account budgets.
|
||||
const m = await member(r);
|
||||
const before = r.audit.length;
|
||||
for (let i = 0; i < 300; i += 1) await assertStepUp(r, { token: "garbage", nonce: nonce(`g${i}`) });
|
||||
expect(r.audit.length - before, "garbage-bearer refusals up to the budget, then one row for the trip").toBe(STEP_UP_ASSERT_LIMITS.app.max + 1);
|
||||
vi.setSystemTime(Date.now() + STEP_UP_ASSERT_LIMITS.app.windowMs + 1000);
|
||||
const mark = r.audit.length;
|
||||
for (let i = 0; i < 30; i += 1) await assertStepUp(r, { token: m.token, nonce: nonce(`a${i}`) });
|
||||
const accountRows = r.audit.slice(mark);
|
||||
expect(accountRows.filter((e) => e.eventType === "step_up_asserted")).toHaveLength(STEP_UP_ASSERT_LIMITS.account.max);
|
||||
const trips = accountRows.filter((e) => e.eventPayloadJson.code === "step_up_rate_limited");
|
||||
expect(trips.map((e) => e.eventPayloadJson.budget)).toEqual(["account"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("receipts", () => {
|
||||
it("records every assertion and every post-secret refusal with account, app, session, method, outcome and time, and nothing secret", async () => {
|
||||
const r = await rig();
|
||||
const m = await member(r);
|
||||
const sp = await member(r, "streampixels");
|
||||
const printed: string[] = [];
|
||||
for (const channel of ["log", "info", "warn", "error", "debug"] as const) vi.spyOn(console, channel).mockImplementation((...a) => void printed.push(a.join(" ")));
|
||||
vi.spyOn(process.stdout, "write").mockImplementation((chunk: unknown) => (printed.push(String(chunk)), true));
|
||||
vi.spyOn(process.stderr, "write").mockImplementation((chunk: unknown) => (printed.push(String(chunk)), true));
|
||||
|
||||
const nonceOk = nonce("ok-CANARY");
|
||||
const nonceBadMethod = nonce("bad-CANARY");
|
||||
const responses = [
|
||||
await assertStepUp(r, { token: m.token, nonce: nonceOk }),
|
||||
await assertStepUp(r, { token: m.token, nonce: nonceOk }),
|
||||
await assertStepUp(r, { token: m.token, method: "evil-CANARY-method", nonce: nonceBadMethod }),
|
||||
await assertStepUp(r, { token: sp.token, nonce: nonce("mismatch-CANARY") }),
|
||||
await assertStepUp(r, { token: "garbage-CANARY", nonce: nonce("anon-CANARY") }),
|
||||
];
|
||||
expect(responses.map((x) => x.statusCode)).toEqual([201, 409, 400, 403, 401]);
|
||||
|
||||
const ok = auditOf(r, "step_up_asserted");
|
||||
expect(ok).toHaveLength(1);
|
||||
expect(ok[0]).toMatchObject({ accountId: m.account.id, sessionId: m.sid, appSlug: "bifrost", eventPayloadJson: { outcome: "asserted", method: "bifrost-passkey" } });
|
||||
expect(Date.parse(ok[0]!.createdAt)).not.toBeNaN();
|
||||
const refusals = auditOf(r, "step_up_assertion_refused");
|
||||
expect(refusals.map((e) => e.eventPayloadJson.code)).toEqual(["step_up_nonce_replayed", "unknown_step_up_method", "bearer_app_mismatch", "sign_in_required"]);
|
||||
expect(refusals.map((e) => e.accountId)).toEqual([m.account.id, m.account.id, sp.account.id, undefined]);
|
||||
expect(refusals[1]!.eventPayloadJson.method).toBeNull();
|
||||
expect(refusals.every((e) => e.appSlug === "bifrost" && e.eventPayloadJson.outcome === "refused")).toBe(true);
|
||||
for (const e of [...ok, ...refusals.slice(0, 2)]) expect(e.eventPayloadJson.nonceDigest).toMatch(/^[0-9a-f]{64}$/);
|
||||
|
||||
const everything = JSON.stringify([r.audit, printed, responses.map((x) => x.body.replace(/"accessToken":"[^"]+"/, ""))]);
|
||||
const minted = responses[0]!.json().accessToken as string;
|
||||
const secrets = [secret, m.token, sp.token, m.issued.refreshToken, "CANARY"];
|
||||
for (const needle of secrets) expect(everything, needle).not.toContain(needle);
|
||||
expect(JSON.stringify(r.audit)).not.toContain(minted);
|
||||
expect(printed.join("")).not.toContain(minted);
|
||||
// A stored session row holds nothing the minted token adds.
|
||||
expect(JSON.stringify(await r.store.findSession("bifrost", m.sid))).not.toContain("step_up");
|
||||
});
|
||||
});
|
||||
209
tests/step-up.test.ts
Normal file
209
tests/step-up.test.ts
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterEach, describe, expect, it } from "vitest";
|
||||
import { buildApp } from "../src/app.js";
|
||||
import { type OAuthProviderRuntime } from "../src/oauth.js";
|
||||
import { buildAuthorizationUrl, providerCatalog } from "../src/providers.js";
|
||||
import { createRuntimeKeyMaterial, decodeJwt, signJwt, verifyJwt } from "../src/signing.js";
|
||||
import { InMemoryStore } from "../src/store/index.js";
|
||||
import { createTestConfig, launchFlow, launchWithRedirect } from "./oauth-flow.js";
|
||||
|
||||
// A sign_in step-up asks the provider for a real re-authentication. It is the
|
||||
// authenticated app's request (never a browser's), it rides in the signed state
|
||||
// only, it is off unless asked for, and a provider that has no such parameter is
|
||||
// refused at start. These tests drive it as StreamPixels does: its own app
|
||||
// secret, twitch and youtube sign_in starts, then the launch hop and redeem.
|
||||
|
||||
const returnTo = "https://streampixels.gamecult.org/signin/return";
|
||||
const spAuth = { "x-heimdall-app-secret": "streampixels-secret" };
|
||||
|
||||
function runtime(provider: "twitch" | "youtube", providerUserId: string): OAuthProviderRuntime {
|
||||
return {
|
||||
async exchangeAuthorizationCode() {
|
||||
return { accessToken: "at", refreshToken: "rt", tokenType: "Bearer", scope: ["user:read:email"], raw: {} };
|
||||
},
|
||||
async resolveIdentity() {
|
||||
return { provider, providerUserId, username: providerUserId, profile: { id: providerUserId } };
|
||||
},
|
||||
async evaluateEntitlements() {
|
||||
return { facts: [], snapshots: [] };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const apps: Awaited<ReturnType<typeof buildApp>>[] = [];
|
||||
afterEach(async () => {
|
||||
await Promise.all(apps.splice(0).map((app) => app.close()));
|
||||
});
|
||||
|
||||
async function rig(config = createTestConfig()) {
|
||||
const app = await buildApp({
|
||||
config,
|
||||
store: new InMemoryStore(),
|
||||
oauthRuntimes: { twitch: runtime("twitch", "t-1"), youtube: runtime("youtube", "y-1") },
|
||||
});
|
||||
apps.push(app);
|
||||
return app;
|
||||
}
|
||||
|
||||
type App = Awaited<ReturnType<typeof rig>>;
|
||||
|
||||
function start(
|
||||
app: App,
|
||||
provider: string,
|
||||
payload: Record<string, unknown> = {},
|
||||
headers: Record<string, string> = {},
|
||||
appSlug = "streampixels",
|
||||
url = returnTo
|
||||
) {
|
||||
return app.inject({ method: "POST", url: `/v1/oauth/${provider}/start`, headers, payload: { appSlug, mode: "sign_in", returnTo: url, ...payload } });
|
||||
}
|
||||
|
||||
describe("step-up on a sign_in start: the provider URL", () => {
|
||||
it("asks nothing extra without stepUp, for every provider StreamPixels signs in with", async () => {
|
||||
const app = await rig();
|
||||
for (const provider of ["twitch", "youtube"]) {
|
||||
for (const extra of [{}, { stepUp: false }]) {
|
||||
const started = await start(app, provider, extra);
|
||||
expect(started.statusCode).toBe(201);
|
||||
expect(decodeJwt(new URL(started.json().authorizationUrl).searchParams.get("state") ?? "").payload.step_up).toBeNull();
|
||||
const url = (await launchWithRedirect(app, started.json())).url;
|
||||
expect(url.searchParams.has("force_verify")).toBe(false);
|
||||
expect(url.searchParams.get("prompt")).toBe(provider === "youtube" ? "consent" : null);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("with stepUp and the app secret: twitch force_verify=true, youtube prompt=login consent, state records it", async () => {
|
||||
const app = await rig();
|
||||
const twitch = await start(app, "twitch", { stepUp: true }, spAuth);
|
||||
expect(twitch.statusCode).toBe(201);
|
||||
expect(decodeJwt(new URL(twitch.json().authorizationUrl).searchParams.get("state") ?? "").payload.step_up).toBe(true);
|
||||
expect((await launchWithRedirect(app, twitch.json())).url.searchParams.get("force_verify")).toBe("true");
|
||||
|
||||
const youtube = await start(app, "youtube", { stepUp: true }, spAuth);
|
||||
expect(youtube.statusCode).toBe(201);
|
||||
expect((await launchWithRedirect(app, youtube.json())).url.searchParams.get("prompt")).toBe("login consent");
|
||||
});
|
||||
|
||||
it("Google (a Bifrost sign_in provider) gets prompt=login in place of select_account", async () => {
|
||||
const app = await rig();
|
||||
const bifrostReturn = "https://bifrost.gamecult.org/auth/heimdall/return";
|
||||
const plain = await start(app, "google", {}, { "x-heimdall-app-secret": "bifrost-secret" }, "bifrost", bifrostReturn);
|
||||
expect((await launchWithRedirect(app, plain.json())).url.searchParams.get("prompt")).toBe("select_account");
|
||||
const stepped = await start(app, "google", { stepUp: true }, { "x-heimdall-app-secret": "bifrost-secret" }, "bifrost", bifrostReturn);
|
||||
expect(stepped.statusCode).toBe(201);
|
||||
expect((await launchWithRedirect(app, stepped.json())).url.searchParams.get("prompt")).toBe("login");
|
||||
});
|
||||
});
|
||||
|
||||
describe("step-up refusals", () => {
|
||||
it("is the app's request: no secret or a wrong secret is 401 app_auth_required, while the same start without stepUp stays open", async () => {
|
||||
const app = await rig();
|
||||
for (const headers of [{}, { "x-heimdall-app-secret": "wrong" }]) {
|
||||
const res = await start(app, "twitch", { stepUp: true }, headers);
|
||||
expect([res.statusCode, res.json().error]).toEqual([401, "app_auth_required"]);
|
||||
}
|
||||
expect((await start(app, "twitch", {}, {})).statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it("a provider with no re-authentication parameter is a typed refusal, with the secret, never a silent pass", async () => {
|
||||
const app = await rig();
|
||||
const bifrost = { "x-heimdall-app-secret": "bifrost-secret" };
|
||||
const res = await start(app, "discord", { stepUp: true }, bifrost, "bifrost", "https://bifrost.gamecult.org/auth/heimdall/return");
|
||||
expect([res.statusCode, res.json().error, res.json().provider]).toEqual([400, "step_up_not_supported", "discord"]);
|
||||
// The URL builder holds the same line: it throws rather than omit the step.
|
||||
for (const provider of ["discord", "patreon", "github", "spotify", "joystick"] as const) {
|
||||
expect(providerCatalog[provider].stepUpAuthorizationParams, provider).toBeUndefined();
|
||||
expect(() =>
|
||||
buildAuthorizationUrl({ provider, clientId: "c", redirectUri: "https://x/cb", state: "s", requestedScopes: undefined, stepUp: true })
|
||||
).toThrow(/no re-authentication parameter/);
|
||||
}
|
||||
expect(Object.keys(providerCatalog).filter((p) => providerCatalog[p as keyof typeof providerCatalog].stepUpAuthorizationParams).sort()).toEqual(["google", "twitch", "youtube"]);
|
||||
});
|
||||
|
||||
it("is sign_in only: link and connect starts carrying stepUp are 400 step_up_only_in_sign_in", async () => {
|
||||
const app = await rig();
|
||||
for (const mode of ["link", "connect"]) {
|
||||
const res = await start(app, "twitch", { mode, stepUp: true }, spAuth);
|
||||
expect([res.statusCode, res.json().error]).toEqual([400, "step_up_only_in_sign_in"]);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("the flag is the signed state's, not the redeem side's", () => {
|
||||
it("a completion reports stepUpRequested only when the start asked, and a stepUp handed to redeem changes nothing", async () => {
|
||||
const app = await rig();
|
||||
for (const asked of [true, false]) {
|
||||
const started = await start(app, "twitch", asked ? { stepUp: true } : {}, asked ? spAuth : {});
|
||||
const flow = await launchFlow(app, started.json());
|
||||
const called = await app.inject({
|
||||
method: "GET",
|
||||
url: `/v1/oauth/twitch/callback?code=c&state=${encodeURIComponent(flow.state)}`,
|
||||
headers: { cookie: flow.cookie, accept: "application/json" },
|
||||
});
|
||||
expect(called.statusCode).toBe(201);
|
||||
const code = called.json().completion.code as string;
|
||||
|
||||
// A stepUp handed to redeem is not read: the answer reflects the start, whatever the body says.
|
||||
const redeemed = await app.inject({ method: "POST", url: "/v1/apps/streampixels/auth-completions/redeem", payload: { completionCode: code, stepUp: true } });
|
||||
expect(redeemed.statusCode).toBe(201);
|
||||
expect(redeemed.json().stepUpRequested).toBe(asked ? true : undefined);
|
||||
// The proof is the signed state's too: the claim carries step_up_at exactly when the start asked.
|
||||
expect(typeof redeemed.json().claimSet.step_up_at).toBe(asked ? "number" : "undefined");
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("a forged or odd state cannot carry a step-up the start would not have signed", () => {
|
||||
// A real signing key on disk, so the test can re-sign a state as only Heimdall's key holder could.
|
||||
const dir = mkdtempSync(join(tmpdir(), "heimdall-stepup-"));
|
||||
const config = { ...createTestConfig(), signingPrivateKeyPath: join(dir, "signing.pem"), bootstrapSigningPrivateKeyOnMissing: true };
|
||||
// The app creates the key on first boot; read it only after the rig exists.
|
||||
const loadKeys = (c: typeof config) => createRuntimeKeyMaterial({ ...c, bootstrapSigningPrivateKeyOnMissing: false });
|
||||
|
||||
async function forgedState(app: App, provider: string, headers: Record<string, string>, stepUp: unknown, appSlug = "streampixels", url = returnTo) {
|
||||
const started = await start(app, provider, {}, headers, appSlug, url);
|
||||
const real = new URL(started.json().authorizationUrl).searchParams.get("state") ?? "";
|
||||
const keys = loadKeys(config);
|
||||
const verified = verifyJwt(real, keys.publicKey) as { valid: boolean; payload: Record<string, unknown> };
|
||||
expect(verified.valid, "the test key signs what the app verifies").toBe(true);
|
||||
return { real, forged: signJwt({ ...verified.payload, step_up: stepUp }, keys) };
|
||||
}
|
||||
const launch = (app: App, provider: string, state: string) => app.inject({ method: "GET", url: `/v1/oauth/${provider}/launch?state=${encodeURIComponent(state)}` });
|
||||
|
||||
it("rejects any step_up that is not null or true as invalid_state at the launch hop", async () => {
|
||||
const app = await rig(config);
|
||||
expect((await launch(app, "twitch", (await forgedState(app, "twitch", {}, true)).forged)).statusCode, "a well-formed true still launches").toBe(302);
|
||||
for (const odd of ["true", "yes", 1, 0, false, {}, []]) {
|
||||
const res = await launch(app, "twitch", (await forgedState(app, "twitch", {}, odd)).forged);
|
||||
expect([res.statusCode, res.json().error], JSON.stringify(odd)).toEqual([400, "invalid_state"]);
|
||||
}
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it("a step-up state for a provider with no re-authentication parameter fails closed and does not burn the state", async () => {
|
||||
const dir2 = mkdtempSync(join(tmpdir(), "heimdall-stepup-"));
|
||||
const config2 = { ...createTestConfig(), signingPrivateKeyPath: join(dir2, "signing.pem"), bootstrapSigningPrivateKeyOnMissing: true };
|
||||
try {
|
||||
const app = await rig(config2);
|
||||
const bifrost = { "x-heimdall-app-secret": "bifrost-secret" };
|
||||
const started = await start(app, "discord", {}, bifrost, "bifrost", "https://bifrost.gamecult.org/auth/heimdall/return");
|
||||
const real = new URL(started.json().authorizationUrl).searchParams.get("state") ?? "";
|
||||
const keys2 = loadKeys(config2);
|
||||
const verified = verifyJwt(real, keys2.publicKey) as { valid: boolean; payload: Record<string, unknown> };
|
||||
expect(verified.valid).toBe(true);
|
||||
const forged = signJwt({ ...verified.payload, step_up: true }, keys2);
|
||||
for (let attempt = 0; attempt < 2; attempt += 1) {
|
||||
const res = await launch(app, "discord", forged);
|
||||
expect(res.statusCode, "never a redirect without the step").toBe(500);
|
||||
expect(res.headers.location).toBeUndefined();
|
||||
}
|
||||
// Not "state_already_launched": the refused launches did not claim the state.
|
||||
expect((await launch(app, "discord", real)).statusCode).toBe(302);
|
||||
} finally {
|
||||
rmSync(dir2, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
|
@ -3,7 +3,7 @@ import { Pool } from "pg";
|
|||
import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
|
||||
import { newDb } from "pg-mem";
|
||||
import { type HeimdallConfig } from "../src/config.js";
|
||||
import { createStore } from "../src/store/index.js";
|
||||
import { createStore, IdentityHeldElsewhereError, InMemoryStore, type HeimdallStore } from "../src/store/index.js";
|
||||
import {
|
||||
createPostgresStore,
|
||||
PostgresStore,
|
||||
|
|
@ -14,7 +14,12 @@ import {
|
|||
samePredicate,
|
||||
STORE_TABLE_PRIVILEGES,
|
||||
} from "../src/store/postgres.js";
|
||||
import { REQUIRED_COLUMNS, REQUIRED_KEYS, REQUIRED_TABLES } from "../src/store/schema.js";
|
||||
import {
|
||||
OAUTH_STATE_PRUNE_BATCH,
|
||||
OAUTH_STATE_PRUNE_MARGIN_MS,
|
||||
OAUTH_STATE_SKEW_MS,
|
||||
} from "../src/store/types.js";
|
||||
import { CREATE_SCHEMA_SQL, REQUIRED_COLUMNS, REQUIRED_KEYS, REQUIRED_TABLES } from "../src/store/schema.js";
|
||||
|
||||
describe("PostgresStore", () => {
|
||||
it("round-trips core auth records through postgres", async () => {
|
||||
|
|
@ -198,6 +203,244 @@ describe("PostgresStore", () => {
|
|||
});
|
||||
});
|
||||
|
||||
// linked_identities has one writer that can move a row between accounts: none.
|
||||
// upsert refreshes the holder's own row and refuses another account's; unlink is
|
||||
// the only delete, and it never takes an account's last identity.
|
||||
const unlinkStores: Array<[string, () => Promise<HeimdallStore>]> = [
|
||||
["InMemoryStore", async () => new InMemoryStore()],
|
||||
[
|
||||
"PostgresStore on pg-mem",
|
||||
async () => {
|
||||
const store = new PostgresStore(new (newDb().adapters.createPg().Pool)());
|
||||
await store.ensureSchema();
|
||||
return store;
|
||||
},
|
||||
],
|
||||
];
|
||||
describe.each(unlinkStores)("linked_identities writes, %s", (_name, make) => {
|
||||
const at = "2026-11-13T12:00:00.000Z";
|
||||
const input = (accountId: string, providerUserId: string, extra: Record<string, unknown> = {}) => ({
|
||||
accountId,
|
||||
provider: "discord" as const,
|
||||
providerUserId,
|
||||
scopes: ["identify"],
|
||||
profileJson: {},
|
||||
createdAt: at,
|
||||
updatedAt: at,
|
||||
...extra,
|
||||
});
|
||||
async function twoAccounts() {
|
||||
const store = await make();
|
||||
const a = await store.createAccount({ createdAt: at, lastSeenAt: at });
|
||||
const b = await store.createAccount({ createdAt: at, lastSeenAt: at });
|
||||
return { store, a, b };
|
||||
}
|
||||
|
||||
// pg-mem has neither ON CONFLICT ... WHERE nor row locks: these two run on real Postgres below.
|
||||
const realPostgresOnly = _name !== "InMemoryStore";
|
||||
|
||||
it.skipIf(realPostgresOnly)("upsert on an identity another account holds throws IdentityHeldElsewhereError and leaves the row untouched", async () => {
|
||||
const { store, a, b } = await twoAccounts();
|
||||
const held = await store.upsertLinkedIdentity(input(a.id, "u1", { username: "original", accessTokenEncrypted: "keep" }));
|
||||
await expect(
|
||||
store.upsertLinkedIdentity(input(b.id, "u1", { username: "thief", accessTokenEncrypted: "stolen", updatedAt: "2027-01-01T00:00:00.000Z" }))
|
||||
).rejects.toBeInstanceOf(IdentityHeldElsewhereError);
|
||||
expect(await store.findStoredLinkedIdentity("discord", "u1")).toEqual(held);
|
||||
expect(await store.listStoredLinkedIdentitiesForAccount(b.id)).toEqual([]);
|
||||
});
|
||||
|
||||
it.skipIf(realPostgresOnly)("moveIdentities keeps one contract: moved, replayed, conflict, lapsed proof, coverage, reversal", async () => {
|
||||
await exerciseMoveContract(await make());
|
||||
});
|
||||
|
||||
it("upsert by the holder still refreshes its own row, keeping its id", async () => {
|
||||
const { store, a } = await twoAccounts();
|
||||
const first = await store.upsertLinkedIdentity(input(a.id, "u1", { username: "one" }));
|
||||
const again = await store.upsertLinkedIdentity(input(a.id, "u1", { username: "two", updatedAt: "2026-11-14T00:00:00.000Z" }));
|
||||
expect([again.id, again.accountId, again.username]).toEqual([first.id, a.id, "two"]);
|
||||
});
|
||||
|
||||
it("unlink: deletes one of two, refuses the last, reports another account's or a missing id as not_found", async () => {
|
||||
const { store, a, b } = await twoAccounts();
|
||||
const one = await store.upsertLinkedIdentity(input(a.id, "u1"));
|
||||
const two = await store.upsertLinkedIdentity(input(a.id, "u2"));
|
||||
const theirs = await store.upsertLinkedIdentity(input(b.id, "u3"));
|
||||
expect(await store.unlinkLinkedIdentity(a.id, theirs.id)).toEqual({ kind: "not_found" });
|
||||
expect(await store.unlinkLinkedIdentity(a.id, "no-such")).toEqual({ kind: "not_found" });
|
||||
expect(await store.unlinkLinkedIdentity(b.id, theirs.id)).toEqual({ kind: "last_identity" });
|
||||
const done = await store.unlinkLinkedIdentity(a.id, one.id);
|
||||
expect(done).toMatchObject({ kind: "unlinked", identity: { id: one.id, provider: "discord", providerUserId: "u1" } });
|
||||
expect(await store.unlinkLinkedIdentity(a.id, two.id)).toEqual({ kind: "last_identity" });
|
||||
expect((await store.listStoredLinkedIdentitiesForAccount(a.id)).map((i) => i.id)).toEqual([two.id]);
|
||||
expect(await store.findStoredLinkedIdentity("discord", "u3")).toMatchObject({ id: theirs.id, accountId: b.id });
|
||||
});
|
||||
|
||||
it.skipIf(realPostgresOnly)("two concurrent unlinks of an account's last two identities leave exactly one", async () => {
|
||||
const { store, a } = await twoAccounts();
|
||||
const one = await store.upsertLinkedIdentity(input(a.id, "u1"));
|
||||
const two = await store.upsertLinkedIdentity(input(a.id, "u2"));
|
||||
const results = await Promise.all([store.unlinkLinkedIdentity(a.id, one.id), store.unlinkLinkedIdentity(a.id, two.id)]);
|
||||
expect(results.map((r) => r.kind).sort()).toEqual(["last_identity", "unlinked"]);
|
||||
expect(await store.listStoredLinkedIdentitiesForAccount(a.id)).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("consent_receipts foreign key", () => {
|
||||
it("a revocation names a receipt of its own account: the schema says so and the memory store enforces it", async () => {
|
||||
expect(CREATE_SCHEMA_SQL).toContain("FOREIGN KEY (revokes_receipt_id, account_id) REFERENCES consent_receipts(id, account_id)");
|
||||
const store = new InMemoryStore();
|
||||
const base = { appSlug: "streampixels" as const, provider: "joystick" as const, createdAt: "2026-11-08T00:00:00.000Z" };
|
||||
const { receipt: grant } = await store.createConsentReceipt({ ...base, accountId: "a", kind: "grant", scopesAsked: [], scopesGranted: [], consentPageDigest: "d", consentText: "t" });
|
||||
await expect(store.createConsentReceipt({ ...base, accountId: "b", kind: "revocation", revokesReceiptId: grant.id })).rejects.toThrow(/own account/);
|
||||
await expect(store.createConsentReceipt({ ...base, accountId: "a", kind: "revocation", revokesReceiptId: "no-such" })).rejects.toThrow(/own account/);
|
||||
expect(await store.listConsentReceipts("a")).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("PostgresStore.createConsentReceipt revocation conflict", () => {
|
||||
async function granted() {
|
||||
const adapter = newDb().adapters.createPg();
|
||||
const store = new PostgresStore(new adapter.Pool());
|
||||
await store.ensureSchema();
|
||||
const now = "2026-11-08T00:00:00.000Z";
|
||||
const account = await store.createAccount({ createdAt: now, lastSeenAt: now, displayName: "Probe" });
|
||||
const base = { accountId: account.id, appSlug: "streampixels" as const, provider: "joystick" as const };
|
||||
const { receipt: grant } = await store.createConsentReceipt({ ...base, kind: "grant", createdAt: now, scopesAsked: ["a"], scopesGranted: ["a"], consentPageDigest: "d", consentText: "t" });
|
||||
return { store, base, grant };
|
||||
}
|
||||
|
||||
it("a second revocation of one grant inserts nothing: created:false, the first row's id", async () => {
|
||||
const { store, base, grant } = await granted();
|
||||
const first = await store.createConsentReceipt({ ...base, kind: "revocation", createdAt: "2026-11-08T01:00:00.000Z", revokesReceiptId: grant.id });
|
||||
const second = await store.createConsentReceipt({ ...base, kind: "revocation", createdAt: "2026-11-08T02:00:00.000Z", revokesReceiptId: grant.id });
|
||||
expect(first.created).toBe(true);
|
||||
expect(second.created).toBe(false);
|
||||
expect(second.receipt.id).toBe(first.receipt.id);
|
||||
expect(second.receipt.createdAt).toBe("2026-11-08T01:00:00.000Z");
|
||||
expect((await store.listConsentReceipts(base.accountId)).filter((r) => r.kind === "revocation")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("the read-back returns the revocation of this grant, not another's or the grant", async () => {
|
||||
const { store, base, grant } = await granted();
|
||||
const other = (await store.createConsentReceipt({ ...base, kind: "grant", createdAt: "2026-11-08T00:30:00.000Z", scopesAsked: [], scopesGranted: [], consentPageDigest: "d2", consentText: "t2" })).receipt;
|
||||
const otherRevocation = await store.createConsentReceipt({ ...base, kind: "revocation", createdAt: "2026-11-08T01:00:00.000Z", revokesReceiptId: other.id });
|
||||
const first = await store.createConsentReceipt({ ...base, kind: "revocation", createdAt: "2026-11-08T01:10:00.000Z", revokesReceiptId: grant.id });
|
||||
const second = await store.createConsentReceipt({ ...base, kind: "revocation", createdAt: "2026-11-08T02:00:00.000Z", revokesReceiptId: grant.id });
|
||||
expect(second.receipt.id).toBe(first.receipt.id);
|
||||
expect(second.receipt.id).not.toBe(otherRevocation.receipt.id);
|
||||
expect(second.receipt).toMatchObject({ kind: "revocation", revokesReceiptId: grant.id });
|
||||
});
|
||||
});
|
||||
|
||||
describe("InMemoryStore.createConsentReceipt", () => {
|
||||
it("writes one revocation per grant: the second names the first and is not created", async () => {
|
||||
const store = new InMemoryStore();
|
||||
const base = { accountId: "a", appSlug: "streampixels" as const, provider: "joystick" as const, createdAt: "2026-11-08T00:00:00.000Z" };
|
||||
const { receipt: grant } = await store.createConsentReceipt({ ...base, kind: "grant", scopesAsked: [], scopesGranted: [], consentPageDigest: "d", consentText: "t" });
|
||||
const first = await store.createConsentReceipt({ ...base, kind: "revocation", revokesReceiptId: grant.id });
|
||||
const second = await store.createConsentReceipt({ ...base, createdAt: "2026-11-09T00:00:00.000Z", kind: "revocation", revokesReceiptId: grant.id });
|
||||
expect([first.created, second.created]).toEqual([true, false]);
|
||||
expect(second.receipt).toEqual(first.receipt);
|
||||
expect(await store.listConsentReceipts("a")).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("InMemoryStore.claimOAuthStateUse", () => {
|
||||
const use = {
|
||||
jti: "state-1",
|
||||
phase: "launch" as const,
|
||||
appSlug: "repixelizer" as const,
|
||||
usedAt: "2026-04-26T12:00:00.000Z",
|
||||
expiresAt: "2026-04-26T12:10:00.000Z",
|
||||
};
|
||||
|
||||
it("is true once per (jti, phase)", async () => {
|
||||
const store = new InMemoryStore();
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(true);
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(false);
|
||||
expect(await store.claimOAuthStateUse({ ...use, phase: "callback" })).toBe(true);
|
||||
expect(await store.claimOAuthStateUse({ ...use, phase: "callback" })).toBe(false);
|
||||
expect(await store.claimOAuthStateUse({ ...use, jti: "state-2" })).toBe(true);
|
||||
});
|
||||
|
||||
it("drops a record only once its state's exp + skew + margin has passed", async () => {
|
||||
const store = new InMemoryStore();
|
||||
await store.claimOAuthStateUse(use);
|
||||
const expMs = Date.parse(use.expiresAt);
|
||||
const at = (ms: number) => new Date(ms).toISOString();
|
||||
// Inside the skew past expiry the state still verifies, and the margin keeps the record beyond that.
|
||||
await store.claimOAuthStateUse({ ...use, jti: "state-2", usedAt: at(expMs + OAUTH_STATE_SKEW_MS) });
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(false);
|
||||
const boundary = expMs + OAUTH_STATE_SKEW_MS + OAUTH_STATE_PRUNE_MARGIN_MS;
|
||||
await store.claimOAuthStateUse({ ...use, jti: "state-3", usedAt: at(boundary - 1) });
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(false);
|
||||
// At exactly exp + skew + margin the record is prunable (the rule is <=).
|
||||
await store.claimOAuthStateUse({ ...use, jti: "state-4", usedAt: at(boundary) });
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(true);
|
||||
});
|
||||
|
||||
it("removes at most one batch of prunable records per successful claim", async () => {
|
||||
const store = new InMemoryStore();
|
||||
const expMs = Date.parse(use.expiresAt);
|
||||
const total = OAUTH_STATE_PRUNE_BATCH * 2 + 7;
|
||||
for (let i = 0; i < total; i += 1) await store.claimOAuthStateUse({ ...use, jti: `old-${i}` });
|
||||
const size = () => (store as unknown as { oauthStateUses: Map<string, string> }).oauthStateUses.size;
|
||||
expect(size()).toBe(total);
|
||||
const later = new Date(expMs + OAUTH_STATE_SKEW_MS + OAUTH_STATE_PRUNE_MARGIN_MS).toISOString();
|
||||
await store.claimOAuthStateUse({ ...use, jti: "fresh-1", usedAt: later, expiresAt: later });
|
||||
expect(size()).toBe(total + 1 - OAUTH_STATE_PRUNE_BATCH);
|
||||
// A refused (replayed) claim prunes nothing, as on Postgres where the delete follows a new row.
|
||||
await store.claimOAuthStateUse({ ...use, jti: "fresh-1", usedAt: later, expiresAt: later });
|
||||
expect(size()).toBe(total + 1 - OAUTH_STATE_PRUNE_BATCH);
|
||||
});
|
||||
});
|
||||
|
||||
describe("PostgresStore.claimOAuthStateUse retention", () => {
|
||||
const use = {
|
||||
jti: "state-1",
|
||||
phase: "launch" as const,
|
||||
appSlug: "repixelizer" as const,
|
||||
usedAt: "2026-04-26T12:00:00.000Z",
|
||||
expiresAt: "2026-04-26T12:10:00.000Z",
|
||||
};
|
||||
|
||||
function doublePool(prune: "ok" | "throws", inserted = 1) {
|
||||
const calls: Array<{ sql: string; params: unknown[] }> = [];
|
||||
const pool = {
|
||||
query: async (sql: string, params: unknown[]) => {
|
||||
calls.push({ sql, params });
|
||||
if (calls.length === 1) return { rowCount: inserted, rows: [] };
|
||||
if (prune === "throws") throw Object.assign(new Error("permission denied for table oauth_state_uses"), { code: "42501" });
|
||||
return { rowCount: 0, rows: [] };
|
||||
},
|
||||
};
|
||||
return { calls, store: new PostgresStore(pool as unknown as Pool) };
|
||||
}
|
||||
|
||||
it("runs one bounded delete after a new row, at the shared cutoff and batch", async () => {
|
||||
const { calls, store } = doublePool("ok");
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(true);
|
||||
expect(calls).toHaveLength(2);
|
||||
expect(calls[1]!.sql).toMatch(/DELETE FROM oauth_state_uses/);
|
||||
expect(calls[1]!.params).toEqual([
|
||||
new Date(Date.parse(use.usedAt) - OAUTH_STATE_SKEW_MS - OAUTH_STATE_PRUNE_MARGIN_MS),
|
||||
OAUTH_STATE_PRUNE_BATCH,
|
||||
]);
|
||||
});
|
||||
|
||||
it("prunes nothing when the claim is a replay", async () => {
|
||||
const { calls, store } = doublePool("ok", 0);
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(false);
|
||||
expect(calls).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("a failing prune does not change the claim's result", async () => {
|
||||
const { calls, store } = doublePool("throws");
|
||||
expect(await store.claimOAuthStateUse(use)).toBe(true);
|
||||
expect(calls).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("createPostgresStore", () => {
|
||||
// pg emits an idle client's connection loss on the pool. With no listener
|
||||
// that event kills the process, and Node prints the pg Client with its
|
||||
|
|
@ -232,12 +475,16 @@ describe("PostgresStore.checkSchema", () => {
|
|||
"sessions",
|
||||
"auth_attempts",
|
||||
"private_command_receipts",
|
||||
"pending_links",
|
||||
"auth_completions",
|
||||
"oauth_state_uses",
|
||||
"capability_grants",
|
||||
"entitlement_snapshots",
|
||||
"consent_receipts",
|
||||
"identity_moves",
|
||||
"audit_events",
|
||||
]);
|
||||
expect(REQUIRED_COLUMNS).toHaveLength(85);
|
||||
expect(REQUIRED_COLUMNS).toHaveLength(121);
|
||||
expect(REQUIRED_COLUMNS).toEqual(
|
||||
expect.arrayContaining([
|
||||
{ table: "auth_completions", column: "code", type: "TEXT", nullable: false },
|
||||
|
|
@ -248,11 +495,15 @@ describe("PostgresStore.checkSchema", () => {
|
|||
{ table: "auth_completions", column: "attempt_id", type: "TEXT", nullable: true },
|
||||
])
|
||||
);
|
||||
expect(REQUIRED_KEYS).toHaveLength(12);
|
||||
expect(REQUIRED_KEYS).toHaveLength(19);
|
||||
expect(REQUIRED_KEYS).toEqual(
|
||||
expect.arrayContaining([
|
||||
{ table: "linked_identities", columns: "provider,provider_user_id", predicate: "" },
|
||||
{ table: "private_command_receipts", columns: "app_slug,idempotency_key", predicate: "" },
|
||||
{ table: "oauth_state_uses", columns: "jti,phase", predicate: "" },
|
||||
{ table: "consent_receipts", columns: "revokes_receipt_id", predicate: "revokes_receipt_id IS NOT NULL" },
|
||||
{ table: "consent_receipts", columns: "account_id,id", predicate: "" },
|
||||
{ table: "identity_moves", columns: "reverses_move_id", predicate: "reverses_move_id IS NOT NULL" },
|
||||
{ table: "entitlement_snapshots", columns: "account_id,provider,scope", predicate: "" },
|
||||
{ table: "auth_completions", columns: "app_slug,attempt_id", predicate: "attempt_id IS NOT NULL AND consumed_at IS NULL" },
|
||||
])
|
||||
|
|
@ -329,6 +580,8 @@ async function exerciseStore(store: PostgresStore): Promise<Set<string>> {
|
|||
const linked = await s.upsertLinkedIdentity(identity);
|
||||
await s.updateLinkedIdentityCredential(linked.id, async () => ({ kind: "keep" }));
|
||||
await s.upsertLinkedIdentity({ ...identity, username: "again" });
|
||||
const spare = await s.upsertLinkedIdentity({ ...identity, providerUserId: "u-spare" });
|
||||
expect((await s.unlinkLinkedIdentity(account.id, spare.id)).kind).toBe("unlinked");
|
||||
await s.findAccountByLinkedIdentity("discord", "u1");
|
||||
await s.findStoredLinkedIdentity("discord", "u1");
|
||||
await s.findStoredLinkedIdentityForAccount(account.id, "discord");
|
||||
|
|
@ -362,13 +615,217 @@ async function exerciseStore(store: PostgresStore): Promise<Set<string>> {
|
|||
await s.consumeAuthCompletion("ghostlight", byCode.code, now);
|
||||
await s.createAuthCompletion({ ...completion, attemptId: attempt.handle });
|
||||
await s.consumeAuthCompletionByAttempt("ghostlight", attempt.handle, now);
|
||||
const found = await s.createAuthCompletion(completion);
|
||||
await s.findAuthCompletion("ghostlight", found.code);
|
||||
const pending = await s.createPendingLink({
|
||||
appSlug: "ghostlight",
|
||||
accountId: account.id,
|
||||
provider: "discord",
|
||||
providerUserId: "u2",
|
||||
identity: { ...identity, providerUserId: "u2" },
|
||||
returnTo: "https://x.test/",
|
||||
createdAt: now,
|
||||
expiresAt: later,
|
||||
});
|
||||
await s.consumePendingLink("ghostlight", pending.id, account.id, now);
|
||||
const snapshot = { accountId: account.id, provider: "discord" as const, scope: "ghostlight:probe", evaluatedAt: now, isAllowed: true, reasonCode: "ok", rawSummaryJson: {} };
|
||||
await s.upsertEntitlementSnapshot(snapshot);
|
||||
await s.upsertEntitlementSnapshot({ ...snapshot, isAllowed: false });
|
||||
const stateUse = { jti: randomUUID(), phase: "launch" as const, appSlug: "ghostlight" as const, usedAt: now, expiresAt: later };
|
||||
expect(await s.claimOAuthStateUse(stateUse)).toBe(true);
|
||||
expect(await s.claimOAuthStateUse(stateUse)).toBe(false);
|
||||
expect(await s.claimOAuthStateUse({ ...stateUse, phase: "callback" })).toBe(true);
|
||||
// The prune is swallowed when the role may not run it, so the exercise proves it ran: a long-expired
|
||||
// record is gone after the next new claim. A missing prune stands for the privilege refusal behind it.
|
||||
const stale = { ...stateUse, jti: randomUUID(), usedAt: "2000-01-01T00:00:00.000Z", expiresAt: "2000-01-01T00:10:00.000Z" };
|
||||
expect(await s.claimOAuthStateUse(stale)).toBe(true);
|
||||
expect(await s.claimOAuthStateUse({ ...stateUse, jti: randomUUID() })).toBe(true);
|
||||
const retained = await s.claimOAuthStateUse(stale);
|
||||
if (!retained) {
|
||||
throw Object.assign(new Error("oauth_state_uses was not pruned"), { code: "42501" });
|
||||
}
|
||||
const { receipt: grant } = await s.createConsentReceipt({ kind: "grant", accountId: account.id, appSlug: "streampixels", provider: "joystick", createdAt: now, scopesAsked: ["a", "b"], scopesGranted: ["a"], consentPageDigest: "d", consentText: "t" });
|
||||
const revocation = { kind: "revocation" as const, accountId: account.id, appSlug: "streampixels" as const, provider: "joystick" as const, createdAt: later, revokesReceiptId: grant.id };
|
||||
const first = await s.createConsentReceipt(revocation);
|
||||
// The second revocation of one grant hits ON CONFLICT DO NOTHING and reads the first back.
|
||||
const second = await s.createConsentReceipt(revocation);
|
||||
expect(first.created).toBe(true);
|
||||
expect(second.created).toBe(false);
|
||||
expect(second.receipt.id).toBe(first.receipt.id);
|
||||
expect((await s.listConsentReceipts(account.id)).map((r) => r.kind)).toEqual(["grant", "revocation"]);
|
||||
await s.createAuditEvent({ eventType: "probe", eventPayloadJson: {}, createdAt: now });
|
||||
const target = await s.createAccount({ createdAt: now, lastSeenAt: now });
|
||||
await s.upsertLinkedIdentity({ ...identity, accountId: target.id, provider: "patreon", providerUserId: "u-target" });
|
||||
const moveId = `move-${randomUUID()}`;
|
||||
expect((await s.moveIdentities({ moveId, appSlug: "bifrost", fromAccountId: account.id, toAccountId: target.id, identityIds: "all", covers: "account", proofSessions: [], proof: { from: [], to: null }, at: now })).kind).toBe("moved");
|
||||
expect((await s.findIdentityMove(moveId))?.id).toBe(moveId);
|
||||
return called;
|
||||
}
|
||||
|
||||
/**
|
||||
* The move contract both stores keep, once. Each case builds its own accounts,
|
||||
* so the order of cases proves nothing and a store holding earlier moves is fine.
|
||||
*/
|
||||
async function exerciseMoveContract(store: HeimdallStore): Promise<void> {
|
||||
const at = "2026-11-14T12:00:00.000Z";
|
||||
const later = "2999-01-01T00:00:00.000Z";
|
||||
const proofTiers = { from: [{ tier: "strong" as const, method: "bifrost-passkey", identityId: null }], to: { tier: "weak" as const, method: null, identityId: null } };
|
||||
const side = async (providers: Array<"discord" | "google" | "patreon">) => {
|
||||
const account = await store.createAccount({ createdAt: at, lastSeenAt: at });
|
||||
const rows = [];
|
||||
for (const provider of providers) {
|
||||
rows.push(await store.upsertLinkedIdentity({ accountId: account.id, provider, providerUserId: `${provider}-${randomUUID()}`, accessTokenEncrypted: "A", refreshTokenEncrypted: "R", scopes: [], profileJson: {}, createdAt: at, updatedAt: at }));
|
||||
}
|
||||
const sessionId = randomUUID();
|
||||
await store.createSession({ id: sessionId, accountId: account.id, appSlug: "bifrost", createdAt: at, lastSeenAt: at, expiresAt: later, accessRevision: 1, claimsJson: {} });
|
||||
return { account, rows, proofSession: { appSlug: "bifrost" as const, sessionId, accountId: account.id, accessRevision: 1 } };
|
||||
};
|
||||
const input = (from: Awaited<ReturnType<typeof side>>, to: Awaited<ReturnType<typeof side>>, extra: Record<string, unknown> = {}) => ({
|
||||
moveId: `move-${randomUUID()}`,
|
||||
appSlug: "bifrost" as const,
|
||||
fromAccountId: from.account.id,
|
||||
toAccountId: to.account.id,
|
||||
identityIds: "all" as const,
|
||||
covers: "account" as const,
|
||||
proofSessions: [from.proofSession, to.proofSession],
|
||||
proof: proofTiers,
|
||||
at,
|
||||
...extra,
|
||||
});
|
||||
const held = async (a: { account: { id: string } }) => (await store.listStoredLinkedIdentitiesForAccount(a.account.id)).map((i) => i.id).sort();
|
||||
|
||||
// Moved: rows, credentials, sessions and the record.
|
||||
const a = await side(["discord", "google"]);
|
||||
const b = await side(["patreon"]);
|
||||
const first = input(a, b);
|
||||
const moved = await store.moveIdentities(first);
|
||||
expect(moved.kind).toBe("moved");
|
||||
expect(await held(a)).toEqual([]);
|
||||
expect(await held(b)).toEqual([...a.rows.map((r) => r.id), ...b.rows.map((r) => r.id)].sort());
|
||||
for (const row of await store.listStoredLinkedIdentitiesForAccount(b.account.id)) {
|
||||
if (a.rows.some((r) => r.id === row.id)) expect([row.accessTokenEncrypted, row.refreshTokenEncrypted]).toEqual([undefined, undefined]);
|
||||
else expect(row.accessTokenEncrypted, "the destination's own credential is untouched").toBe("A");
|
||||
}
|
||||
const record = await store.findIdentityMove(first.moveId);
|
||||
expect(record).toMatchObject({ id: first.moveId, fromAccountId: a.account.id, toAccountId: b.account.id, proof: proofTiers, createdAt: at });
|
||||
expect(record!.moved.map((m) => m.credentialStripped)).toEqual([true, true]);
|
||||
expect((await store.findSession("bifrost", a.proofSession.sessionId))!.accessRevision).toBe(2);
|
||||
expect((await store.findSession("bifrost", b.proofSession.sessionId))!.accessRevision).toBe(1);
|
||||
|
||||
// Replay answers from the row, even though the proof session is gone; a different pair is a conflict.
|
||||
expect(await store.moveIdentities(first)).toEqual({ kind: "replayed", move: record });
|
||||
const c = await side(["discord"]);
|
||||
expect(await store.moveIdentities({ ...first, toAccountId: c.account.id })).toEqual({ kind: "move_id_conflict" });
|
||||
expect(await store.moveIdentities({ ...first, reversesMoveId: "x" })).toEqual({ kind: "move_id_conflict" });
|
||||
|
||||
// Into or out of an alias.
|
||||
expect((await store.moveIdentities(input(a, c, { proofSessions: [c.proofSession] }))).kind).toBe("already_moved");
|
||||
expect((await store.moveIdentities(input(c, a, { proofSessions: [c.proofSession] }))).kind).toBe("already_moved");
|
||||
|
||||
// A proof session that was revoked, or has moved on a revision, has lapsed.
|
||||
const d = await side(["google"]);
|
||||
const e = await side(["patreon"]);
|
||||
await store.revokeSession("bifrost", e.proofSession.sessionId, e.account.id, 1, at);
|
||||
expect((await store.moveIdentities(input(d, e))).kind).toBe("proof_lapsed");
|
||||
expect(await held(d)).toHaveLength(1);
|
||||
|
||||
// Coverage and conflict.
|
||||
const f = await side(["discord", "google"]);
|
||||
const g = await side(["patreon"]);
|
||||
expect((await store.moveIdentities(input(f, g, { covers: [f.rows[0]!.id] }))).kind).toBe("identity_not_proved");
|
||||
expect((await store.moveIdentities(input(f, g, { identityIds: ["nope"] }))).kind).toBe("identity_not_found");
|
||||
const h = await side(["discord"]);
|
||||
expect(await store.moveIdentities(input(f, h))).toEqual({ kind: "provider_conflict", provider: "discord" });
|
||||
expect(await held(f)).toHaveLength(2);
|
||||
const onlyDiscord = await store.moveIdentities(input(f, g, { identityIds: [f.rows[0]!.id], covers: [f.rows[0]!.id] }));
|
||||
expect(onlyDiscord.kind).toBe("moved");
|
||||
expect(await held(f)).toEqual([f.rows[1]!.id]);
|
||||
|
||||
// Reversal: moves exactly what the forward carried, once, and a reversal is not itself reversible.
|
||||
const forward = (moved as { move: { id: string } }).move;
|
||||
const back = input(b, a, { reversesMoveId: forward.id, proofSessions: [], identityIds: a.rows.map((r) => r.id), covers: a.rows.map((r) => r.id) });
|
||||
const reversed = await store.moveIdentities(back);
|
||||
expect(reversed.kind).toBe("moved");
|
||||
expect(await held(a)).toEqual(a.rows.map((r) => r.id).sort());
|
||||
expect(await held(b)).toEqual(b.rows.map((r) => r.id));
|
||||
expect((await store.moveIdentities({ ...back, moveId: `move-${randomUUID()}` })).kind).toBe("not_reversible");
|
||||
expect((await store.moveIdentities(input(a, b, { reversesMoveId: back.moveId, proofSessions: [], identityIds: "all" }))).kind).toBe("not_reversible");
|
||||
|
||||
// A moveId answers only the move that used it: each of app, source, destination and reversal must match.
|
||||
const k = await side(["discord"]);
|
||||
const l = await side(["patreon"]);
|
||||
const m = await side(["google"]);
|
||||
const once = input(k, l);
|
||||
expect((await store.moveIdentities(once)).kind).toBe("moved");
|
||||
expect((await store.moveIdentities({ ...once, fromAccountId: m.account.id })).kind).toBe("move_id_conflict");
|
||||
expect((await store.moveIdentities({ ...once, toAccountId: m.account.id })).kind).toBe("move_id_conflict");
|
||||
expect((await store.moveIdentities({ ...once, appSlug: "streampixels" })).kind).toBe("move_id_conflict");
|
||||
expect((await store.moveIdentities(once)).kind).toBe("replayed");
|
||||
|
||||
// Every step of a move is on Postgres too: expiry of the source's pending links and unredeemed completions, and the stripped credential's expiry and failure mark.
|
||||
const n = await side(["discord", "google"]);
|
||||
const o = await side(["patreon"]);
|
||||
await store.upsertLinkedIdentity({ accountId: n.account.id, provider: "discord", providerUserId: (await store.listStoredLinkedIdentitiesForAccount(n.account.id))[0]!.providerUserId, tokenExpiresAt: "2999-01-01T00:00:00.000Z", scopes: [], profileJson: {}, createdAt: at, updatedAt: at });
|
||||
await store.updateLinkedIdentityCredential(n.rows[1]!.id, async () => ({ kind: "failed", failedAt: at }));
|
||||
const linkOf = (accountId: string) => store.createPendingLink({ appSlug: "bifrost", accountId, provider: "discord", providerUserId: "p", identity: { accountId, provider: "discord", providerUserId: "p", scopes: [], profileJson: {}, createdAt: at, updatedAt: at }, returnTo: "https://x.test/", createdAt: at, expiresAt: later });
|
||||
const completionOf = (accountId: string) => store.createAuthCompletion({ appSlug: "bifrost", provider: "discord", mode: "sign_in", accountId, sessionId: n.proofSession.sessionId, returnTo: "https://x.test/", createdAt: at, expiresAt: later, payloadJson: {} });
|
||||
const sourceLink = await linkOf(n.account.id);
|
||||
const destLink = await linkOf(o.account.id);
|
||||
const sourceCompletion = await completionOf(n.account.id);
|
||||
const destCompletion = await completionOf(o.account.id);
|
||||
expect((await store.moveIdentities(input(n, o))).kind).toBe("moved");
|
||||
const after = "2026-11-14T12:00:01.000Z";
|
||||
expect(await store.consumePendingLink("bifrost", sourceLink.id, n.account.id, after)).toBeNull();
|
||||
expect(await store.consumeAuthCompletion("bifrost", sourceCompletion.code, after)).toBeNull();
|
||||
expect((await store.consumePendingLink("bifrost", destLink.id, o.account.id, after))?.id).toBe(destLink.id);
|
||||
expect((await store.consumeAuthCompletion("bifrost", destCompletion.code, after))?.code).toBe(destCompletion.code);
|
||||
for (const row of (await store.listStoredLinkedIdentitiesForAccount(o.account.id)).filter((r) => n.rows.some((x) => x.id === r.id))) {
|
||||
expect([row.accessTokenEncrypted, row.refreshTokenEncrypted, row.tokenExpiresAt, row.refreshFailedAt], row.provider).toEqual([undefined, undefined, undefined, undefined]);
|
||||
}
|
||||
|
||||
// Each reversal guard on its own: the refusal is not_reversible, never another code, and nothing moves.
|
||||
const fresh = async () => ({ p: await side(["discord", "google"]), q: await side(["patreon"]), t: await side(["patreon"]) });
|
||||
const reverse = (forwardId: string, from: { account: { id: string } }, to: { account: { id: string } }, ids: readonly string[]) => ({
|
||||
moveId: `move-${randomUUID()}`, appSlug: "bifrost" as const, fromAccountId: from.account.id, toAccountId: to.account.id,
|
||||
identityIds: ids, covers: ids, proofSessions: [], reversesMoveId: forwardId, proof: { from: [], to: null }, at,
|
||||
});
|
||||
// (a) already reversed, even though the logins are back on the destination by a later forward move
|
||||
{
|
||||
const { p, q } = await fresh();
|
||||
const ids = p.rows.map((r) => r.id);
|
||||
const m1 = input(p, q);
|
||||
expect((await store.moveIdentities(m1)).kind).toBe("moved");
|
||||
expect((await store.moveIdentities(reverse(m1.moveId, q, p, ids))).kind).toBe("moved");
|
||||
expect((await store.moveIdentities(input(p, q, { proofSessions: [] }))).kind).toBe("moved");
|
||||
expect((await store.moveIdentities(reverse(m1.moveId, q, p, ids))).kind, "reversed once").toBe("not_reversible");
|
||||
expect(await held(p)).toEqual([]);
|
||||
}
|
||||
// (d) the logins are still on the forward's destination but the reversal targets another account
|
||||
{
|
||||
const { p, q } = await fresh();
|
||||
const ids = p.rows.map((r) => r.id);
|
||||
const m1 = input(p, q);
|
||||
expect((await store.moveIdentities(m1)).kind).toBe("moved");
|
||||
const elsewhere = await side(["patreon"]);
|
||||
expect((await store.moveIdentities(reverse(m1.moveId, q, elsewhere, ids))).kind, "to is not the forward's source").toBe("not_reversible");
|
||||
expect(await held(elsewhere)).toHaveLength(1);
|
||||
}
|
||||
// (b) the logins moved on from the destination: not held, so not_reversible (not identity_not_found)
|
||||
// (c) the reversal's source is not the forward's destination, or its target is not the forward's source
|
||||
{
|
||||
const { p, q, t } = await fresh();
|
||||
const ids = p.rows.map((r) => r.id);
|
||||
const m1 = input(p, q);
|
||||
expect((await store.moveIdentities(m1)).kind).toBe("moved");
|
||||
expect((await store.moveIdentities(input(q, t, { identityIds: ids, covers: ids, proofSessions: [] }))).kind).toBe("moved");
|
||||
expect((await store.moveIdentities(reverse(m1.moveId, q, p, ids))).kind, "ids no longer held").toBe("not_reversible");
|
||||
expect((await store.moveIdentities(reverse(m1.moveId, t, p, ids))).kind, "from is not the forward's destination").toBe("not_reversible");
|
||||
const u = await side(["google"]);
|
||||
expect((await store.moveIdentities(reverse(m1.moveId, t, u, ids))).kind, "to is not the forward's source").toBe("not_reversible");
|
||||
expect(await held(t)).toEqual([...ids, ...t.rows.map((r) => r.id)].sort());
|
||||
}
|
||||
}
|
||||
|
||||
// Against a real Postgres, through the startup path itself: createStore, with
|
||||
// and without applying the schema. HEIMDALL_TEST_PG_ADMIN_URL names a role
|
||||
// that may create databases and roles. Each case clones a template database
|
||||
|
|
@ -514,6 +971,214 @@ describe.skipIf(!adminUrl)("startup against a live Postgres (HEIMDALL_TEST_PG_AD
|
|||
}
|
||||
});
|
||||
|
||||
it("startup refuses a role that lacks DELETE on linked_identities", async () => {
|
||||
expect(STORE_TABLE_PRIVILEGES.linked_identities).toContain("DELETE");
|
||||
const { name, owner } = await appliedDatabase();
|
||||
await grant(owner, { ...STORE_TABLE_PRIVILEGES, linked_identities: ["SELECT", "INSERT", "UPDATE"] });
|
||||
expect(await start(urlFor(name, role, rolePassword), false)).toBe(refusal("SCHEMA_PRIVILEGES"));
|
||||
});
|
||||
|
||||
it("startup refuses a role that lacks INSERT or SELECT on identity_moves", async () => {
|
||||
expect(STORE_TABLE_PRIVILEGES.identity_moves).toEqual(["SELECT", "INSERT"]);
|
||||
for (const [kept, dropped] of [[["SELECT"], "INSERT"], [["INSERT"], "SELECT"]] as const) {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
await grant(owner, { ...STORE_TABLE_PRIVILEGES, identity_moves: kept });
|
||||
expect(await start(urlFor(name, role, rolePassword), false), `without ${dropped}`).toBe(refusal("SCHEMA_PRIVILEGES"));
|
||||
}
|
||||
});
|
||||
|
||||
it("on real Postgres: the move contract holds", async () => {
|
||||
const { owner } = await appliedDatabase();
|
||||
await exerciseMoveContract(new PostgresStore(owner));
|
||||
});
|
||||
|
||||
describe("concurrent moves", () => {
|
||||
const at = "2026-11-14T12:00:00.000Z";
|
||||
async function pair(store: PostgresStore) {
|
||||
const make = async (provider: "discord" | "patreon") => {
|
||||
const account = await store.createAccount({ createdAt: at, lastSeenAt: at });
|
||||
await store.upsertLinkedIdentity({ accountId: account.id, provider, providerUserId: `${provider}-${randomUUID()}`, scopes: [], profileJson: {}, createdAt: at, updatedAt: at });
|
||||
const sessionId = randomUUID();
|
||||
await store.createSession({ id: sessionId, accountId: account.id, appSlug: "bifrost", createdAt: at, lastSeenAt: at, expiresAt: "2999-01-01T00:00:00.000Z", accessRevision: 1, claimsJson: {} });
|
||||
return { id: account.id, proof: { appSlug: "bifrost" as const, sessionId, accountId: account.id, accessRevision: 1 } };
|
||||
};
|
||||
return { x: await make("discord"), y: await make("patreon") };
|
||||
}
|
||||
const request = (from: { id: string; proof: object }, to: { id: string; proof: object }, moveId: string) => ({
|
||||
moveId,
|
||||
appSlug: "bifrost" as const,
|
||||
fromAccountId: from.id,
|
||||
toAccountId: to.id,
|
||||
identityIds: "all" as const,
|
||||
covers: "account" as const,
|
||||
proofSessions: [from.proof, to.proof] as never,
|
||||
proof: { from: [], to: null },
|
||||
at,
|
||||
});
|
||||
|
||||
it("opposite moves A->B and B->A over two pools leave one applied and never deadlock, ten rounds", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
const storeA = new PostgresStore(owner);
|
||||
const other = fixturePool(urlFor(name));
|
||||
cleanup.push(async () => {
|
||||
await other.end();
|
||||
});
|
||||
const storeB = new PostgresStore(other);
|
||||
for (let round = 0; round < 10; round += 1) {
|
||||
const { x, y } = await pair(storeA);
|
||||
const results = await Promise.all([
|
||||
storeA.moveIdentities(request(x, y, `move-${randomUUID()}`)),
|
||||
storeB.moveIdentities(request(y, x, `move-${randomUUID()}`)),
|
||||
]);
|
||||
const kinds = results.map((r) => r.kind).sort();
|
||||
expect(kinds[0], `round ${round}: ${kinds}`).toBe("moved");
|
||||
expect(["already_moved", "proof_lapsed"], `round ${round}: ${kinds}`).toContain(kinds[1]);
|
||||
const held = (await storeA.listStoredLinkedIdentitiesForAccount(x.id)).length + (await storeA.listStoredLinkedIdentitiesForAccount(y.id)).length;
|
||||
expect(held, "no identity is lost or duplicated").toBe(2);
|
||||
}
|
||||
});
|
||||
|
||||
it("one moveId over two different pairs at once: one moved, the other move_id_conflict, never a receipt for a move it did not make", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
const storeA = new PostgresStore(owner);
|
||||
const other = fixturePool(urlFor(name));
|
||||
cleanup.push(async () => {
|
||||
await other.end();
|
||||
});
|
||||
const storeB = new PostgresStore(other);
|
||||
for (let round = 0; round < 6; round += 1) {
|
||||
const one = await pair(storeA);
|
||||
const two = await pair(storeA);
|
||||
const id = `move-${randomUUID()}`;
|
||||
const results = await Promise.all([storeA.moveIdentities(request(one.x, one.y, id)), storeB.moveIdentities(request(two.x, two.y, id))]);
|
||||
expect(results.map((r) => r.kind).sort(), `round ${round}`).toEqual(["move_id_conflict", "moved"]);
|
||||
const winner = (await storeA.findIdentityMove(id))!;
|
||||
const moved = results.find((r) => r.kind === "moved") as { move: { fromAccountId: string } };
|
||||
expect(winner.fromAccountId).toBe(moved.move.fromAccountId);
|
||||
}
|
||||
});
|
||||
|
||||
it("two concurrent identical moveIds: one moved, one replayed", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
const storeA = new PostgresStore(owner);
|
||||
const other = fixturePool(urlFor(name));
|
||||
cleanup.push(async () => {
|
||||
await other.end();
|
||||
});
|
||||
const storeB = new PostgresStore(other);
|
||||
for (let round = 0; round < 5; round += 1) {
|
||||
const { x, y } = await pair(storeA);
|
||||
const body = request(x, y, `move-${randomUUID()}`);
|
||||
const results = await Promise.all([storeA.moveIdentities(body), storeB.moveIdentities(body)]);
|
||||
expect(results.map((r) => r.kind).sort(), `round ${round}`).toEqual(["moved", "replayed"]);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("on real Postgres: an upsert never moves an identity, and concurrent unlinks of the last two leave one", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
const clientA = new PostgresStore(owner);
|
||||
const at = "2026-11-13T12:00:00.000Z";
|
||||
const a = await clientA.createAccount({ createdAt: at, lastSeenAt: at });
|
||||
const b = await clientA.createAccount({ createdAt: at, lastSeenAt: at });
|
||||
const base = { provider: "discord" as const, scopes: [], profileJson: {}, createdAt: at, updatedAt: at };
|
||||
const held = await clientA.upsertLinkedIdentity({ ...base, accountId: a.id, providerUserId: "u1", username: "original" });
|
||||
await expect(clientA.upsertLinkedIdentity({ ...base, accountId: b.id, providerUserId: "u1", username: "thief" })).rejects.toBeInstanceOf(IdentityHeldElsewhereError);
|
||||
expect(await clientA.findStoredLinkedIdentity("discord", "u1")).toEqual(held);
|
||||
|
||||
await clientA.upsertLinkedIdentity({ ...base, accountId: a.id, providerUserId: "u2" });
|
||||
// Two separate pools, as two Heimdall processes would be, race for the last two.
|
||||
const other = fixturePool(urlFor(name));
|
||||
cleanup.push(async () => {
|
||||
await other.end();
|
||||
});
|
||||
const storeB = new PostgresStore(other);
|
||||
for (let round = 0; round < 10; round += 1) {
|
||||
const [first, second] = await clientA.listStoredLinkedIdentitiesForAccount(a.id);
|
||||
expect(first && second, `round ${round} starts with two`).toBeTruthy();
|
||||
const results = await Promise.all([clientA.unlinkLinkedIdentity(a.id, first!.id), storeB.unlinkLinkedIdentity(a.id, second!.id)]);
|
||||
expect(results.map((r) => r.kind).sort(), `round ${round}`).toEqual(["last_identity", "unlinked"]);
|
||||
expect(await clientA.listStoredLinkedIdentitiesForAccount(a.id)).toHaveLength(1);
|
||||
await clientA.upsertLinkedIdentity({ ...base, accountId: a.id, providerUserId: `u-next-${round}` });
|
||||
}
|
||||
});
|
||||
|
||||
describe("oauth_state_uses retention", () => {
|
||||
const expMs = Date.parse("2026-04-26T12:10:00.000Z");
|
||||
const boundary = expMs + OAUTH_STATE_SKEW_MS + OAUTH_STATE_PRUNE_MARGIN_MS;
|
||||
const use = (jti: string, usedAtMs: number, expiresAtMs = expMs) => ({
|
||||
jti,
|
||||
phase: "launch" as const,
|
||||
appSlug: "repixelizer" as const,
|
||||
usedAt: new Date(usedAtMs).toISOString(),
|
||||
expiresAt: new Date(expiresAtMs).toISOString(),
|
||||
});
|
||||
const count = async (owner: Pool) => Number((await owner.query("SELECT count(*) AS n FROM oauth_state_uses")).rows[0].n);
|
||||
const seed = async (owner: Pool, jti: string) => {
|
||||
await owner.query(
|
||||
"INSERT INTO oauth_state_uses (jti, phase, app_slug, used_at, expires_at) VALUES ($1, 'launch', 'repixelizer', $2, $2)",
|
||||
[jti, new Date(expMs)]
|
||||
);
|
||||
};
|
||||
|
||||
it.each([
|
||||
[boundary - 1, true],
|
||||
[boundary, false],
|
||||
[boundary + 1, false],
|
||||
])("a claim at exp + skew + margin %i ms keeps the record: %s", async (usedAtMs, kept) => {
|
||||
const { owner } = await appliedDatabase();
|
||||
const store = new PostgresStore(owner);
|
||||
expect(await store.claimOAuthStateUse(use("old", expMs - 1000))).toBe(true);
|
||||
expect(await store.claimOAuthStateUse(use("other", usedAtMs, usedAtMs + 600_000))).toBe(true);
|
||||
expect(await store.claimOAuthStateUse(use("old", usedAtMs))).toBe(!kept);
|
||||
});
|
||||
|
||||
it("removes at most one batch per claim and never the live record", async () => {
|
||||
const { owner } = await appliedDatabase();
|
||||
const store = new PostgresStore(owner);
|
||||
const total = OAUTH_STATE_PRUNE_BATCH * 2 + 7;
|
||||
for (let i = 0; i < total; i += 1) await seed(owner, `old-${i}`);
|
||||
const fresh = use("fresh", boundary + 5, boundary + 600_000);
|
||||
expect(await store.claimOAuthStateUse(fresh)).toBe(true);
|
||||
expect(await count(owner)).toBe(total + 1 - OAUTH_STATE_PRUNE_BATCH);
|
||||
expect(await store.claimOAuthStateUse(fresh)).toBe(false);
|
||||
expect(await count(owner)).toBe(total + 1 - OAUTH_STATE_PRUNE_BATCH);
|
||||
});
|
||||
|
||||
it("keeps its expires_at index", async () => {
|
||||
const { owner } = await appliedDatabase();
|
||||
const found = await owner.query("SELECT 1 FROM pg_indexes WHERE indexname = 'oauth_state_uses_expires_at_idx'");
|
||||
expect(found.rowCount).toBe(1);
|
||||
});
|
||||
|
||||
it("the step_up_assert nonce claim is single-use under the store's own role, and independent of the other phases", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
await grant(owner, STORE_TABLE_PRIVILEGES);
|
||||
const pool = fixturePool(urlFor(name, role, rolePassword));
|
||||
cleanup.push(async () => {
|
||||
await pool.end();
|
||||
});
|
||||
const store = new PostgresStore(pool);
|
||||
const claim = { ...use("digest", boundary, boundary + 600_000), phase: "step_up_assert" as const, appSlug: "bifrost" };
|
||||
expect(await store.claimOAuthStateUse(claim)).toBe(true);
|
||||
expect(await store.claimOAuthStateUse(claim)).toBe(false);
|
||||
expect(await store.claimOAuthStateUse({ ...claim, phase: "callback" })).toBe(true);
|
||||
});
|
||||
|
||||
it("a role without DELETE still claims, and leaves the old records", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
await grant(owner, { ...STORE_TABLE_PRIVILEGES, oauth_state_uses: ["SELECT", "INSERT"] });
|
||||
await seed(owner, "old");
|
||||
const pool = fixturePool(urlFor(name, role, rolePassword));
|
||||
cleanup.push(async () => {
|
||||
await pool.end();
|
||||
});
|
||||
const store = new PostgresStore(pool);
|
||||
expect(await store.claimOAuthStateUse(use("fresh", boundary + 5, boundary + 600_000))).toBe(true);
|
||||
expect(await count(owner)).toBe(2);
|
||||
});
|
||||
});
|
||||
|
||||
it("refuses to apply the schema as a role that may not, and closes the store", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
await grant(owner, STORE_TABLE_PRIVILEGES);
|
||||
|
|
@ -524,12 +1189,29 @@ describe.skipIf(!adminUrl)("startup against a live Postgres (HEIMDALL_TEST_PG_AD
|
|||
it("prints each declared predicate exactly as Postgres prints the applied index's", async () => {
|
||||
const { owner } = await appliedDatabase();
|
||||
const printed = await printedDeclaredPredicates(owner, HEIMDALL_SCHEMA_REQUIREMENTS);
|
||||
const applied = await owner.query<{ predicate: string }>(
|
||||
"SELECT pg_get_expr(indpred, indrelid) AS predicate FROM pg_index WHERE indexrelid = 'auth_completions_attempt_unconsumed_unique_idx'::regclass"
|
||||
);
|
||||
const attemptKey = REQUIRED_KEYS.findIndex((key) => key.predicate !== "");
|
||||
expect(printed[attemptKey]).toBe(applied.rows[0]!.predicate);
|
||||
expect(printed.filter((predicate) => predicate !== "")).toHaveLength(1);
|
||||
const appliedByIndex = {
|
||||
auth_completions_attempt_unconsumed_unique_idx: "auth_completions",
|
||||
consent_receipts_revokes_unique_idx: "consent_receipts",
|
||||
identity_moves_reverses_unique_idx: "identity_moves",
|
||||
};
|
||||
const partialKeys = REQUIRED_KEYS.flatMap((key, index) => (key.predicate === "" ? [] : [{ key, index }]));
|
||||
expect(partialKeys.map(({ key }) => key.table).sort()).toEqual(Object.values(appliedByIndex).sort());
|
||||
for (const [indexName, table] of Object.entries(appliedByIndex)) {
|
||||
const applied = await owner.query<{ predicate: string }>(
|
||||
"SELECT pg_get_expr(indpred, indrelid) AS predicate FROM pg_index WHERE indexrelid = $1::regclass",
|
||||
[indexName]
|
||||
);
|
||||
const { index } = partialKeys.find(({ key }) => key.table === table)!;
|
||||
expect(printed[index], indexName).toBe(applied.rows[0]!.predicate);
|
||||
}
|
||||
expect(printed.filter((predicate) => predicate !== "")).toHaveLength(partialKeys.length);
|
||||
});
|
||||
|
||||
it("refuses to boot with consent_receipts missing when the schema is not applied on startup", async () => {
|
||||
const { name, owner } = await appliedDatabase();
|
||||
await owner.query("DROP TABLE consent_receipts");
|
||||
|
||||
expect(await start(urlFor(name), false)).toBe(refusal("SCHEMA_MISSING"));
|
||||
});
|
||||
|
||||
it("refuses a table whose primary key was dropped, even after applying the schema", async () => {
|
||||
|
|
@ -545,7 +1227,10 @@ describe.skipIf(!adminUrl)("startup against a live Postgres (HEIMDALL_TEST_PG_AD
|
|||
await owner.query(`GRANT USAGE ON SCHEMA public TO ${role}`);
|
||||
for (const [table, wanted] of Object.entries(STORE_TABLE_PRIVILEGES)) {
|
||||
const columns = REQUIRED_COLUMNS.filter((column) => column.table === table).map((column) => column.column).join(", ");
|
||||
for (const privilege of wanted) await owner.query(`GRANT ${privilege} (${columns}) ON ${table} TO ${role}`);
|
||||
for (const privilege of wanted) {
|
||||
// DELETE removes rows and cannot be granted per column.
|
||||
await owner.query(privilege === "DELETE" ? `GRANT DELETE ON ${table} TO ${role}` : `GRANT ${privilege} (${columns}) ON ${table} TO ${role}`);
|
||||
}
|
||||
}
|
||||
|
||||
expect(await start(urlFor(name, role, rolePassword), false)).toBe("started");
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ describe("Heimdall verse runtime publication", () => {
|
|||
expect(bySchema.get("idunn.daemon_health")).toEqual([
|
||||
"yggdrasil-heimdall",
|
||||
"active",
|
||||
"Heimdall auth runtime active; storage=postgres; providers=2/7; apps=4; healthTransport=CultNet/RUDP",
|
||||
"Heimdall auth runtime active; storage=postgres; providers=2/8; apps=4; healthTransport=CultNet/RUDP",
|
||||
"2026-06-16T17:10:00.000Z",
|
||||
"heimdall.cultnet-rudp-provider-health",
|
||||
"daemon-published",
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ describe("Heimdall Verse witness advertisement", () => {
|
|||
"youtube",
|
||||
"spotify",
|
||||
"joystick",
|
||||
"google",
|
||||
]);
|
||||
expect(advertisement.appProfiles.map((profile) => profile.slug)).toEqual([
|
||||
"repixelizer",
|
||||
|
|
|
|||
Loading…
Reference in a new issue