@o3co/auth-provider-passkey 0.0.0 → 0.18.0-rc.1

package/passkey-registration/src/section.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const section = z.strictObject({
+    requests: z
+        .number()
+        .int()
+        .min(1)
+        .max(100_000)
+        .default(60)
+        .describe("Requests allowed per source in each window, over both registration routes."),
+    "window-seconds": z
+        .number()
+        .int()
+        .min(1)
+        .max(86_400)
+        .default(300)
+        .describe("The window, in seconds, that requests are counted over."),
+});

package/webauthn/README.md

@@ -0,0 +1,47 @@
+# webauthn
+
+## Responsibilities
+- Runs WebAuthn ceremonies: options, response verification, the signature count and the user handle, by its internal module `ceremony`.
+- Keeps passkeys: each subject's user handle, and the credentials registered for it; its internal module `registration` registers them.
+- Answers assertions by the passkeys it keeps, and assertions whose challenge and credential the caller keeps.
+
+## Not here
+- What an assertion leads to, and the amr it adds (the login and second-factor modules). Issuing tokens. Second-factor credentials (`mfa` keeps them). The routes that register passkeys, and who may register.
+
+## Offers
+- `ceremonies`: creation options (a discoverable credential unless asked otherwise) and attestation, request options and assertion. The caller keeps the challenge and the credential and hands them over once.
+  - Options also answer the challenge's end, `until`: now on `kernel`'s clock plus `challenge-seconds`.
+  - An answer at or past an `until` handed back is `challenge`; with none, the caller judges the lifetime.
+- `passkeys`: a challenge the same for everyone, made for a requester, and the assertion of a discoverable passkey by that requester → subject, challenge time, user verified, backup eligible; or a refusal.
+- `registrations`: options for a subject's new passkey, and keeping the one a response creates → the credential, or a refusal (the ceremony's, `unreadable`, `no-challenge`, `conflict`, `full`).
+  - The caller answers for who the subject is; webauthn takes it as given, so only a module that has authenticated the subject may ask.
+- `credentialOf`: a value read as a credential in the shape webauthn writes, with its fields alone and the canonical checks and limits of its id, key and handle; nothing for any other value.
+- `freshHandle`: a new user handle from the randomness given, by the rule webauthn makes its own by.
+- Store interfaces, which the assembly wires. The store never sees what a record holds.
+  - Passkeys: credentials and subjects, each by a key webauthn makes, saved once, read, changed from what they hold, kept without end. Needs: no eviction, survives a crash, never rolled back by failover, confirmed reads.
+  - Challenges: opened for a lifetime, taken by putting a mark in place. Needs: survives a crash, never rolled back by failover, names derived from the challenge.
+- Operator section: `rp-id`, `rp-name`, `origins` (required), `top-origins` (default none), `challenge-seconds` (default 120), `user-verification` (default `preferred`), `max-credentials` (per subject, default 10).
+- Test configuration builders, the contract tests of both store interfaces, and a software authenticator behind a browser (`./testing`), which answers options as a browser does and takes twists for refusal tests.
+
+## Invariants
+- A challenge is 32 random bytes, taken once, within its lifetime on `kernel`'s clock, whatever the store's expiry. A taken mark stays for the rest of it.
+- An assertion's challenge is redeemed by its requester alone; any other is `challenge`, after the challenge is taken. Its record keeps the requester's SHA-256, never the requester.
+- Origins match the list exactly: https, or http on `localhost`; never an IP literal. An Android app origin is `android:apk-key-hash:` and the unpadded base64url SHA-256 of its signing certificate, never a top origin. A reported top origin not listed is refused, and with none listed any frame is, for registration and assertion alike. The relying party ID must match; boot refuses one that is not each web origin's host or a domain it lies under. Algorithms are EdDSA, ES256 and RS256.
+- The count is compared after the signature verified, and must go up (0 after 0 passes). It is written only over the count judged; a lost race is `raced`.
+- `registrations`' creation options require a discoverable credential, as `passkeys` lists none to ask for.
+- `passkeys` refuses an assertion without a user handle before any store is read. The handle must be its holder's, judged after the signature.
+- A user handle is 32 random bytes per subject, carrying neither the subject nor a name. Handles and credential ids are written and compared only as unpadded base64url; a credential that would not read back is refused before a write. Transports are kept only as a short list of short strings. A record read in another shape is unavailable.
+- A credential id its holder lists is refused at registration. One no holder lists, left by a registration that failed between its two writes or found its subject full, is taken over. Options exclude the subject's own.
+- Registration asks for no attestation, so it takes the public key as sent: nothing proves the client holds its private key until the first assertion.
+- `conflict` tells the caller that some subject lists an id. Ids are high-entropy, made by the authenticator, so this answers only for an id already known.
+- `required` refuses a response without user verification. A backup eligibility other than the registered one is refused.
+- A store that cannot tell is unavailable, never a refusal.
+
+## Data
+- Passkeys and subjects through the passkey store; challenges through the challenge store.
+
+## Depends on
+- `kernel`
+
+## Vocabulary
+- holder: a subject's user handle and the ids of its passkeys. passkey: a credential this module keeps for a subject.

