@yielded/auth-persistence 0.1.0-beta.24 → 0.1.0-beta.26

package/src/internal/passkey-native.ts

@@ -0,0 +1,372 @@
+import { CurrentCommitJournal } from "@yielded/auth/Hooks";
+import * as M from "@yielded/auth/Passkey";
+import { Crypto, Effect, Option, Schema } from "effect";
+import { SqlError } from "effect/sql/SqlError";
+
+import { sqlBatchAssertion } from "./d1-planning";
+import type { NativeSqlTables } from "./native-sql-table";
+import { passkeyOperationInputs } from "./passkey-inputs";
+import {
+  makePasskeyNativeReadState,
+  makePasskeyNativeState,
+  passkeyNativeInvariant,
+  type PasskeyNativeMapping,
+  type PasskeyNativeRead,
+  type PasskeyNativeReadState,
+} from "./passkey-native-state";
+import {
+  passkeyAssertionPurposes,
+  passkeyCredentialKey,
+  passkeyMatchesAccess,
+  validPasskeyCeremony,
+} from "./passkey-policy";
+import { exactSqlText } from "./sql-change";
+import {
+  CurrentSqlCommit,
+  makeSqlCommitExecutor,
+  registerSqlCommitReceipt,
+  registerSqlPostcondition,
+  registerSqlBatchPostcondition,
+  SqlBatchCommit,
+} from "./sql-commit";
+
+const unavailable = () => M.PasskeyUnavailable.make({});
+
+export const preparePasskeyNative = <Value, A>(
+  value: Value,
+  prepare: M.PreparePasskeyCommit<Value, A>,
+) =>
+  Effect.gen(function* () {
+    const journal = yield* CurrentCommitJournal;
+
+    const receipt = prepare(value, journal);
+
+    passkeyNativeInvariant(receipt?._tag === "PreparedCommit" && Effect.isEffect(receipt.read));
+    yield* registerSqlCommitReceipt(receipt);
+
+    return receipt;
+  });
+
+const services = Effect.fnUntraced(function* (
+  tables: NativeSqlTables,
+  mapping: PasskeyNativeMapping,
+  batch?: SqlBatchCommit["Service"],
+) {
+  const boundOwner = yield* Effect.serviceOption(CurrentSqlCommit);
+  const state = yield* makePasskeyNativeState(tables, mapping);
+  const executor = yield* makeSqlCommitExecutor(unavailable);
+  const crypto = yield* Crypto.Crypto;
+  const { sql, ceremony: flow, credential } = state;
+  const read = mapping.read;
+
+  const provide = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    Effect.provideService(effect, Crypto.Crypto, crypto);
+
+  const run = <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    mode: "transaction" | "statement" = "transaction",
+  ) =>
+    batch === undefined
+      ? executor.run(provide(effect), mode)
+      : executor.batch(provide(effect)).pipe(Effect.provideService(SqlBatchCommit, batch));
+
+  const advisory = <A, E, R>(effect: Effect.Effect<A, E, R>) => executor.read(provide(effect));
+
+  const issue: M.PasskeyPersistence["Service"]["issue"] = (original, prepare) =>
+    run(
+      Effect.gen(function* () {
+        const input = M.snapshotPasskeySync(passkeyOperationInputs.issue, original);
+        const ceremony = input.ceremony;
+
+        if (
+          !flow.validModule(ceremony.moduleId) ||
+          !validPasskeyCeremony(ceremony) ||
+          ceremony.purpose === "registration"
+        )
+          return yield* preparePasskeyNative({ _tag: "Rejected" }, prepare);
+        const statement = flow.insert(ceremony);
+        let changed: number;
+
+        if (batch !== undefined) {
+          yield* flow.stage(statement, 1);
+          changed = 1;
+        } else {
+          changed = yield* flow.change(statement).pipe(
+            Effect.catchIf(
+              (error) => Schema.is(SqlError)(error) && error.reason._tag === "UniqueViolation",
+              () => Effect.succeed(0),
+            ),
+          );
+        }
+
+        return yield* preparePasskeyNative(
+          changed === 1 ? { _tag: "Issued", ceremony } : { _tag: "Rejected" },
+          prepare,
+        );
+      }),
+      "statement",
+    );
+
+  const persistence: M.PasskeyPersistence["Service"] = {
+    issue,
+    context: (original) =>
+      advisory(
+        Effect.suspend(() => flow.context(M.snapshotPasskeySync(M.PasskeyAccess, original))),
+      ),
+    consume: (original, prepare) =>
+      run(
+        Effect.gen(function* () {
+          const input = M.snapshotPasskeySync(passkeyOperationInputs.consume, original);
+          const captured = input.credential;
+
+          const revision = captured.revision.credentials.find(
+            (entry) => entry.credentialId === captured.credentialId,
+          );
+
+          const assertion = input.assertion;
+
+          if (
+            !flow.validModule(input.access.moduleId) ||
+            !passkeyMatchesAccess(input.ceremony, input.access) ||
+            !passkeyAssertionPurposes.some((purpose) => purpose === input.ceremony.purpose) ||
+            !validPasskeyCeremony(input.ceremony) ||
+            revision === undefined ||
+            !captured.active ||
+            captured.rpId !== input.ceremony.profile.rpId ||
+            assertion.protocolCredentialId !== captured.protocolCredentialId ||
+            assertion.backupEligible !== captured.backupEligible ||
+            (assertion.userHandle !== undefined && assertion.userHandle !== captured.userHandle)
+          )
+            return yield* preparePasskeyNative("Rejected", prepare);
+          const consumed = flow.consume(input.access, input.ceremony);
+
+          if (batch === undefined) {
+            if ((yield* flow.change(consumed)) !== 1)
+              return yield* preparePasskeyNative("Rejected", prepare);
+          } else yield* flow.stage(consumed, 1);
+          const key = yield* passkeyCredentialKey(captured.rpId, captured.protocolCredentialId);
+
+          const exact = (column: string, value: unknown) =>
+            exactSqlText(sql, credential.column(column), credential.value(column, value));
+
+          const counter = credential.column(read.credential.counter);
+          const next = credential.value(read.credential.counter, assertion.counter);
+
+          const merged = captured.backupEligible
+            ? sql`case when ${counter} > ${next} then ${counter} else ${next} end`
+            : next;
+
+          const identity = [
+            exact(read.credential.credentialId, captured.credentialId),
+            exact(read.credential.credentialKey, key),
+            exact(read.credential.credentialRevision, revision.revision),
+            sql`${credential.column(read.credential.backupEligible)} = ${credential.value(read.credential.backupEligible, mapping.telemetry.encodeBackupEligible(captured.backupEligible))}`,
+            state.active("credential"),
+          ];
+
+          const statement = sql`${credential.update({
+            [read.credential.counter]: merged,
+            [read.credential.backupState]: mapping.telemetry.encodeBackupState(
+              assertion.backupState,
+            ),
+            [mapping.telemetry.lastUsedAt]: state.storedNow,
+          })} where ${sql.and([
+            ...identity,
+            captured.backupEligible
+              ? sql`true`
+              : sql`((${counter} = 0 and ${next} = 0) or ${counter} < ${next})`,
+          ])}`;
+
+          let changed: number;
+
+          if (batch === undefined) {
+            changed = yield* flow.change(statement);
+            if (
+              changed === 0 &&
+              sql.onDialectOrElse({ mysql: () => true, orElse: () => false }) &&
+              (captured.backupEligible || assertion.counter === 0)
+            ) {
+              // mysql2 can disable FOUND_ROWS. The UPDATE still holds the row lock;
+              // prove the unchanged telemetry matched this exact semantic key.
+              const matched =
+                yield* sql`select 1 as matched from ${credential.name} where ${sql.and(identity)} and ${captured.backupEligible ? sql`${counter} >= ${next}` : sql`${counter} = 0`} and ${credential.column(read.credential.backupState)} = ${credential.value(read.credential.backupState, mapping.telemetry.encodeBackupState(assertion.backupState))}`;
+
+              if (matched.length === 1) changed = 1;
+            }
+          } else {
+            yield* flow.stage(statement, 1);
+            changed = 1;
+          }
+
+          if (Option.isSome(boundOwner)) {
+            // Protect the accepted result from later bound application SQL. BE
+            // retains the observed accepted floor; it does not compare an entire
+            // telemetry snapshot or reject valid out-of-order assertions.
+            const acceptedCounter = captured.backupEligible
+              ? sql`${counter} >= ${credential.value(read.credential.counter, Math.max(captured.counter, assertion.counter))}`
+              : sql`${counter} = ${next}`;
+
+            const condition = sql.and([
+              flow.absent(input.access),
+              changed === 1
+                ? sql`exists(select 1 from ${credential.name} where ${sql.and(identity)} and ${acceptedCounter}
+                    and ${credential.column(read.credential.backupState)} = ${credential.value(read.credential.backupState, mapping.telemetry.encodeBackupState(assertion.backupState))})`
+                : sql`true`,
+            ]);
+
+            if (batch === undefined) {
+              yield* registerSqlPostcondition({
+                name: "passkey-consume-preserved",
+                check: Effect.gen(function* () {
+                  const rows = yield* sql`select 1 where ${condition}`;
+
+                  passkeyNativeInvariant(rows.length === 1);
+                }),
+              });
+            } else {
+              yield* registerSqlBatchPostcondition({
+                name: "passkey-consume-preserved",
+                statement: sqlBatchAssertion(sql, condition),
+              });
+            }
+          }
+
+          return yield* preparePasskeyNative(changed === 1 ? "Verified" : "Rejected", prepare);
+        }),
+      ),
+    cleanup: (original, prepare) =>
+      run(
+        Effect.gen(function* () {
+          const input = M.snapshotPasskeySync(passkeyOperationInputs.cleanup, original);
+
+          passkeyNativeInvariant(flow.validModule(input.moduleId));
+
+          return yield* preparePasskeyNative(
+            yield* flow.cleanup(input.moduleId, input.limit, batch !== undefined),
+            prepare,
+          );
+        }),
+        "statement",
+      ),
+  };
+
+  const credentials = makePasskeyNativeCredentialService(state, read, advisory);
+
+  return {
+    batch: batch !== undefined,
+    state,
+    executor,
+    run,
+    advisory,
+    passkeyPersistence: persistence,
+    passkeyCredentials: credentials,
+  };
+});
+
+export const makeNativePasskeyServices = (tables: NativeSqlTables, mapping: PasskeyNativeMapping) =>
+  services(tables, mapping);
+
+export const makeBatchPasskeyServices = (tables: NativeSqlTables, mapping: PasskeyNativeMapping) =>
+  Effect.flatMap(SqlBatchCommit, (batch) => services(tables, mapping, batch));
+
+export type NativePasskeyServices = Effect.Success<ReturnType<typeof makeNativePasskeyServices>>;
+
+const makePasskeyNativeCredentialService = (
+  state: PasskeyNativeReadState,
+  read: PasskeyNativeRead,
+  advisory: <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<
+    A,
+    M.PasskeyUnavailable,
+    Exclude<
+      Exclude<Exclude<R, Crypto.Crypto>, import("effect/sql/SqlClient").SqlClient>,
+      import("@yielded/auth/Hooks").LifecycleHooks
+    >
+  >,
+) => {
+  const { sql, joinedSubject: subject, joinedFactor: factor, joinedCredential: credential } = state;
+
+  const credentials: M.PasskeyCredentials["Service"] = {
+    lookup: (original) =>
+      advisory(
+        Effect.gen(function* () {
+          const input = M.snapshotPasskeySync(passkeyOperationInputs.lookup, original);
+
+          return yield* state.lookup(input.rpId, input.protocolCredentialId);
+        }),
+      ),
+    listForSubject: (original) =>
+      advisory(
+        Effect.gen(function* () {
+          const input = M.snapshotPasskeySync(passkeyOperationInputs.listForSubject, original);
+
+          const nativeId = state.native(input.subjectId);
+
+          const rows =
+            yield* sql`select ${subject.fields("s_")}, ${factor.fields("f_")}, ${credential.fields("c_")}
+        from ${state.selected("subject", "passkey_subject")}
+        left join ${state.selected("authority", "passkey_factor")} on ${factor.column(read.authority.subjectId)} = ${factor.value(read.authority.subjectId, nativeId)}
+        left join ${state.selected("credential", "passkey_credential")} on ${credential.column(read.credential.subjectId)} = ${credential.value(read.credential.subjectId, nativeId)} and ${credential.column(read.credential.rpId)} = ${credential.value(read.credential.rpId, input.rpId)}
+        where ${subject.column(read.subject.id)} = ${subject.value(read.subject.id, nativeId)} limit 4097`;
+
+          if (rows.length === 0 || rows.length > 4096) return undefined;
+          const subjectRow = subject.decode(rows[0]!, "s_");
+
+          passkeyNativeInvariant(
+            rows.every((selected) => {
+              const other = subject.decode(selected, "s_");
+
+              return (
+                state.sameId(read.subject.decodeId(other), nativeId) &&
+                other[read.subject.securityRevision] === subjectRow[read.subject.securityRevision]
+              );
+            }),
+          );
+
+          const revision = state.revision(
+            subjectRow,
+            rows.map((row) => factor.decode(row, "f_")),
+          );
+
+          passkeyNativeInvariant(revision.subjectId === input.subjectId);
+          const values = new Map<string, M.PasskeyCredential>();
+
+          for (const selected of rows) {
+            const row = credential.decode(selected, "c_");
+
+            if (row[read.credential.credentialId] === null) continue;
+            const decoded = yield* state.decodeCredential(row, revision, subjectRow);
+
+            if (decoded !== undefined) values.set(decoded.credentialId, decoded);
+          }
+          const userHandle = values.values().next().value?.userHandle;
+
+          return M.snapshotPasskeySync(M.PasskeyEnrollmentSnapshot, {
+            revision,
+            ...(userHandle === undefined ? {} : { userHandle }),
+            credentials: [...values.values()].map((value) => ({
+              type: "public-key" as const,
+              id: value.protocolCredentialId,
+            })),
+          });
+        }),
+      ),
+  };
+
+  return credentials;
+};
+
+export const makeNativePasskeyCredentialServices = Effect.fnUntraced(function* (
+  tables: NativeSqlTables,
+  mapping: PasskeyNativeRead,
+) {
+  const state = yield* makePasskeyNativeReadState(tables, mapping);
+  const executor = yield* makeSqlCommitExecutor(unavailable);
+  const crypto = yield* Crypto.Crypto;
+
+  const advisory = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    executor.read(Effect.provideService(effect, Crypto.Crypto, crypto));
+
+  return { passkeyCredentials: makePasskeyNativeCredentialService(state, mapping, advisory) };
+});

