ox 1.2.0 → 1.3.0

package/src/wasm/internal/hashState.ts

@@ -0,0 +1,154 @@
+import type * as Engine from '../../core/Engine.js'
+import type { Module } from './instantiate.js'
+import { MemoryError } from './instantiate.js'
+
+/** Exports required by every incremental hash state. @internal */
+export type Exports = {
+  zero(ptr: number, length: number): void
+}
+
+/** Parameters for creating a host-owned incremental hash state. @internal */
+export type Options<exports extends Exports> = {
+  digestSize: number
+  finalize: (exports: exports, state: number, out: number) => void
+  init: (
+    exports: exports,
+    state: number,
+    input: number,
+    inputLength: number,
+  ) => void
+  input?: Uint8Array | undefined
+  stateSize: number
+  update: (
+    exports: exports,
+    state: number,
+    input: number,
+    inputLength: number,
+  ) => void
+}
+
+const alignment = 8
+const wasm32Size = 0x1_0000_0000
+
+function align(value: number) {
+  return Math.ceil(value / alignment) * alignment
+}
+
+function reserve<exports extends Exports>(
+  module: Module<exports>,
+  end: number,
+) {
+  if (!Number.isSafeInteger(end) || end > wasm32Size)
+    throw new MemoryError({
+      bytes: end,
+      cause: new RangeError('Hash workspace exceeds wasm32 memory.'),
+    })
+  module.reserve(end - module.heapBase)
+}
+
+/**
+ * Creates a hash state whose authoritative bytes live in host memory.
+ *
+ * The shared WASM instance only holds a state during one synchronous call.
+ * Every workspace is cleared before control returns to the caller.
+ *
+ * @internal
+ */
+export function create<exports extends Exports>(
+  module: Module<exports>,
+  options: Options<exports>,
+): Engine.HashState {
+  const { digestSize, finalize, init, stateSize, update } = options
+  const initial = options.input ?? new Uint8Array()
+  const inputPtr = module.heapBase
+  const statePtr = align(inputPtr + initial.length)
+  const end = statePtr + stateSize
+  reserve(module, end)
+
+  let state: Uint8Array
+  try {
+    module.exports.zero(module.heapBase, end - module.heapBase)
+    const view = module.view()
+    view.set(initial, inputPtr)
+    init(module.exports, statePtr, inputPtr, initial.length)
+    state = module.view().slice(statePtr, end)
+  } finally {
+    module.exports.zero(module.heapBase, end - module.heapBase)
+  }
+
+  return fromSnapshot(module, state, {
+    digestSize,
+    finalize,
+    stateSize,
+    update,
+  })
+}
+
+type SnapshotOptions<exports extends Exports> = Pick<
+  Options<exports>,
+  'digestSize' | 'finalize' | 'stateSize' | 'update'
+>
+
+function fromSnapshot<exports extends Exports>(
+  module: Module<exports>,
+  state: Uint8Array,
+  options: SnapshotOptions<exports>,
+): Engine.HashState {
+  const { digestSize, finalize, stateSize, update } = options
+  let active = true
+
+  const assertActive = () => {
+    if (!active) throw new Error('Hash state has been destroyed.')
+  }
+
+  const hashState: Engine.HashState = {
+    clone() {
+      assertActive()
+      return fromSnapshot(module, state.slice(), options)
+    },
+    destroy() {
+      if (!active) return
+      active = false
+      state.fill(0)
+    },
+    digestInto(output) {
+      assertActive()
+      if (output.length < digestSize)
+        throw new RangeError(
+          `Digest output requires at least ${digestSize} bytes.`,
+        )
+
+      const statePtr = align(module.heapBase)
+      const outPtr = statePtr + stateSize
+      const end = outPtr + digestSize
+      reserve(module, end)
+      active = false
+      try {
+        module.view().set(state, statePtr)
+        finalize(module.exports, statePtr, outPtr)
+        output.set(module.view().subarray(outPtr, end))
+      } finally {
+        state.fill(0)
+        module.exports.zero(module.heapBase, end - module.heapBase)
+      }
+    },
+    update(input) {
+      assertActive()
+      const inputPtr = module.heapBase
+      const statePtr = align(inputPtr + input.length)
+      const end = statePtr + stateSize
+      reserve(module, end)
+      try {
+        const view = module.view()
+        view.set(input, inputPtr)
+        view.set(state, statePtr)
+        update(module.exports, statePtr, inputPtr, input.length)
+        state.set(module.view().subarray(statePtr, end))
+      } finally {
+        module.exports.zero(module.heapBase, end - module.heapBase)
+      }
+    },
+  }
+
+  return hashState
+}

