@meith/accounts 0.16.0

package/src/webauthn/authenticator.fixture.ts

@@ -0,0 +1,268 @@
+import { decodeBase64Url, encodeBase64Url } from '../crypto/base64url'
+
+export type FixtureAlgorithm = 'ES256' | 'RS256' | 'EdDSA'
+
+export function encodeCbor(value: unknown): Uint8Array {
+  if (typeof value === 'number') {
+    return value < 0 ? head(1, -1 - value) : head(0, value)
+  }
+  if (value instanceof Uint8Array) {
+    return concat(head(2, value.length), value)
+  }
+  if (typeof value === 'string') {
+    const bytes = new TextEncoder().encode(value)
+    return concat(head(3, bytes.length), bytes)
+  }
+  if (Array.isArray(value)) {
+    return concat(head(4, value.length), ...value.map(encodeCbor))
+  }
+  if (value instanceof Map) {
+    const parts: Uint8Array[] = [head(5, value.size)]
+    for (const [key, entry] of value) {
+      parts.push(encodeCbor(key), encodeCbor(entry))
+    }
+    return concat(...parts)
+  }
+  throw new Error('the fixture encoder does not know that shape')
+}
+
+function head(major: number, argument: number): Uint8Array {
+  if (argument < 24) return Uint8Array.from([(major << 5) | argument])
+  if (argument < 0x100) return Uint8Array.from([(major << 5) | 24, argument])
+  if (argument < 0x10000) {
+    return Uint8Array.from([(major << 5) | 25, argument >> 8, argument & 0xff])
+  }
+  return Uint8Array.from([
+    (major << 5) | 26,
+    (argument >>> 24) & 0xff,
+    (argument >>> 16) & 0xff,
+    (argument >>> 8) & 0xff,
+    argument & 0xff,
+  ])
+}
+
+export function concat(...parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
+  const out = new Uint8Array(parts.reduce((total, part) => total + part.length, 0))
+  let offset = 0
+  for (const part of parts) {
+    out.set(part, offset)
+    offset += part.length
+  }
+  return out
+}
+
+export interface FixtureResponse {
+  readonly clientDataJSON: string
+  readonly attestationObject: string
+}
+
+export interface FixtureAssertion {
+  readonly clientDataJSON: string
+  readonly authenticatorData: string
+  readonly signature: string
+}
+
+export interface FixtureAuthenticator {
+  readonly credentialId: string
+  readonly publicKey: string
+  register(input: {
+    readonly challenge: string
+    readonly origin: string
+    readonly type?: string
+    readonly rpId?: string
+    readonly flags?: number
+  }): Promise<FixtureResponse>
+  assert(input: {
+    readonly challenge: string
+    readonly origin: string
+    readonly type?: string
+    readonly rpId?: string
+    readonly signCount?: number
+    readonly flags?: number
+    readonly tamper?: boolean
+  }): Promise<FixtureAssertion>
+}
+
+export async function createAuthenticator(input: {
+  readonly rpId: string
+  readonly algorithm?: FixtureAlgorithm
+  readonly credentialId?: Uint8Array
+}): Promise<FixtureAuthenticator> {
+  const algorithm = input.algorithm ?? 'ES256'
+  const credentialId = input.credentialId ?? Uint8Array.from({ length: 16 }, (_, i) => i + 1)
+
+  const pair = (await crypto.subtle.generateKey(generateParams(algorithm), true, [
+    'sign',
+    'verify',
+  ])) as CryptoKeyPair
+
+  const jwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
+
+  const coseKey = encodeCbor(coseEntries(algorithm, jwk))
+
+  const clientData = (type: string, challenge: string, origin: string): string =>
+    encodeBase64Url(
+      new TextEncoder().encode(JSON.stringify({ type, challenge, origin, crossOrigin: false })),
+    )
+
+  const authenticatorData = async (
+    rpId: string,
+    flags: number,
+    signCount: number,
+    attested: Uint8Array | null,
+  ): Promise<Uint8Array> => {
+    const rpIdHash = new Uint8Array(
+      await crypto.subtle.digest('SHA-256', new TextEncoder().encode(rpId)),
+    )
+
+    const counter = new Uint8Array(4)
+    new DataView(counter.buffer).setUint32(0, signCount)
+
+    if (attested === null) {
+      return concat(rpIdHash, Uint8Array.from([flags]), counter)
+    }
+
+    const idLength = new Uint8Array(2)
+    new DataView(idLength.buffer).setUint16(0, credentialId.length)
+
+    return concat(
+      rpIdHash,
+      Uint8Array.from([flags]),
+      counter,
+      new Uint8Array(16),
+      idLength,
+      credentialId,
+      attested,
+    )
+  }
+
+  return {
+    credentialId: encodeBase64Url(credentialId),
+    publicKey: encodeBase64Url(coseKey),
+
+    async register(request): Promise<FixtureResponse> {
+      const authData = await authenticatorData(
+        request.rpId ?? input.rpId,
+        request.flags ?? 0b0100_0101,
+        0,
+        coseKey,
+      )
+
+      return {
+        clientDataJSON: clientData(
+          request.type ?? 'webauthn.create',
+          request.challenge,
+          request.origin,
+        ),
+        attestationObject: encodeBase64Url(
+          encodeCbor(
+            new Map<string, unknown>([
+              ['fmt', 'none'],
+              ['attStmt', new Map()],
+              ['authData', authData],
+            ]),
+          ),
+        ),
+      }
+    },
+
+    async assert(request): Promise<FixtureAssertion> {
+      const authData = await authenticatorData(
+        request.rpId ?? input.rpId,
+        request.flags ?? 0b0000_0101,
+        request.signCount ?? 1,
+        null,
+      )
+
+      const json = clientData(request.type ?? 'webauthn.get', request.challenge, request.origin)
+
+      const clientDataHash = new Uint8Array(
+        await crypto.subtle.digest('SHA-256', decodeBase64Url(json)),
+      )
+
+      const raw = new Uint8Array(
+        await crypto.subtle.sign(
+          signParams(algorithm),
+          pair.privateKey,
+          concat(authData, clientDataHash),
+        ),
+      )
+
+      const signature = algorithm === 'ES256' ? derFromRaw(raw) : raw
+      if (request.tamper === true) {
+        signature[signature.length - 1] = (signature[signature.length - 1] ?? 0) ^ 0xff
+      }
+
+      return {
+        clientDataJSON: json,
+        authenticatorData: encodeBase64Url(authData),
+        signature: encodeBase64Url(signature),
+      }
+    },
+  }
+}
+
+function generateParams(
+  algorithm: FixtureAlgorithm,
+): EcKeyGenParams | RsaHashedKeyGenParams | Algorithm {
+  if (algorithm === 'ES256') return { name: 'ECDSA', namedCurve: 'P-256' }
+  if (algorithm === 'EdDSA') return { name: 'Ed25519' }
+  return {
+    name: 'RSASSA-PKCS1-v1_5',
+    modulusLength: 2048,
+    publicExponent: new Uint8Array([1, 0, 1]),
+    hash: 'SHA-256',
+  }
+}
+
+function signParams(algorithm: FixtureAlgorithm): EcdsaParams | Algorithm {
+  if (algorithm === 'ES256') return { name: 'ECDSA', hash: 'SHA-256' }
+  if (algorithm === 'EdDSA') return { name: 'Ed25519' }
+  return { name: 'RSASSA-PKCS1-v1_5' }
+}
+
+function coseEntries(algorithm: FixtureAlgorithm, jwk: JsonWebKey): Map<number, unknown> {
+  if (algorithm === 'ES256') {
+    return new Map<number, unknown>([
+      [1, 2],
+      [3, -7],
+      [-1, 1],
+      [-2, decodeBase64Url(jwk.x!)],
+      [-3, decodeBase64Url(jwk.y!)],
+    ])
+  }
+
+  if (algorithm === 'EdDSA') {
+    return new Map<number, unknown>([
+      [1, 1],
+      [3, -8],
+      [-1, 6],
+      [-2, decodeBase64Url(jwk.x!)],
+    ])
+  }
+
+  return new Map<number, unknown>([
+    [1, 3],
+    [3, -257],
+    [-1, decodeBase64Url(jwk.n!)],
+    [-2, decodeBase64Url(jwk.e!)],
+  ])
+}
+
+export function derFromRaw(raw: Uint8Array): Uint8Array {
+  const half = raw.length / 2
+  const r = trim(raw.slice(0, half))
+  const s = trim(raw.slice(half))
+
+  const body = concat(Uint8Array.from([0x02, r.length]), r, Uint8Array.from([0x02, s.length]), s)
+
+  return concat(Uint8Array.from([0x30, body.length]), body)
+}
+
+function trim(value: Uint8Array): Uint8Array {
+  let start = 0
+  while (start < value.length - 1 && value[start] === 0) start += 1
+
+  const trimmed = value.slice(start)
+  return trimmed[0]! > 0x7f ? concat(Uint8Array.from([0]), trimmed) : trimmed
+}

