@meith/accounts 0.16.0

package/src/webauthn/service.ts

@@ -0,0 +1,266 @@
+import { ConflictError, ForbiddenError, NotFoundError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import { encodeBase64Url, randomBase64Url } from '../crypto/base64url'
+import type {
+  AccountRecord,
+  AccountRepository,
+  Clock,
+  PasskeyRecord,
+  PasskeyRepository,
+  UserIdentityRepository,
+} from '../ports'
+import type { IdentityService, LoginResult, RequestContext } from '../service'
+import { SUPPORTED_ALGORITHMS } from './cose'
+import type { AssertionResponse, RegistrationResponse } from './verify'
+import { type RelyingParty, verifyAssertion, verifyRegistration } from './verify'
+
+export const PASSKEY_LABEL_MAX = 60
+
+export const PASSKEY_LIMIT = 20
+
+export const CHALLENGE_BYTES = 32
+
+export const REMOVE_LAST_CREDENTIAL =
+  'That is the only way you have left to sign in. Set a password first, then remove it.'
+
+export interface PasskeyDeps {
+  readonly identity: IdentityService
+  readonly accounts: AccountRepository
+  readonly passkeys: PasskeyRepository
+  readonly identities?: UserIdentityRepository
+  readonly clock?: Clock
+}
+
+export interface PasskeyRegistrationOptions {
+  readonly challenge: string
+  readonly rp: { readonly id: string; readonly name: string }
+  readonly user: { readonly id: string; readonly name: string; readonly displayName: string }
+  readonly pubKeyCredParams: readonly { readonly type: 'public-key'; readonly alg: number }[]
+  readonly excludeCredentials: readonly {
+    readonly type: 'public-key'
+    readonly id: string
+  }[]
+  readonly authenticatorSelection: {
+    readonly residentKey: 'preferred'
+    readonly userVerification: 'preferred'
+  }
+  readonly timeout: number
+  readonly attestation: 'none'
+}
+
+export interface PasskeyAssertionOptions {
+  readonly challenge: string
+  readonly rpId: string
+  readonly userVerification: 'preferred'
+  readonly timeout: number
+  readonly allowCredentials?: readonly {
+    readonly type: 'public-key'
+    readonly id: string
+  }[]
+}
+
+const TIMEOUT_MS = 120_000
+
+export function newChallenge(): string {
+  return randomBase64Url(CHALLENGE_BYTES)
+}
+
+export class PasskeyService {
+  private readonly identity: IdentityService
+  private readonly accounts: AccountRepository
+  private readonly passkeys: PasskeyRepository
+  private readonly identities: UserIdentityRepository | undefined
+  private readonly now: Clock
+
+  constructor(deps: PasskeyDeps) {
+    this.identity = deps.identity
+    this.accounts = deps.accounts
+    this.passkeys = deps.passkeys
+    this.identities = deps.identities
+    this.now = deps.clock ?? (() => new Date())
+  }
+
+  async registrationOptions(input: {
+    readonly userId: number
+    readonly challenge: string
+    readonly relyingParty: RelyingParty
+    readonly boardName: string
+  }): Promise<PasskeyRegistrationOptions> {
+    const account = await this.accounts.findById(input.userId)
+    if (account === null) throw new NotFoundError(msg('error.accounts.account-longer-exists'))
+
+    const existing = await this.passkeys.listForUser(input.userId)
+    if (existing.length >= PASSKEY_LIMIT) {
+      throw new ConflictError(
+        `An account may hold ${PASSKEY_LIMIT} passkeys. Remove one before adding another.`,
+      )
+    }
+
+    return {
+      challenge: input.challenge,
+      rp: { id: input.relyingParty.id, name: input.boardName },
+      user: {
+        id: userHandle(account.id),
+        name: account.username,
+        displayName: account.username,
+      },
+      pubKeyCredParams: SUPPORTED_ALGORITHMS.map((alg) => ({ type: 'public-key', alg })),
+      excludeCredentials: existing.map((passkey) => ({
+        type: 'public-key',
+        id: passkey.credentialId,
+      })),
+      authenticatorSelection: { residentKey: 'preferred', userVerification: 'preferred' },
+      timeout: TIMEOUT_MS,
+      attestation: 'none',
+    }
+  }
+
+  assertionOptions(input: {
+    readonly challenge: string
+    readonly relyingParty: RelyingParty
+    readonly allowCredentials?: readonly string[]
+  }): PasskeyAssertionOptions {
+    return {
+      challenge: input.challenge,
+      rpId: input.relyingParty.id,
+      userVerification: 'preferred',
+      timeout: TIMEOUT_MS,
+      ...(input.allowCredentials === undefined
+        ? {}
+        : {
+            allowCredentials: input.allowCredentials.map((id) => ({
+              type: 'public-key' as const,
+              id,
+            })),
+          }),
+    }
+  }
+
+  async enrol(input: {
+    readonly userId: number
+    readonly label: string
+    readonly response: RegistrationResponse
+    readonly expectedChallenge: string
+    readonly relyingParty: RelyingParty
+  }): Promise<PasskeyRecord> {
+    const verified = await verifyRegistration({
+      response: input.response,
+      expectedChallenge: input.expectedChallenge,
+      relyingParty: input.relyingParty,
+    })
+
+    const claimed = await this.passkeys.findByCredentialId(verified.credentialId)
+    if (claimed !== null) {
+      throw new ConflictError(msg('error.accounts.passkey-already-registered-here'))
+    }
+
+    return this.passkeys.create({
+      userId: input.userId,
+      credentialId: verified.credentialId,
+      publicKey: verified.publicKey,
+      signCount: verified.signCount,
+      label: passkeyLabel(input.label),
+      transports:
+        input.response.transports === undefined || input.response.transports.length === 0
+          ? null
+          : input.response.transports.join(','),
+      now: this.now(),
+    })
+  }
+
+  async authenticate(input: {
+    readonly credentialId: string
+    readonly response: AssertionResponse
+    readonly expectedChallenge: string
+    readonly relyingParty: RelyingParty
+    readonly context?: RequestContext
+  }): Promise<{ readonly account: AccountRecord; readonly login: LoginResult }> {
+    const passkey = await this.passkeys.findByCredentialId(input.credentialId)
+    if (passkey === null) {
+      throw new ForbiddenError(msg('error.accounts.passkey-registered-board'))
+    }
+
+    const verified = await verifyAssertion({
+      response: input.response,
+      expectedChallenge: input.expectedChallenge,
+      relyingParty: input.relyingParty,
+      publicKey: passkey.publicKey,
+      storedSignCount: passkey.signCount,
+    })
+
+    const account = await this.accounts.findById(passkey.userId)
+    if (account === null) {
+      throw new ForbiddenError(msg('error.accounts.account-behind-passkey-longer-exists'))
+    }
+
+    const login = await this.identity.startSessionFor(account, input.context ?? {})
+    await this.passkeys.markUsed(passkey.id, verified.signCount, this.now())
+
+    return { account, login }
+  }
+
+  /**
+   * The same signature check as signing in, against one named account and with
+   * no session at the end of it. A second factor has to prove the device
+   * belongs to the member who has just given their password — accepting any
+   * registered passkey would let anybody past anybody's second step.
+   */
+  async proveOwnership(input: {
+    readonly userId: number
+    readonly credentialId: string
+    readonly response: AssertionResponse
+    readonly expectedChallenge: string
+    readonly relyingParty: RelyingParty
+  }): Promise<boolean> {
+    const passkey = await this.passkeys.findByCredentialId(input.credentialId)
+    if (passkey === null || passkey.userId !== input.userId) return false
+
+    const verified = await verifyAssertion({
+      response: input.response,
+      expectedChallenge: input.expectedChallenge,
+      relyingParty: input.relyingParty,
+      publicKey: passkey.publicKey,
+      storedSignCount: passkey.signCount,
+    })
+
+    await this.passkeys.markUsed(passkey.id, verified.signCount, this.now())
+    return true
+  }
+
+  async remove(input: {
+    readonly userId: number
+    readonly passkeyId: number
+    readonly hasPassword: boolean
+    readonly usableProviders?: readonly string[]
+  }): Promise<void> {
+    const remaining = (await this.passkeys.listForUser(input.userId)).filter(
+      (passkey) => passkey.id !== input.passkeyId,
+    )
+
+    const usable = input.usableProviders ?? []
+    const links =
+      this.identities === undefined
+        ? []
+        : (await this.identities.listForUser(input.userId)).filter((identity) =>
+            usable.includes(identity.provider),
+          )
+
+    if (!input.hasPassword && remaining.length === 0 && links.length === 0) {
+      throw new ForbiddenError(REMOVE_LAST_CREDENTIAL)
+    }
+
+    const removed = await this.passkeys.remove(input.userId, input.passkeyId)
+    if (!removed) throw new NotFoundError(msg('error.accounts.passkey-already-removed'))
+  }
+}
+
+export function passkeyLabel(raw: string): string {
+  const trimmed = raw.replace(/\s+/gu, ' ').trim()
+  if (trimmed === '') return 'Passkey'
+  return [...trimmed].slice(0, PASSKEY_LABEL_MAX).join('')
+}
+
+function userHandle(userId: number): string {
+  return encodeBase64Url(new TextEncoder().encode(`u${userId}`))
+}

package/src/webauthn/verify.ts

@@ -0,0 +1,231 @@
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import { decodeBase64Url, encodeBase64Url } from '../crypto/base64url'
+import { cborBytes, cborMap, decodeCbor } from './cbor'
+import { importCoseKey, rawSignatureFromDer } from './cose'
+
+const FLAG_USER_PRESENT = 0b0000_0001
+const FLAG_USER_VERIFIED = 0b0000_0100
+const FLAG_ATTESTED_CREDENTIAL = 0b0100_0000
+
+export interface RelyingParty {
+  readonly id: string
+  readonly origin: string
+}
+
+export interface RegistrationResponse {
+  readonly clientDataJSON: string
+  readonly attestationObject: string
+  readonly transports?: readonly string[]
+}
+
+export interface RegisteredCredential {
+  readonly credentialId: string
+  readonly publicKey: string
+  readonly signCount: number
+  readonly userVerified: boolean
+}
+
+export interface AssertionResponse {
+  readonly clientDataJSON: string
+  readonly authenticatorData: string
+  readonly signature: string
+}
+
+const REFUSED = 'That passkey could not be verified. Try again.'
+
+export async function verifyRegistration(input: {
+  readonly response: RegistrationResponse
+  readonly expectedChallenge: string
+  readonly relyingParty: RelyingParty
+}): Promise<RegisteredCredential> {
+  assertClientData({
+    clientDataJSON: input.response.clientDataJSON,
+    expectedType: 'webauthn.create',
+    expectedChallenge: input.expectedChallenge,
+    expectedOrigin: input.relyingParty.origin,
+  })
+
+  const attestation = decodeOrRefuse(() =>
+    cborMap(decodeCbor(decodeBase64Url(input.response.attestationObject)).value),
+  )
+  const authData = decodeOrRefuse(() => cborBytes(attestation.get('authData')))
+  const parsed = await parseAuthenticatorData(authData, input.relyingParty.id)
+
+  if (!parsed.userPresent) {
+    throw new ValidationError(msg('error.accounts.passkey-confirmed-device'))
+  }
+
+  const credential = parsed.credential
+  if (credential === null) throw new ValidationError(REFUSED)
+
+  await decodeOrRefuseAsync(() => importCoseKey(credential.publicKey))
+
+  return {
+    credentialId: encodeBase64Url(credential.credentialId),
+    publicKey: encodeBase64Url(credential.publicKey),
+    signCount: parsed.signCount,
+    userVerified: parsed.userVerified,
+  }
+}
+
+export async function verifyAssertion(input: {
+  readonly response: AssertionResponse
+  readonly expectedChallenge: string
+  readonly relyingParty: RelyingParty
+  readonly publicKey: string
+  readonly storedSignCount: number
+}): Promise<{ readonly signCount: number }> {
+  assertClientData({
+    clientDataJSON: input.response.clientDataJSON,
+    expectedType: 'webauthn.get',
+    expectedChallenge: input.expectedChallenge,
+    expectedOrigin: input.relyingParty.origin,
+  })
+
+  const authData = decodeBase64Url(input.response.authenticatorData)
+  const parsed = await parseAuthenticatorData(authData, input.relyingParty.id)
+
+  if (!parsed.userPresent) {
+    throw new ValidationError(msg('error.accounts.passkey-confirmed-device'))
+  }
+
+  const imported = await decodeOrRefuseAsync(() => importCoseKey(decodeBase64Url(input.publicKey)))
+
+  const clientDataHash = await sha256(decodeBase64Url(input.response.clientDataJSON))
+  const signed = concat(authData, clientDataHash)
+
+  const raw = decodeBase64Url(input.response.signature)
+  const signature = imported.derSignature ? rawSignatureFromDer(raw) : raw
+
+  const verified = await crypto.subtle.verify(
+    imported.verifyParams,
+    imported.key,
+    signature as unknown as BufferSource,
+    signed as unknown as BufferSource,
+  )
+
+  if (!verified) throw new ValidationError(REFUSED)
+
+  if (parsed.signCount > 0 && parsed.signCount <= input.storedSignCount) {
+    throw new ValidationError(msg('error.accounts.passkey-replayed-counter-board-already'))
+  }
+
+  return { signCount: parsed.signCount }
+}
+
+interface ParsedAuthenticatorData {
+  readonly userPresent: boolean
+  readonly userVerified: boolean
+  readonly signCount: number
+  readonly credential: {
+    readonly credentialId: Uint8Array
+    readonly publicKey: Uint8Array
+  } | null
+}
+
+async function parseAuthenticatorData(
+  authData: Uint8Array,
+  rpId: string,
+): Promise<ParsedAuthenticatorData> {
+  if (authData.length < 37) throw new ValidationError(REFUSED)
+
+  const expectedRpIdHash = await sha256(new TextEncoder().encode(rpId))
+  if (!sameBytes(authData.subarray(0, 32), expectedRpIdHash)) {
+    throw new ValidationError(msg('error.accounts.passkey-belongs-different-site'))
+  }
+
+  const flags = authData[32]!
+  const signCount = new DataView(authData.buffer, authData.byteOffset + 33, 4).getUint32(0)
+
+  if ((flags & FLAG_ATTESTED_CREDENTIAL) === 0) {
+    return {
+      userPresent: (flags & FLAG_USER_PRESENT) !== 0,
+      userVerified: (flags & FLAG_USER_VERIFIED) !== 0,
+      signCount,
+      credential: null,
+    }
+  }
+
+  const idLength = new DataView(authData.buffer, authData.byteOffset + 53, 2).getUint16(0)
+  const idStart = 55
+  const idEnd = idStart + idLength
+  if (idEnd > authData.length || idLength === 0) throw new ValidationError(REFUSED)
+
+  const keyBytes = authData.subarray(idEnd)
+  const key = decodeOrRefuse(() => decodeCbor(keyBytes))
+
+  return {
+    userPresent: (flags & FLAG_USER_PRESENT) !== 0,
+    userVerified: (flags & FLAG_USER_VERIFIED) !== 0,
+    signCount,
+    credential: {
+      credentialId: authData.slice(idStart, idEnd),
+      publicKey: keyBytes.slice(0, key.length),
+    },
+  }
+}
+
+function assertClientData(input: {
+  readonly clientDataJSON: string
+  readonly expectedType: string
+  readonly expectedChallenge: string
+  readonly expectedOrigin: string
+}): void {
+  let data: Record<string, unknown>
+  try {
+    const decoded = new TextDecoder().decode(decodeBase64Url(input.clientDataJSON))
+    const parsed = JSON.parse(decoded) as unknown
+    if (typeof parsed !== 'object' || parsed === null) throw new Error('not an object')
+    data = parsed as Record<string, unknown>
+  } catch (cause) {
+    throw new ValidationError(REFUSED, {}, { cause })
+  }
+
+  if (data.type !== input.expectedType) throw new ValidationError(REFUSED)
+
+  if (typeof data.challenge !== 'string' || data.challenge !== input.expectedChallenge) {
+    throw new ValidationError(msg('error.accounts.sign-in-attempt-expired-started-somewhere'))
+  }
+
+  if (typeof data.origin !== 'string' || data.origin !== input.expectedOrigin) {
+    throw new ValidationError(msg('error.accounts.passkey-used-against-different-address'))
+  }
+}
+
+function decodeOrRefuse<T>(read: () => T): T {
+  try {
+    return read()
+  } catch (cause) {
+    throw new ValidationError(REFUSED, {}, { cause })
+  }
+}
+
+async function decodeOrRefuseAsync<T>(read: () => Promise<T>): Promise<T> {
+  try {
+    return await read()
+  } catch (cause) {
+    throw new ValidationError(REFUSED, {}, { cause })
+  }
+}
+
+async function sha256(bytes: Uint8Array): Promise<Uint8Array> {
+  return new Uint8Array(await crypto.subtle.digest('SHA-256', bytes as unknown as BufferSource))
+}
+
+function concat(left: Uint8Array, right: Uint8Array): Uint8Array {
+  const out = new Uint8Array(left.length + right.length)
+  out.set(left, 0)
+  out.set(right, left.length)
+  return out
+}
+
+function sameBytes(left: Uint8Array, right: Uint8Array): boolean {
+  if (left.length !== right.length) return false
+  let diff = 0
+  for (let index = 0; index < left.length; index += 1) {
+    diff |= left[index]! ^ right[index]!
+  }
+  return diff === 0
+}