package/src/internal/passkey-policy.ts

@@ -0,0 +1,246 @@
+import {
+  PasskeyUnavailable,
+  type PasskeyCeremony,
+  PasskeyCredential,
+  type PasskeyRevision,
+  snapshotPasskeySync,
+  type PasskeyAccess,
+  type PasskeyActionAuthorization,
+  type PasskeyManagementPolicy,
+  type PasskeyRequirement,
+} from "@yielded/auth/Passkey";
+import { Crypto, DateTime, Effect, Schema } from "effect";
+
+const invariant: (value: unknown) => asserts value = (value) => {
+  if (!value) throw PasskeyUnavailable.make({});
+};
+
+const encoder = new TextEncoder();
+
+const decoder = new TextDecoder("utf-8", { fatal: true });
+
+/** RP tuples have no collation-dependent string identity. */
+export const passkeyKey = Effect.fnUntraced(function* (
+  kind: string,
+  fields: ReadonlyArray<string>,
+) {
+  const values = ["effect-auth/passkey/" + kind + "/v1", ...fields].map((field) => {
+    const bytes = encoder.encode(field);
+
+    invariant(decoder.decode(bytes) === field);
+
+    return bytes;
+  });
+
+  const packed = new Uint8Array(values.reduce((size, bytes) => size + 4 + bytes.length, 0));
+  const view = new DataView(packed.buffer);
+  let offset = 0;
+
+  for (const bytes of values) {
+    view.setUint32(offset, bytes.length, false);
+    packed.set(bytes, offset + 4);
+    offset += 4 + bytes.length;
+  }
+
+  const crypto = yield* Crypto.Crypto;
+  const hashed = yield* crypto.digest("SHA-256", packed);
+
+  return "v1:" + Array.from(hashed, (value) => value.toString(16).padStart(2, "0")).join("");
+});
+
+export const passkeyCredentialKey = (rpId: string, id: string) =>
+  passkeyKey("credential", [rpId, id]);
+
+/** Private passkeyStorage is decoded Type data, never a consumer wire transform. */
+export const passkeyStorage = <S extends Schema.Codec<unknown, unknown, never, never>>(
+  schema: S,
+  maximumBytes: number,
+) => {
+  const codec = Schema.fromJsonString(Schema.toCodecJson(Schema.toType(schema)));
+
+  const encode = (value: S["Type"]) => {
+    const text = "v1:" + Schema.encodeSync(codec)(snapshotPasskeySync(schema, value));
+
+    invariant(encoder.encode(text).length <= maximumBytes);
+
+    return text;
+  };
+
+  return {
+    encode,
+    decode: (text: unknown): S["Type"] => {
+      invariant(typeof text === "string" && text.startsWith("v1:"));
+      invariant(encoder.encode(text).length <= maximumBytes);
+      const value = snapshotPasskeySync(schema, Schema.decodeSync(codec)(text.slice(3)));
+
+      invariant(encode(value) === text);
+
+      return value;
+    },
+  };
+};
+
+// Legal 32 x 16 x 2048 origins require more than one MiB before JSON escaping.
+export const passkeyCredentialStorage = passkeyStorage(PasskeyCredential, 512 * 1024);
+
+export const samePasskeyCredential = (left: PasskeyCredential, right: PasskeyCredential) => {
+  const semantic = (value: PasskeyCredential) => ({
+    ...value,
+    counter: 0,
+    backupState: false,
+    revision: { ...value.revision, credentials: [] },
+  });
+
+  return (
+    passkeyCredentialStorage.encode(semantic(left)) ===
+    passkeyCredentialStorage.encode(semantic(right))
+  );
+};
+
+export const samePasskeyRevision = (
+  left: typeof PasskeyRevision.Type,
+  right: typeof PasskeyRevision.Type,
+) => {
+  const pairs = new Map(left.credentials.map((item) => [item.credentialId, item.revision]));
+
+  return (
+    left.subjectId === right.subjectId &&
+    left.securityRevision === right.securityRevision &&
+    pairs.size === left.credentials.length &&
+    new Set(right.credentials.map((item) => item.credentialId)).size === right.credentials.length &&
+    pairs.size === right.credentials.length &&
+    right.credentials.every((item) => pairs.get(item.credentialId) === item.revision)
+  );
+};
+
+export const passkeyAssertionPurposes = ["sign-in", "pending", "step-up", "action"] as const;
+
+const contextPurpose = {
+  SignIn: "sign-in",
+  Pending: "pending",
+  StepUp: "step-up",
+  Action: "action",
+  Enrollment: "enrollment",
+  Registration: "registration",
+} as const;
+
+export const validPasskeyCeremony = (ceremony: PasskeyCeremony) =>
+  ceremony.expiresAtMillis > ceremony.issuedAtMillis &&
+  ceremony.expiresAtMillis <= ceremony.requestBindingExpiresAtMillis &&
+  contextPurpose[ceremony.context._tag] === ceremony.purpose &&
+  new Set(ceremony.allowedCredentials.map((item) => item.id)).size ===
+    ceremony.allowedCredentials.length;
+
+export const passkeyMatchesAccess = (ceremony: PasskeyCeremony, access: PasskeyAccess) =>
+  ceremony.moduleId === access.moduleId &&
+  ceremony.purpose === access.purpose &&
+  ceremony.flowId === access.flowId &&
+  ceremony.requestBindingVerifier === access.requestBindingVerifier &&
+  ceremony.requestBindingExpiresAtMillis === access.requestBindingExpiresAtMillis;
+
+export interface PasskeyActionFacts {
+  readonly moduleId: string;
+  readonly revision: typeof PasskeyRevision.Type;
+  readonly nowMillis: number;
+  readonly currentRequirement: typeof PasskeyRequirement.Type;
+  readonly expected: {
+    readonly action: PasskeyActionAuthorization["challenge"]["action"];
+    readonly commandId: string;
+    readonly flowId: string;
+    readonly bindingDigest: string;
+    readonly revision: typeof PasskeyRevision.Type;
+  };
+  readonly originalRequirement?: typeof PasskeyRequirement.Type;
+}
+
+/** Reject stale bindings before evaluating application requirements. */
+export const validPasskeyActionEvidence = (
+  facts: Pick<PasskeyActionFacts, "moduleId" | "revision" | "expected" | "nowMillis">,
+  authorization: PasskeyActionAuthorization,
+) => {
+  const { challenge, evidence } = authorization;
+  const { expected, revision, nowMillis: now } = facts;
+
+  if (
+    challenge.moduleId !== facts.moduleId ||
+    challenge.action !== expected.action ||
+    challenge.commandId !== expected.commandId ||
+    challenge.flowId !== expected.flowId ||
+    challenge.bindingDigest !== expected.bindingDigest ||
+    evidence.flowId !== expected.flowId ||
+    evidence.bindingDigest !== expected.bindingDigest ||
+    !samePasskeyRevision(challenge.revision, expected.revision) ||
+    revision.subjectId !== expected.revision.subjectId ||
+    revision.securityRevision !== expected.revision.securityRevision ||
+    evidence.revision.subjectId !== revision.subjectId ||
+    evidence.revision.securityRevision !== revision.securityRevision
+  )
+    return false;
+  for (const requested of [expected.revision, evidence.revision])
+    if (
+      requested.credentials.some(
+        (item) =>
+          !revision.credentials.some(
+            (current) =>
+              current.credentialId === item.credentialId && current.revision === item.revision,
+          ),
+      )
+    )
+      return false;
+  if (
+    evidence.proofs.some(
+      (proof) =>
+        DateTime.toEpochMillis(proof.verifiedAt) > now ||
+        !evidence.revision.credentials.some((item) => item.credentialId === proof.credentialId),
+    )
+  )
+    return false;
+
+  return true;
+};
+
+/** SQL policy predicates remain native. This authorizes the exact evidence and
+ * returns the deadline every backend must retain through its final commit. */
+export const assessPasskeyAction = (
+  facts: PasskeyActionFacts,
+  authorization: PasskeyActionAuthorization,
+  policy: PasskeyManagementPolicy,
+) => {
+  if (!validPasskeyActionEvidence(facts, authorization)) return undefined;
+  const { evidence } = authorization;
+  const now = facts.nowMillis;
+  let expiresBefore = Infinity;
+
+  for (const requirement of [
+    authorization.requirement,
+    facts.currentRequirement,
+    ...(facts.originalRequirement === undefined ? [] : [facts.originalRequirement]),
+  ]) {
+    const age = Math.min(policy.maximumEvidenceAgeMillis, requirement.maximumAgeMillis);
+
+    const fresh = evidence.proofs.filter(
+      (proof) => now - DateTime.toEpochMillis(proof.verifiedAt) < age,
+    );
+
+    const factors = new Set(fresh.flatMap((proof) => proof.factors));
+
+    if (
+      !requirement.alternatives.some(
+        (alternative) =>
+          alternative.factors.every((factor) => factors.has(factor)) &&
+          new Set(fresh.map((proof) => proof.credentialId)).size >=
+            alternative.minimumCredentials &&
+          fresh.some(
+            (proof) =>
+              (!alternative.userVerified || proof.userVerified) &&
+              (!alternative.phishingResistant || proof.phishingResistant),
+          ),
+      )
+    )
+      return undefined;
+    for (const proof of fresh)
+      expiresBefore = Math.min(expiresBefore, DateTime.toEpochMillis(proof.verifiedAt) + age);
+  }
+
+  return { notBeforeMillis: now, expiresBeforeMillis: expiresBefore };
+};