package/src/webauthn/cbor.ts

@@ -0,0 +1,110 @@
+export type CborValue =
+  | number
+  | bigint
+  | string
+  | boolean
+  | null
+  | Uint8Array
+  | readonly CborValue[]
+  | ReadonlyMap<CborValue, CborValue>
+
+export interface CborRead {
+  readonly value: CborValue
+  readonly length: number
+}
+
+export function decodeCbor(bytes: Uint8Array, offset = 0): CborRead {
+  const start = offset
+  const initial = byteAt(bytes, offset)
+  offset += 1
+
+  const major = initial >> 5
+  const minor = initial & 0b11111
+
+  if (major === 7) {
+    if (minor === 20) return { value: false, length: offset - start }
+    if (minor === 21) return { value: true, length: offset - start }
+    if (minor === 22) return { value: null, length: offset - start }
+    if (minor === 23) return { value: null, length: offset - start }
+    throw new Error(`unsupported CBOR simple value ${minor}`)
+  }
+
+  const head = readArgument(bytes, offset, minor)
+  offset = head.offset
+  const argument = head.value
+
+  if (major === 0) return { value: argument, length: offset - start }
+  if (major === 1) return { value: -1 - argument, length: offset - start }
+
+  if (major === 2) {
+    const end = offset + argument
+    if (end > bytes.length) throw new Error('truncated CBOR byte string')
+    return { value: bytes.slice(offset, end), length: end - start }
+  }
+
+  if (major === 3) {
+    const end = offset + argument
+    if (end > bytes.length) throw new Error('truncated CBOR text string')
+    return {
+      value: new TextDecoder().decode(bytes.subarray(offset, end)),
+      length: end - start,
+    }
+  }
+
+  if (major === 4) {
+    const items: CborValue[] = []
+    for (let index = 0; index < argument; index += 1) {
+      const item = decodeCbor(bytes, offset)
+      items.push(item.value)
+      offset += item.length
+    }
+    return { value: items, length: offset - start }
+  }
+
+  if (major === 5) {
+    const entries = new Map<CborValue, CborValue>()
+    for (let index = 0; index < argument; index += 1) {
+      const key = decodeCbor(bytes, offset)
+      offset += key.length
+      const value = decodeCbor(bytes, offset)
+      offset += value.length
+      entries.set(key.value, value.value)
+    }
+    return { value: entries, length: offset - start }
+  }
+
+  throw new Error(`unsupported CBOR major type ${major}`)
+}
+
+function readArgument(
+  bytes: Uint8Array,
+  offset: number,
+  minor: number,
+): { value: number; offset: number } {
+  if (minor < 24) return { value: minor, offset }
+  if (minor === 24) return { value: byteAt(bytes, offset), offset: offset + 1 }
+  if (minor === 25) {
+    return { value: (byteAt(bytes, offset) << 8) | byteAt(bytes, offset + 1), offset: offset + 2 }
+  }
+  if (minor === 26) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, 4)
+    return { value: view.getUint32(0), offset: offset + 4 }
+  }
+  throw new Error(`unsupported CBOR argument width ${minor}`)
+}
+
+function byteAt(bytes: Uint8Array, offset: number): number {
+  const value = bytes[offset]
+  if (value === undefined) throw new Error('truncated CBOR value')
+  return value
+}
+
+export function cborMap(value: CborValue): ReadonlyMap<CborValue, CborValue> {
+  if (!(value instanceof Map)) throw new Error('expected a CBOR map')
+  return value
+}
+
+export function cborBytes(value: CborValue | undefined): Uint8Array {
+  if (!(value instanceof Uint8Array)) throw new Error('expected a CBOR byte string')
+  return value
+}