package/webauthn/config.example

@@ -0,0 +1,7 @@
+webauthn {
+	rp-id = login.example.invalid
+	rp-name = "Example"
+	origins = [
+		"https://login.example.invalid"
+	]
+}

package/webauthn/src/ceremony/README.md

@@ -0,0 +1,24 @@
+# ceremony
+
+Internal module of `webauthn`: the WebAuthn ceremonies, over a pinned version of `@simplewebauthn/server`.
+
+## Responsibilities
+- Makes creation and request options, and verifies attestations and assertions.
+
+## Not here
+- Where challenges and credentials are kept, and which subject they belong to (the package).
+
+## Offers
+- `ceremoniesFor` (relying party, randomness, clock) → the package's `Ceremonies`. No library type crosses it.
+- `challengeOf` (response) → the challenge the client data names, read by the library's decoder, the one that verifies it.
+
+## Invariants
+- A challenge is 32 random bytes. Options list the three algorithms, ask for no attestation, and require a discoverable credential unless the caller asks for one that need not be.
+- A challenge ends the relying party's timeout after it was made.
+- Before the library runs: an end given that the clock has reached is `challenge`; client data the library cannot read is `malformed`; a challenge other than the one given is `challenge`; a reported top origin that is not listed, or not in a frame, is `top-origin`, and so is any frame when none is listed.
+- The library's refusals map by how its messages start; any other is `malformed`. The library never judges the count (it is handed 0).
+- After the signature: a handle carried must be the credential's (none carried passes), the backup eligibility must be the credential's, and the count must go up (0 after 0 passes).
+- An assertion by a credential other than the one given is `malformed`.
+
+## Depends on
+- `@simplewebauthn/server`; the package's contract

package/webauthn/src/ceremony/ceremony.d.ts

@@ -0,0 +1,11 @@
+import type { Ceremonies } from "../contract.js";
+export interface RelyingParty {
+    readonly id: string;
+    readonly name: string;
+    readonly origins: readonly string[];
+    readonly topOrigins: readonly string[];
+    readonly timeoutMs: number;
+}
+/** The challenge a response answers, read as its verification reads it. */
+export declare function challengeOf(response: unknown): string | undefined;
+export declare function ceremoniesFor(rp: RelyingParty, random: (n: number) => Uint8Array, now: () => number): Ceremonies;

package/webauthn/src/ceremony/ceremony.js