package/src/wasm/internal/hashes.ts

@@ -1,22 +1,51 @@
 import * as hash from './hash.js'
-import { wasmBase64 } from './hashes.wasm.js'
+import {
+  keccak256StateSize,
+  ripemd160StateSize,
+  sha256StateSize,
+  wasmBase64,
+} from './hashes.wasm.js'
+import * as hashState from './hashState.js'
 import * as internal from './instantiate.js'
 
+type Algorithm = 'keccak256' | 'ripemd160' | 'sha256'
+
+type StateExports = {
+  [key in `${Algorithm}_init`]: (state: number) => void
+} & {
+  [key in `${Algorithm}_update`]: (
+    state: number,
+    input: number,
+    inputLength: number,
+  ) => void
+} & {
+  [key in `${Algorithm}_finalize`]: (state: number, out: number) => void
+}
+
 /** Exports shared by the Hash and Keystore providers. @internal */
-export type Exports = hash.Exports & {
-  keccak256(input: number, length: number, out: number): void
-  pbkdf2_sha256(
-    password: number,
-    passwordLength: number,
-    salt: number,
-    saltLength: number,
-    iterations: number,
-    out: number,
-    outLength: number,
-    scratch: number,
-  ): void
-  ripemd160(input: number, length: number, out: number): void
-  sha256(input: number, length: number, out: number): void
+export type Exports = hash.Exports &
+  hash.StateExports &
+  StateExports & {
+    keccak256(input: number, length: number, out: number): void
+    pbkdf2_sha256(
+      password: number,
+      passwordLength: number,
+      salt: number,
+      saltLength: number,
+      iterations: number,
+      out: number,
+      outLength: number,
+      scratch: number,
+    ): void
+    ripemd160(input: number, length: number, out: number): void
+    sha256(input: number, length: number, out: number): void
+  }
+
+const digestSize = { keccak256: 32, ripemd160: 20, sha256: 32 }
+const stateSize = {
+  keccak256: keccak256StateSize,
+  ripemd160: ripemd160StateSize,
+  sha256: sha256StateSize,
 }
 
 const instantiate = /*#__PURE__*/ internal.memoize(() =>
@@ -27,3 +56,15 @@ const instantiate = /*#__PURE__*/ internal.memoize(() =>
 export function load() {
   return instantiate()
 }
+
+/** Creates an incremental state for one of the shared hash primitives. @internal */
+export function create(module: internal.Module<Exports>, hash: Algorithm) {
+  return hashState.create(module, {
+    digestSize: digestSize[hash],
+    finalize: (exports, state, out) => exports[`${hash}_finalize`](state, out),
+    init: (exports, state) => exports[`${hash}_init`](state),
+    stateSize: stateSize[hash],
+    update: (exports, state, input, inputLength) =>
+      exports[`${hash}_update`](state, input, inputLength),
+  })
+}

package/src/wasm/internal/hashes.wasm.ts

@@ -8,10 +8,22 @@
 
 /** Base64-encoded WASM binary. */
 export const wasmBase64 =
-  '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'
+  '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'
 
 /** Constant shared with the module's C source. */
-export const hmacSha256ScratchSize = 544
+export const hmacSha256ScratchSize = 144
 
 /** Constant shared with the module's C source. */
-export const pbkdf2Sha256ScratchSize = 544
+export const hmacSha256StateSize = 144
+
+/** Constant shared with the module's C source. */
+export const keccak256StateSize = 344
+
+/** Constant shared with the module's C source. */
+export const pbkdf2Sha256ScratchSize = 352
+
+/** Constant shared with the module's C source. */
+export const ripemd160StateSize = 96
+
+/** Constant shared with the module's C source. */
+export const sha256StateSize = 112

package/src/webauthn/Authentication.ts

@@ -175,6 +175,7 @@ export function getOptions(
     challenge,
     extensions,
     rpId = window.location.hostname,
+    timeout,
     userVerification = 'required',
   } = options
   return {
@@ -197,6 +198,7 @@ export function getOptions(
       challenge: Bytes.fromHex(challenge),
       ...(extensions && { extensions }),
       rpId,
+      ...(timeout !== undefined && { timeout }),
       userVerification,
     },
   }
@@ -214,6 +216,8 @@ export declare namespace getOptions {
       | undefined
     /** The relying party identifier to use. */
     rpId?: Types.PublicKeyCredentialRequestOptions['rpId'] | undefined
+    /** Time, in milliseconds, that the caller is willing to wait for the operation. */
+    timeout?: Types.PublicKeyCredentialRequestOptions['timeout'] | undefined
     /** The user verification requirement. */
     userVerification?:
       | Types.PublicKeyCredentialRequestOptions['userVerification']

package/src/webauthn/Registration.ts

@@ -160,6 +160,7 @@ export function getOptions(
       id: window.location.hostname,
       name: window.document.title,
     },
+    timeout,
     user,
   } = options
   const name = (user?.name ?? name_)!
@@ -184,6 +185,7 @@ export function getOptions(
         },
       ],
       rp,
+      ...(timeout !== undefined && { timeout }),
       user: {
         id: user?.id ?? Hash.keccak256(Bytes.fromString(name), { as: 'Bytes' }),
         name,

package/src/webauthn/Types.ts

@@ -38,7 +38,29 @@ export type LargeBlobSupport = {
 
 export type BufferSource = ArrayBufferView | ArrayBuffer
 
-export type PrfExtension = Record<'eval', Record<'first', Uint8Array>>
+/** Inputs or outputs for a WebAuthn PRF evaluation. */
+export type PrfValues<serialized extends boolean = false> = {
+  /** First PRF input or output. */
+  first: serialized extends true ? string : BufferSource
+  /** Optional second PRF input or output. */
+  second?: (serialized extends true ? string : BufferSource) | undefined
+}
+
+/** Inputs for the WebAuthn PRF extension. */
+export type PrfExtension<serialized extends boolean = false> = {
+  /** PRF inputs for the selected credential. */
+  eval?: PrfValues<serialized> | undefined
+  /** PRF inputs keyed by base64url-encoded credential ID. */
+  evalByCredential?: Record<string, PrfValues<serialized>> | undefined
+}
+
+/** Outputs from the WebAuthn PRF extension. */
+export type PrfExtensionOutput = {
+  /** Whether the created credential supports PRF evaluation. */
+  enabled?: boolean | undefined
+  /** PRF evaluation results. */
+  results?: PrfValues | undefined
+}
 
 export interface AuthenticationExtensionsClientInputs<
   serialized extends boolean = false,
@@ -47,10 +69,18 @@ export interface AuthenticationExtensionsClientInputs<
   credProps?: boolean
   hmacCreateSecret?: boolean
   minPinLength?: boolean
-  prf?: serialized extends true ? { eval: { first: string } } : PrfExtension
+  prf?: PrfExtension<serialized> | undefined
   largeBlob?: LargeBlobSupport
 }
 
+/** Outputs from WebAuthn client extension processing. */
+export type AuthenticationExtensionsClientOutputs = ReturnType<
+  globalThis.PublicKeyCredential['getClientExtensionResults']
+> & {
+  /** WebAuthn PRF extension output. */
+  prf?: PrfExtensionOutput | undefined
+}
+
 export interface AuthenticatorSelectionCriteria {
   authenticatorAttachment?: AuthenticatorAttachment
   requireResidentKey?: boolean

package/src/webauthn/_test/Authentication.test.ts

@@ -1,3 +1,4 @@
+import { runInNewContext } from 'node:vm'
 import { afterAll, beforeAll, describe, expect, test, vi } from 'vp/test'
 import * as Bytes from '../../core/Bytes.js'
 import * as Hash from '../../core/Hash.js'
@@ -5,7 +6,7 @@ import * as P256 from '../../core/P256.js'
 import * as PublicKey from '../../core/PublicKey.js'
 import * as Signature from '../../core/Signature.js'
 import * as WebCryptoP256 from '../../core/WebCryptoP256.js'
-import { Authentication } from '../index.js'
+import { Authentication, type Types } from '../index.js'
 
 beforeAll(() => {
   vi.stubGlobal('window', {
@@ -73,6 +74,16 @@ describe('getOptions', () => {
     `)
   })
 
+  test('options: timeout', () => {
+    const options = Authentication.getOptions({
+      challenge:
+        '0xf631058a3ba1116acce12396fad0a125b5041c43f8e15723709f81aa8d5f4ccf',
+      timeout: 30_000,
+    })
+
+    expect(options.publicKey?.timeout).toMatchInlineSnapshot(`30000`)
+  })
+
   test('options: credentialId', () => {
     expect(
       Authentication.getOptions({
@@ -200,6 +211,61 @@ describe('serializeOptions', () => {
     expect(() => JSON.stringify(serialized)).not.toThrow()
   })
 
+  test('with extensions (prf.evalByCredential)', () => {
+    const first = runInNewContext(
+      'Uint8Array.from([4, 5, 6]).buffer',
+    ) as ArrayBuffer
+    const options: Types.CredentialRequestOptions = {
+      publicKey: {
+        challenge: new Uint8Array([1, 2, 3]),
+        extensions: {
+          prf: {
+            evalByCredential: {
+              credential: {
+                first,
+                second: new Uint8Array(),
+              },
+            },
+          },
+        },
+      },
+    }
+    const serialized = Authentication.serializeOptions(options)
+
+    expect(first).not.toBeInstanceOf(ArrayBuffer)
+    expect(serialized.publicKey!.extensions).toMatchInlineSnapshot(`
+      {
+        "prf": {
+          "evalByCredential": {
+            "credential": {
+              "first": "BAUG",
+              "second": "",
+            },
+          },
+        },
+      }
+    `)
+    expect(() => JSON.stringify(serialized)).not.toThrow()
+  })
+
+  test('with extensions (empty prf)', () => {
+    const options: Types.CredentialRequestOptions = {
+      publicKey: {
+        challenge: new Uint8Array([1, 2, 3]),
+        extensions: {
+          prf: {},
+        },
+      },
+    }
+    const serialized = Authentication.serializeOptions(options)
+
+    expect(serialized.publicKey!.extensions).toMatchInlineSnapshot(`
+      {
+        "prf": {},
+      }
+    `)
+  })
+
   test('empty publicKey', () => {
     const serialized = Authentication.serializeOptions({})
     expect(serialized).toEqual({})
@@ -241,6 +307,62 @@ describe('deserializeOptions', () => {
     )
   })
 
+  test('with extensions (prf.evalByCredential)', () => {
+    const options: Types.CredentialRequestOptions = {
+      publicKey: {
+        challenge: new Uint8Array([1, 2, 3]),
+        extensions: {
+          prf: {
+            evalByCredential: {
+              credential: {
+                first: new Uint8Array([4, 5, 6]),
+                second: new Uint8Array(),
+              },
+            },
+          },
+        },
+      },
+    }
+    const serialized = Authentication.serializeOptions(options)
+    const deserialized = Authentication.deserializeOptions(serialized)
+
+    expect(deserialized.publicKey!.extensions).toMatchInlineSnapshot(`
+      {
+        "prf": {
+          "evalByCredential": {
+            "credential": {
+              "first": Uint8Array [
+                4,
+                5,
+                6,
+              ],
+              "second": Uint8Array [],
+            },
+          },
+        },
+      }
+    `)
+  })
+
+  test('with extensions (empty prf)', () => {
+    const options: Types.CredentialRequestOptions = {
+      publicKey: {
+        challenge: new Uint8Array([1, 2, 3]),
+        extensions: {
+          prf: {},
+        },
+      },
+    }
+    const serialized = Authentication.serializeOptions(options)
+    const deserialized = Authentication.deserializeOptions(serialized)
+
+    expect(deserialized.publicKey!.extensions).toMatchInlineSnapshot(`
+      {
+        "prf": {},
+      }
+    `)
+  })
+
   test('empty publicKey', () => {
     const deserialized = Authentication.deserializeOptions({})
     expect(deserialized).toEqual({})

package/src/webauthn/_test/Registration.test.ts

@@ -1,3 +1,4 @@
+import { runInNewContext } from 'node:vm'
 import { afterAll, beforeAll, describe, expect, test, vi } from 'vp/test'
 import * as Base64 from '../../core/Base64.js'
 import * as Bytes from '../../core/Bytes.js'
@@ -329,6 +330,15 @@ describe('getOptions', () => {
     `)
   })
 
+  test('options: timeout', () => {
+    const options = Registration.getOptions({
+      name: 'Foo',
+      timeout: 30_000,
+    })
+
+    expect(options.publicKey?.timeout).toMatchInlineSnapshot(`30000`)
+  })
+
   test('args: excludeCredentialIds', () => {
     expect(
       Registration.getOptions({
@@ -594,6 +604,9 @@ describe('serializeOptions', () => {
   })
 
   test('with extensions (prf)', () => {
+    const first = runInNewContext(
+      'Uint8Array.from([7, 8, 9]).buffer',
+    ) as ArrayBuffer
     const options: Types.CredentialCreationOptions = {
       publicKey: {
         challenge: new Uint8Array([1, 2, 3]),
@@ -607,7 +620,8 @@ describe('serializeOptions', () => {
         extensions: {
           prf: {
             eval: {
-              first: new Uint8Array([7, 8, 9]),
+              first,
+              second: new Uint8Array(),
             },
           },
         },
@@ -615,9 +629,11 @@ describe('serializeOptions', () => {
     }
     const serialized = Registration.serializeOptions(options)
 
-    expect(typeof serialized.publicKey!.extensions!.prf!.eval.first).toBe(
-      'string',
-    )
+    expect(first).not.toBeInstanceOf(ArrayBuffer)
+    expect(
+      serialized.publicKey!.extensions!.prf!.eval!.first,
+    ).toMatchInlineSnapshot(`"BwgJ"`)
+    expect(serialized.publicKey!.extensions!.prf!.eval!.second).toBe('')
     expect(() => JSON.stringify(serialized)).not.toThrow()
   })
 
@@ -674,6 +690,7 @@ describe('deserializeOptions', () => {
           prf: {
             eval: {
               first: new Uint8Array([7, 8, 9]),
+              second: new Uint8Array(),
             },
           },
         },
@@ -682,12 +699,15 @@ describe('deserializeOptions', () => {
     const serialized = Registration.serializeOptions(options)
     const deserialized = Registration.deserializeOptions(serialized)
 
-    expect(deserialized.publicKey!.extensions!.prf!.eval.first).toBeInstanceOf(
+    expect(deserialized.publicKey!.extensions!.prf!.eval!.first).toBeInstanceOf(
       Uint8Array,
     )
-    expect(deserialized.publicKey!.extensions!.prf!.eval.first).toEqual(
+    expect(deserialized.publicKey!.extensions!.prf!.eval!.first).toEqual(
       new Uint8Array([7, 8, 9]),
     )
+    expect(deserialized.publicKey!.extensions!.prf!.eval!.second).toEqual(
+      new Uint8Array(),
+    )
   })
 
   test('empty publicKey', () => {