package/src/webauthn/cose.ts

@@ -0,0 +1,130 @@
+import { encodeBase64Url } from '../crypto/base64url'
+import { type CborValue, cborMap, decodeCbor } from './cbor'
+
+export type CoseAlgorithm = -7 | -8 | -257
+
+export const SUPPORTED_ALGORITHMS: readonly CoseAlgorithm[] = [-7, -257, -8]
+
+const KTY = 1
+const ALG = 3
+const CRV = -1
+const X = -2
+const Y = -3
+const RSA_MODULUS = -1
+const RSA_EXPONENT = -2
+
+interface ImportedKey {
+  readonly jwk: JsonWebKey
+  readonly importParams: RsaHashedImportParams | EcKeyImportParams | AlgorithmIdentifier
+  readonly verifyParams: AlgorithmIdentifier | EcdsaParams
+  readonly derSignature: boolean
+}
+
+export function algorithmOf(publicKey: Uint8Array): CoseAlgorithm {
+  const key = cborMap(decodeCbor(publicKey).value)
+  const alg = key.get(ALG)
+  if (alg === -7 || alg === -8 || alg === -257) return alg
+  throw new Error('unsupported COSE algorithm')
+}
+
+export async function importCoseKey(publicKey: Uint8Array): Promise<{
+  readonly key: CryptoKey
+  readonly verifyParams: AlgorithmIdentifier | EcdsaParams
+  readonly derSignature: boolean
+}> {
+  const described = describe(cborMap(decodeCbor(publicKey).value))
+
+  const key = await crypto.subtle.importKey('jwk', described.jwk, described.importParams, false, [
+    'verify',
+  ])
+
+  return {
+    key,
+    verifyParams: described.verifyParams,
+    derSignature: described.derSignature,
+  }
+}
+
+function describe(key: ReadonlyMap<CborValue, CborValue>): ImportedKey {
+  const kty = key.get(KTY)
+  const alg = key.get(ALG)
+
+  if (kty === 2 && alg === -7) {
+    if (key.get(CRV) !== 1) throw new Error('unsupported elliptic curve')
+    return {
+      jwk: {
+        kty: 'EC',
+        crv: 'P-256',
+        x: coordinate(key.get(X)),
+        y: coordinate(key.get(Y)),
+      },
+      importParams: { name: 'ECDSA', namedCurve: 'P-256' },
+      verifyParams: { name: 'ECDSA', hash: 'SHA-256' },
+      derSignature: true,
+    }
+  }
+
+  if (kty === 3 && alg === -257) {
+    return {
+      jwk: {
+        kty: 'RSA',
+        n: coordinate(key.get(RSA_MODULUS)),
+        e: coordinate(key.get(RSA_EXPONENT)),
+        alg: 'RS256',
+      },
+      importParams: { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
+      verifyParams: { name: 'RSASSA-PKCS1-v1_5' },
+      derSignature: false,
+    }
+  }
+
+  if (kty === 1 && alg === -8) {
+    if (key.get(CRV) !== 6) throw new Error('unsupported edwards curve')
+    return {
+      jwk: { kty: 'OKP', crv: 'Ed25519', x: coordinate(key.get(X)) } as JsonWebKey,
+      importParams: { name: 'Ed25519' },
+      verifyParams: { name: 'Ed25519' },
+      derSignature: false,
+    }
+  }
+
+  throw new Error('unsupported COSE key type')
+}
+
+function coordinate(value: CborValue | undefined): string {
+  if (!(value instanceof Uint8Array)) throw new Error('malformed COSE key')
+  return encodeBase64Url(value)
+}
+
+export function rawSignatureFromDer(signature: Uint8Array, coordinateBytes = 32): Uint8Array {
+  if (signature[0] !== 0x30) throw new Error('malformed ECDSA signature')
+
+  let offset = 2
+  if (signature[1] !== undefined && signature[1] > 0x80) offset += signature[1] - 0x80
+
+  const readInteger = (): Uint8Array => {
+    if (signature[offset] !== 0x02) throw new Error('malformed ECDSA signature')
+    const length = signature[offset + 1]
+    if (length === undefined) throw new Error('malformed ECDSA signature')
+    const start = offset + 2
+    offset = start + length
+    return signature.slice(start, offset)
+  }
+
+  const r = readInteger()
+  const s = readInteger()
+
+  const out = new Uint8Array(coordinateBytes * 2)
+  out.set(pad(r, coordinateBytes), 0)
+  out.set(pad(s, coordinateBytes), coordinateBytes)
+  return out
+}
+
+function pad(value: Uint8Array, size: number): Uint8Array {
+  const trimmed = value[0] === 0 ? value.slice(1) : value
+  if (trimmed.length > size) throw new Error('malformed ECDSA signature')
+
+  const out = new Uint8Array(size)
+  out.set(trimmed, size - trimmed.length)
+  return out
+}