@@ -0,0 +1,190 @@
+import { verifyAuthenticationResponse, verifyRegistrationResponse } from "@simplewebauthn/server";
+import { decodeClientDataJSON } from "@simplewebauthn/server/helpers";
+/** EdDSA, ES256 and RS256, as COSE names them. */
+const algorithms = [-8, -7, -257];
+const base64url = (bytes) => Buffer.from(bytes).toString("base64url");
+/** The client data as the library decodes it; none when that is not a JSON object. */
+function clientDataOf(response) {
+    const encoded = response?.response
+        ?.clientDataJSON;
+    if (typeof encoded !== "string")
+        return undefined;
+    try {
+        const data = decodeClientDataJSON(encoded);
+        return typeof data === "object" && data !== null && !Array.isArray(data)
+            ? data
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The challenge a response answers, read as its verification reads it. */
+export function challengeOf(response) {
+    const challenge = clientDataOf(response)?.challenge;
+    return typeof challenge === "string" ? challenge : undefined;
+}
+/** The library's messages for a refusal, by how they start; any other refusal is `malformed`. */
+const refusals = [
+    ["Unexpected public key alg ", "algorithm"],
+    ["Unexpected registration response origin ", "origin"],
+    ["Unexpected authentication response origin ", "origin"],
+    ["Unexpected registration response challenge ", "challenge"],
+    ["Unexpected authentication response challenge ", "challenge"],
+    ["Unexpected RP ID hash", "rp"],
+    ["User verification", "user-verification"],
+];
+const refusalOf = (error) => refusals.find(([start]) => error instanceof Error && error.message.startsWith(start))?.[1] ??
+    "malformed";
+const refused = (reason) => ({ kind: "refused", reason });
+/** The library's answer, or the refusal its error names. */
+async function libraryAnswer(verify) {
+    try {
+        return await verify();
+    }
+    catch (error) {
+        return refusalOf(error);
+    }
+}
+// The client's transports, which the library passes on unchecked: a short list of short strings.
+const hintOf = (value) => Array.isArray(value) &&
+    value.length <= 8 &&
+    value.every((t) => typeof t === "string" && t.length <= 32)
+    ? [...value]
+    : undefined;
+export function ceremoniesFor(rp, random, now) {
+    const fresh = () => ({ challenge: base64url(random(32)), until: now() + rp.timeoutMs });
+    /** Before the library: a challenge past its end or other than the one given, and a frame not listed. */
+    const precheck = (response, challenge, until) => {
+        if (until !== undefined && now() >= until)
+            return "challenge";
+        const data = clientDataOf(response);
+        if (!data)
+            return "malformed";
+        if (data.challenge !== challenge)
+            return "challenge";
+        // With no page listed, a frame is refused even when the browser names no page.
+        if (data.crossOrigin === true && rp.topOrigins.length === 0)
+            return "top-origin";
+        if (data.topOrigin === undefined)
+            return undefined;
+        const listed = typeof data.topOrigin === "string" && rp.topOrigins.includes(data.topOrigin);
+        return data.crossOrigin === true && listed ? undefined : "top-origin";
+    };
+    const expected = (challenge, v) => ({
+        expectedChallenge: challenge,
+        expectedOrigin: [...rp.origins],
+        expectedRPID: rp.id,
+        requireUserVerification: v === "required",
+    });
+    return {
+        creation: (user, exclude, v, asked = {}) => {
+            const discoverable = asked.discoverable ?? true;
+            const { challenge, until } = fresh();
+            const options = {
+                rp: { id: rp.id, name: rp.name },
+                user: { id: user.handle, name: user.name, displayName: user.name },
+                challenge,
+                pubKeyCredParams: algorithms.map((alg) => ({ alg, type: "public-key" })),
+                timeout: rp.timeoutMs,
+                attestation: "none",
+                excludeCredentials: exclude.map((id) => ({ id, type: "public-key" })),
+                // Passkeys are asked for with no credential listed, which reaches only a discoverable one.
+                authenticatorSelection: {
+                    residentKey: discoverable ? "required" : "discouraged",
+                    requireResidentKey: discoverable,
+                    userVerification: v,
+                },
+            };
+            return { options, challenge, until };
+        },
+        attest: async (response, challenge, handle, v, until) => {
+            const early = precheck(response, challenge, until);
+            if (early)
+                return refused(early);
+            const verified = await libraryAnswer(() => verifyRegistrationResponse({
+                // The library checks the shape it reads.
+                response: response,
+                ...expected(challenge, v),
+                supportedAlgorithmIDs: algorithms,
+            }));
+            if (typeof verified === "string")
+                return refused(verified);
+            const info = verified.registrationInfo;
+            if (!verified.verified || !info)
+                return refused("signature");
+            const transports = hintOf(info.credential.transports);
+            return {
+                kind: "attested",
+                credential: {
+                    id: info.credential.id,
+                    publicKey: base64url(info.credential.publicKey),
+                    signCount: info.credential.counter,
+                    userHandle: handle,
+                    backupEligible: info.credentialDeviceType === "multiDevice",
+                    backedUp: info.credentialBackedUp,
+                    ...(transports ? { transports } : {}),
+                },
+            };
+        },
+        request: (allow, v) => {
+            const { challenge, until } = fresh();
+            const options = {
+                challenge,
+                timeout: rp.timeoutMs,
+                rpId: rp.id,
+                allowCredentials: allow.map((c) => ({
+                    id: c.id,
+                    type: "public-key",
+                    ...(c.transports ? { transports: c.transports } : {}),
+                })),
+                userVerification: v,
+            };
+            return { options, challenge, until };
+        },
+        assert: async (response, challenge, credential, v, until) => {
+            const early = precheck(response, challenge, until);
+            if (early)
+                return refused(early);
+            const answered = response;
+            if (answered.id !== credential.id)
+                return refused("malformed");
+            const verified = await libraryAnswer(() => verifyAuthenticationResponse({
+                response: answered,
+                ...expected(challenge, v),
+                // The frame was judged above; the library asks for the list to accept one at all.
+                ...(rp.topOrigins.length > 0 ? { expectedTopOrigin: [...rp.topOrigins] } : {}),
+                // 0, so the library never judges the count before the signature; it is judged below.
+                credential: {
+                    id: credential.id,
+                    publicKey: new Uint8Array(Buffer.from(credential.publicKey, "base64url")),
+                    counter: 0,
+                },
+            }));
+            if (typeof verified === "string")
+                return refused(verified);
+            if (!verified.verified)
+                return refused("signature");
+            return afterSignature(credential, verified.authenticationInfo, answered.response.userHandle);
+        },
+    };
+}
+/** What a verified signature still has to meet: the handle, the backup eligibility, the count. */
+function afterSignature(credential, info, userHandle) {
+    // None carried passes: a credential that is not discoverable may carry none.
+    if (userHandle !== undefined && userHandle !== null && userHandle !== credential.userHandle) {
+        return refused("user-handle");
+    }
+    if ((info.credentialDeviceType === "multiDevice") !== credential.backupEligible) {
+        return refused("backup-eligibility");
+    }
+    // An authenticator that keeps no count answers 0 every time.
+    const kept = info.newCounter === 0 && credential.signCount === 0;
+    if (!kept && info.newCounter <= credential.signCount)
+        return refused("sign-count");
+    return {
+        kind: "asserted",
+        credential: { ...credential, signCount: info.newCounter, backedUp: info.credentialBackedUp },
+        userVerified: info.userVerified,
+    };
+}

package/webauthn/src/contract.d.ts

@@ -0,0 +1,90 @@
+/** WebAuthn's user verification requirement; only `required` refuses a response without it. */
+export type Verification = "required" | "preferred" | "discouraged";
+/** A credential to check assertions with; ids, keys and handles are unpadded base64url. Its holder may keep it. */
+export interface Credential {
+    readonly id: string;
+    readonly publicKey: string;
+    readonly signCount: number;
+    readonly userHandle: string;
+    readonly backupEligible: boolean;
+    readonly backedUp: boolean;
+    readonly transports?: readonly string[];
+}
+export type CeremonyRefusal = "malformed" | "challenge" | "origin" | "top-origin" | "rp" | "algorithm" | "signature" | "sign-count" | "user-handle" | "user-verification" | "backup-eligibility";
+export type Asserted = 
+/** `credential` carries the new sign count and backup state, for the holder to keep. */
+{
+    readonly kind: "asserted";
+    readonly credential: Credential;
+    readonly userVerified: boolean;
+} | {
+    readonly kind: "refused";
+    readonly reason: CeremonyRefusal;
+};
+/** Ceremonies whose challenge, its end (`until`, on `kernel`'s clock) and credential the caller keeps and hands over once. */
+export interface Ceremonies {
+    /** Options for a new credential, and the challenge to keep for its answer; a discoverable one unless told otherwise. */
+    creation(user: {
+        readonly handle: string;
+        readonly name: string;
+    }, exclude: readonly string[], v: Verification, asked?: {
+        readonly discoverable?: boolean;
+    }): {
+        readonly options: unknown;
+        readonly challenge: string;
+        readonly until: number;
+    };
+    attest(response: unknown, challenge: string, handle: string, v: Verification, until?: number): Promise<{
+        readonly kind: "attested";
+        readonly credential: Credential;
+    } | {
+        readonly kind: "refused";
+        readonly reason: CeremonyRefusal;
+    }>;
+    /** Options for an assertion by one of `allow`, and the challenge to keep for its answer. */
+    request(allow: readonly Credential[], v: Verification): {
+        readonly options: unknown;
+        readonly challenge: string;
+        readonly until: number;
+    };
+    assert(response: unknown, challenge: string, credential: Credential, v: Verification, until?: number): Promise<Asserted>;
+}
+export declare const ceremonies: import("@o3co/auth-provider-foundation/kernel").Contract<Ceremonies>;
+/** Assertions by the discoverable passkeys webauthn keeps. Throws Unavailable when the store cannot tell. */
+export interface Passkeys {
+    /** The same for everyone: reads nothing and lists no credential. Only `requester` redeems it. */
+    challenge(requester: string): Promise<{
+        readonly options: unknown;
+    }>;
+    /** `requester` is who redeems: a challenge made for another is refused as `challenge`. */
+    assert(response: unknown, requester: string): Promise<{
+        readonly kind: "asserted";
+        readonly subject: string;
+        /** When the challenge was made, on `kernel`'s clock. */
+        readonly challengedAt: number;
+        readonly userVerified: boolean;
+        readonly backupEligible: boolean;
+    } | {
+        readonly kind: "refused";
+        readonly reason: CeremonyRefusal | "unknown-credential" | "no-user-handle" | "raced";
+    }>;
+}
+export declare const passkeys: import("@o3co/auth-provider-foundation/kernel").Contract<Passkeys>;
+export type RegistrationRefusal = CeremonyRefusal | "unreadable" | "no-challenge" | "conflict" | "full";
+/** Passkeys for a subject the caller vouches for, each answering a challenge made for it, once. Throws Unavailable when the store cannot tell. */
+export interface Registrations {
+    /** Options for a new passkey of `subject`, excluding its own; its first options make its user handle. */
+    creation(subject: string): Promise<{
+        readonly options: unknown;
+    }>;
+    register(subject: string, response: unknown, nickname?: string): Promise<{
+        readonly kind: "registered";
+        readonly credential: Credential;
+    } | {
+        readonly kind: "refused";
+        readonly reason: RegistrationRefusal;
+    }>;
+}
+export declare const registrations: import("@o3co/auth-provider-foundation/kernel").Contract<Registrations>;
+export { credentialOf, freshHandle } from "./records.js";
+export * from "./store.js";

package/webauthn/src/contract.js

@@ -0,0 +1,6 @@
+import { contract } from "@o3co/auth-provider-foundation/kernel";
+export const ceremonies = contract("webauthn.ceremonies");
+export const passkeys = contract("webauthn.passkeys");
+export const registrations = contract("webauthn.registrations");
+export { credentialOf, freshHandle } from "./records.js";
+export * from "./store.js";

package/webauthn/src/module.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@o3co/auth-provider-foundation/kernel").Module;
+export default _default;

package/webauthn/src/module.js

@@ -0,0 +1,35 @@
+import { defineModule } from "@o3co/auth-provider-foundation/kernel";
+import { ceremoniesFor } from "./ceremony/ceremony.js";
+import { ceremonies, challengeStore, passkeyStore, passkeys, registrations } from "./contract.js";
+import { passkeysOver } from "./passkeys.js";
+import { freshHandle, keptChallenges, keptPasskeys } from "./records.js";
+import { registrationsOver } from "./registration/registrations.js";
+import { section } from "./section.js";
+const relyingParty = (s) => ({
+    id: s["rp-id"],
+    name: s["rp-name"],
+    origins: s.origins,
+    topOrigins: s["top-origins"],
+    timeoutMs: s["challenge-seconds"] * 1000,
+});
+const passkeysOf = async (c) => keptPasskeys(await c.get(passkeyStore));
+const challengesOf = async (c) => keptChallenges(await c.get(challengeStore), c.clock.now, c.section["challenge-seconds"] * 1000);
+export default defineModule({ name: "webauthn", section, replicaSafe: true }, (m) => [
+    m
+        .provide(ceremonies)
+        .by((c) => ceremoniesFor(relyingParty(c.section), c.random.bytes, c.clock.now)),
+    m.provide(passkeys).by(async (c) => passkeysOver({
+        ceremonies: await c.get(ceremonies),
+        records: await passkeysOf(c),
+        challenges: await challengesOf(c),
+        verification: c.section["user-verification"],
+    })),
+    m.provide(registrations).by(async (c) => registrationsOver({
+        ceremonies: await c.get(ceremonies),
+        records: await passkeysOf(c),
+        challenges: await challengesOf(c),
+        verification: c.section["user-verification"],
+        max: c.section["max-credentials"],
+        freshHandle: () => freshHandle(c.random.bytes),
+    })),
+]);

package/webauthn/src/passkeys.d.ts

@@ -0,0 +1,10 @@
+import type { Ceremonies, Passkeys, Verification } from "./contract.js";
+import type { KeptChallenges, KeptPasskeys } from "./records.js";
+export interface PasskeyParts {
+    readonly ceremonies: Ceremonies;
+    readonly records: KeptPasskeys;
+    readonly challenges: KeptChallenges;
+    readonly verification: Verification;
+}
+/** Assertions by the passkeys webauthn keeps, each found by the credential it names. */
+export declare function passkeysOver(p: PasskeyParts): Passkeys;

package/webauthn/src/passkeys.js

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto";
+import { challengeOf } from "./ceremony/ceremony.js";
+const refused = (reason) => ({ kind: "refused", reason });
+// A digest keeps the challenge's record one size, whatever the requester sent.
+const digestOf = (requester) => createHash("sha256").update(requester).digest("base64url");
+/** Assertions by the passkeys webauthn keeps, each found by the credential it names. */
+export function passkeysOver(p) {
+    return {
+        challenge: async (requester) => {
+            const { options, challenge } = p.ceremonies.request([], p.verification);
+            await p.challenges.open(challenge, { kind: "assertion", requester: digestOf(requester) });
+            return { options };
+        },
+        assert: async (response, requester) => {
+            const answered = response;
+            // Without a handle nothing ties the key to its holder: refused before the store is asked.
+            const handle = answered?.response?.userHandle;
+            if (typeof handle !== "string" || handle === "")
+                return refused("no-user-handle");
+            const challenge = challengeOf(response);
+            if (challenge === undefined || typeof answered?.id !== "string")
+                return refused("malformed");
+            const opened = await p.challenges.take(challenge);
+            if (opened?.kind !== "assertion" || opened.requester !== digestOf(requester)) {
+                return refused("challenge");
+            }
+            const found = await p.records.passkey(answered.id);
+            if (!found)
+                return refused("unknown-credential");
+            const holder = await p.records.holder(found.subject);
+            if (!holder?.credentials.includes(answered.id))
+                return refused("unknown-credential");
+            const credential = { ...found.credential, userHandle: holder.handle };
+            const asserted = await p.ceremonies.assert(response, challenge, credential, p.verification);
+            if (asserted.kind === "refused")
+                return asserted;
+            if ((await p.records.count(credential, asserted.credential)) === "raced") {
+                return refused("raced");
+            }
+            return {
+                kind: "asserted",
+                subject: found.subject,
+                challengedAt: opened.at,
+                userVerified: asserted.userVerified,
+                backupEligible: credential.backupEligible,
+            };
+        },
+    };
+}

package/webauthn/src/records.d.ts

@@ -0,0 +1,47 @@
+import type { Credential } from "./contract.js";
+import type { ChallengeStore, PasskeyStore } from "./store.js";
+/** Whether `text` is unpadded base64url of 1 to `max` bytes: the one spelling of those bytes. */
+export declare function isCanonical(text: unknown, max: number): text is string;
+export declare const handleBytes = 64;
+export declare const idBytes = 1023;
+export interface Holder {
+    readonly handle: string;
+    readonly credentials: readonly string[];
+}
+export interface Passkey {
+    readonly subject: string;
+    readonly credential: Omit<Credential, "userHandle">;
+}
+/** A credential in the shape webauthn writes, with its fields alone; none for any other value. */
+export declare function credentialOf(value: unknown): Credential | undefined;
+/** A new subject's user handle: 32 random bytes, unpadded base64url. */
+export declare const freshHandle: (random: (n: number) => Uint8Array) => string;
+/** Passkeys and their holders, written only in canonical form and read only in the shape written. */
+export declare function keptPasskeys(store: PasskeyStore): {
+    holder: (subject: string) => Promise<Holder | undefined>;
+    /** The subject's handle; `fresh` becomes it when the subject has none yet. */
+    handleFor: (subject: string, fresh: string) => Promise<string>;
+    passkey: (id: string) => Promise<Passkey | undefined>;
+    /** Keeps a new passkey for the subject, whose handle it was made for; an id its holder lists is a conflict. */
+    register: (subject: string, credential: Credential, max: number, nickname?: string) => Promise<"registered" | "conflict" | "full" | "malformed">;
+    /** Moves the count on from the one judged; another change first is a lost race. */
+    count: (judged: Credential, next: Credential) => Promise<"counted" | "raced">;
+};
+export type KeptPasskeys = ReturnType<typeof keptPasskeys>;
+/** What a challenge was made for: a subject's registration, or an assertion by anyone, redeemed by its requester (kept as a digest). */
+export type Purpose = {
+    readonly kind: "registration";
+    readonly subject: string;
+} | {
+    readonly kind: "assertion";
+    readonly requester: string;
+};
+/** Challenges of 32 bytes, each taken once, with when they were made. */
+export declare function keptChallenges(store: ChallengeStore, now: () => number, lifetimeMs: number): {
+    open: (challenge: string, purpose: Purpose) => Promise<void>;
+    /** The purpose and time of a challenge made and not yet taken; none for any other. */
+    take: (challenge: string) => Promise<(Purpose & {
+        readonly at: number;
+    }) | undefined>;
+};
+export type KeptChallenges = ReturnType<typeof keptChallenges>;