ox 1.1.0 → 1.1.2

package/src/wasm/_test/X25519.test.ts

@@ -0,0 +1,194 @@
+import * as fs from 'node:fs'
+import { x25519 } from '@noble/curves/ed25519.js'
+import { describe, expect, test } from 'vp/test'
+import * as X25519 from '../X25519.js'
+import * as crypto25519 from '../internal/crypto25519.js'
+import { wasmBase64 } from '../internal/crypto25519.wasm.js'
+import * as internal from '../internal/instantiate.js'
+import * as x25519_internal from '../internal/x25519.js'
+import { x25519LowOrder } from './fixtures.js'
+
+const alicePrivateKey = fromHex(
+  '77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a',
+)
+const bobPrivateKey = fromHex(
+  '5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb',
+)
+
+describe('engine', () => {
+  test('vectors: matches RFC 7748 key agreement', async () => {
+    const engine = await X25519.engine()
+    const alicePublicKey = engine.getPublicKey(alicePrivateKey)
+    const bobPublicKey = engine.getPublicKey(bobPrivateKey)
+
+    expect(toHex(alicePublicKey)).toMatchInlineSnapshot(
+      `"8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a"`,
+    )
+    expect(toHex(bobPublicKey)).toMatchInlineSnapshot(
+      `"de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f"`,
+    )
+    expect(
+      toHex(engine.getSharedSecret(alicePrivateKey, bobPublicKey)),
+    ).toMatchInlineSnapshot(
+      `"4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742"`,
+    )
+  })
+
+  test('vectors: matches RFC 7748 arbitrary-point cases', async () => {
+    const engine = await X25519.engine()
+    const vectors = [
+      [
+        'a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4',
+        'e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c',
+        'c3da55379de9c6908e94ea4df28d084f32eccf03491c71f754b4075577a28552',
+      ],
+      [
+        '4b66e9d4d1b4673c5ad22691957d6af5c11b6421e0ea01d42ca4169e7918ba0d',
+        'e5210f12786811d3f4b7959d0538ae2c31dbe7106fc03c3efc4cd549c715a493',
+        '95cbde9476e8907d7aade45cb4b873f88b595a68799fa152e6f8f7647aac7957',
+      ],
+    ] as const
+
+    for (const [privateKey, publicKey, expected] of vectors)
+      expect(
+        toHex(engine.getSharedSecret(fromHex(privateKey), fromHex(publicKey))),
+      ).toBe(expected)
+  })
+
+  test('vectors: matches RFC 7748 iterated cases', async () => {
+    const engine = await X25519.engine()
+    let privateKey = Uint8Array.of(9, ...new Uint8Array(31))
+    let publicKey = privateKey
+    const expected = new Map([
+      [1, '422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079'],
+      [
+        1000,
+        '684cf59ba83309552800ef566f2f4d3c1c3887c49360e3875f2eb94d99532c51',
+      ],
+    ])
+
+    for (let iteration = 1; iteration <= 1000; iteration++) {
+      const previousPrivateKey = privateKey
+      privateKey = engine.getSharedSecret(privateKey, publicKey)
+      publicKey = previousPrivateKey
+      if (expected.has(iteration))
+        expect(toHex(privateKey), `iteration ${iteration}`).toBe(
+          expected.get(iteration),
+        )
+    }
+  })
+
+  test('behavior: accepts masked and noncanonical u-coordinates', async () => {
+    const engine = await X25519.engine()
+    const publicKey = x25519.getPublicKey(bobPrivateKey)
+    const masked = publicKey.slice()
+    masked[31]! |= 0x80
+    const noncanonicalBasePoint = fromHex(`f6${'ff'.repeat(30)}7f`)
+
+    expect(engine.getSharedSecret(alicePrivateKey, masked)).toEqual(
+      engine.getSharedSecret(alicePrivateKey, publicKey),
+    )
+    expect(
+      engine.getSharedSecret(alicePrivateKey, noncanonicalBasePoint),
+    ).toEqual(engine.getPublicKey(alicePrivateKey))
+  })
+
+  test('behavior: rejects low-order and malformed public keys', async () => {
+    const engine = await X25519.engine()
+
+    expect(x25519LowOrder).toEqual(
+      JSON.parse(
+        fs.readFileSync(
+          new URL(
+            '../../../test/vectors/x25519/low-order.json',
+            import.meta.url,
+          ),
+          'utf8',
+        ),
+      ),
+    )
+    expect(x25519LowOrder).toHaveLength(7)
+    for (const vector of x25519LowOrder) {
+      const publicKey = fromHex(vector.publicKey)
+      const highBitAlias = publicKey.slice()
+      highBitAlias[31]! |= 0x80
+      for (const value of [publicKey, highBitAlias])
+        expect(() =>
+          engine.getSharedSecret(alicePrivateKey, value),
+        ).toThrowError(`invalid private or public key received`)
+    }
+
+    for (const size of [0, 1, 31, 33, 64]) {
+      expect(() => engine.getPublicKey(new Uint8Array(size))).toThrowError(
+        `X25519 private key must be 32 bytes, got ${size}`,
+      )
+      expect(() =>
+        engine.getSharedSecret(alicePrivateKey, new Uint8Array(size)),
+      ).toThrowError(`X25519 public key must be 32 bytes, got ${size}`)
+    }
+  })
+
+  test('behavior: respects subviews, ownership, and cleanup', async () => {
+    const engine = await X25519.engine()
+    const privateKey = offsetView(alicePrivateKey)
+    const publicKey = offsetView(x25519.getPublicKey(bobPrivateKey))
+    const before = {
+      privateKey: privateKey.slice(),
+      publicKey: publicKey.slice(),
+    }
+    const sharedSecret = engine.getSharedSecret(privateKey, publicKey)
+    const snapshot = sharedSecret.slice()
+
+    engine.getPublicKey(new Uint8Array(32).fill(0xa5))
+    expect(sharedSecret).toEqual(snapshot)
+    expect({ privateKey, publicKey }).toEqual(before)
+
+    const module = await crypto25519.load()
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase, module.heapBase + 96)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+
+  test('behavior: clears both keys and the shared secret after a late trap', async () => {
+    const module = await internal.instantiate<crypto25519.Exports>(wasmBase64)
+    const publicKey = x25519.getPublicKey(bobPrivateKey)
+    const exports: crypto25519.Exports = {
+      ...module.exports,
+      x25519_get_shared_secret(...parameters) {
+        module.exports.x25519_get_shared_secret(...parameters)
+        throw new WebAssembly.RuntimeError('forced late trap')
+      },
+    }
+
+    expect(() =>
+      x25519_internal.getSharedSecret(
+        { ...module, exports },
+        alicePrivateKey,
+        publicKey,
+      ),
+    ).toThrow(WebAssembly.RuntimeError)
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase, module.heapBase + 96)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(value, 'hex'))
+}
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

package/src/wasm/_test/fixtures.ts

@@ -0,0 +1,4 @@
+import { lowOrder } from '../../../test/vectors/x25519/index.js'
+
+/** Complete libsodium X25519 low-order corpus. */
+export const x25519LowOrder = lowOrder

package/src/wasm/index.ts

@@ -1,11 +1,11 @@
 /** @entrypointCategory WASM */
 
 /**
- * WASM implementations of ox's hash primitives, compiled from C.
+ * WASM implementations of Ox's supported cryptographic primitives, compiled
+ * from C.
  *
- * Load it and hand the result to {@link ox#Engine.set}. WASM must be compiled
- * asynchronously, so the `await` lives here -- every call afterwards is
- * synchronous.
+ * Install it during startup. WASM must be compiled asynchronously, so the
+ * `await` lives there. Every cryptographic call afterwards is synchronous.
  *
  * :::note
  * Performance varies by primitive, input size, runtime, and processor. Run
@@ -16,32 +16,105 @@
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Hash } from 'ox'
- * import { Engine } from 'ox/wasm'
+ * import { Engine, Hash } from 'ox/wasm'
  *
- * await Engine.load()
+ * await Engine.install()
  *
- * Hash.keccak256('0xdeadbeef')
+ * Hash.sha256('0xdeadbeef')
  * ```
  *
  * @category Crypto
  */
 export * as Engine from './Engine.js'
 
+/**
+ * WASM implementations of Ox's supported Ed25519 primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Ed25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ Ed25519: Ed25519.engine() })
+ *
+ * Ed25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Ed25519 from './Ed25519.js'
+
 /**
  * WASM implementations of Ox's supported hash primitives.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Engine, Hash } from 'ox'
- * import * as WasmHash from 'ox/wasm/Hash'
+ * import { Engine } from 'ox'
+ * import { Hash } from 'ox/wasm'
  *
- * Engine.set(await WasmHash.create())
+ * await Engine.install({ Hash: Hash.engine() })
  *
- * Hash.keccak256('0xdeadbeef')
+ * Hash.sha256('0xdeadbeef')
  * ```
  *
  * @category Crypto
  */
 export * as Hash from './Hash.js'
+
+/**
+ * WASM implementation of Ox's synchronous PBKDF2-HMAC-SHA256 primitive.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Keystore } from 'ox/wasm'
+ *
+ * await Engine.install({ Keystore: Keystore.engine() })
+ *
+ * Keystore.pbkdf2({ password: 'testpassword' })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Keystore from './Keystore.js'
+
+/**
+ * WASM implementation of Ox's BIP-39 seed derivation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Mnemonic } from 'ox/wasm'
+ *
+ * await Engine.install({ Mnemonic: Mnemonic.engine() })
+ *
+ * Mnemonic.toSeed(
+ *   'test test test test test test test test test test test junk'
+ * )
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Mnemonic from './Mnemonic.js'
+
+/**
+ * WASM implementations of Ox's supported X25519 primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { X25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ X25519: X25519.engine() })
+ *
+ * X25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as X25519 from './X25519.js'

package/src/wasm/internal/blake3.ts

@@ -0,0 +1,45 @@
+import { wasmBase64 } from './blake3.wasm.js'
+import * as internal from './instantiate.js'
+
+const digestSize = 32
+const wasm32Size = 0x1_0000_0000
+
+/** Exports supplied by the dedicated portable BLAKE3 artifact. @internal */
+export type Exports = {
+  blake3_hash(input: number, length: number, out: number): void
+  zero(ptr: number, length: number): void
+}
+
+const instantiate = /*#__PURE__*/ internal.memoize(() =>
+  internal.instantiate<Exports>(wasmBase64),
+)
+
+/** Returns the one memoized BLAKE3 instance shared by its providers. */
+export function load() {
+  return instantiate()
+}
+
+/** Hashes an input through a loaded BLAKE3 module. @internal */
+export function hash(
+  module: internal.Module<Exports>,
+  input: Uint8Array,
+): Uint8Array {
+  const inputPtr = module.heapBase
+  const end = inputPtr + input.length + digestSize
+  if (!Number.isSafeInteger(end) || end > wasm32Size)
+    throw new internal.MemoryError({
+      bytes: end,
+      cause: new RangeError('BLAKE3 workspace exceeds wasm32 memory.'),
+    })
+
+  const outPtr = inputPtr + input.length
+  const size = end - inputPtr
+  module.reserve(size)
+  try {
+    module.view().set(input, inputPtr)
+    module.exports.blake3_hash(inputPtr, input.length, outPtr)
+    return module.view().slice(outPtr, outPtr + digestSize)
+  } finally {
+    module.exports.zero(inputPtr, size)
+  }
+}

package/src/wasm/internal/blake3.wasm.ts

@@ -0,0 +1,11 @@
+// Generated by `pnpm wasm:build --target=blake3`. Do not edit.
+//
+// Compiled from wasm/src/blake3.c, wasm/vendor/blake3/blake3.c, wasm/vendor/blake3/blake3_dispatch.c, wasm/vendor/blake3/blake3_portable.c, wasm/src/ox_rt.c
+// with wasi-sdk 25.0 + binaryen 123.
+//
+// `pnpm wasm:check` rebuilds this file and fails if the bytes differ, so any
+// change to the C or to `wasm/targets.ts` must be followed by `pnpm wasm:build`.
+
+/** Base64-encoded WASM binary. */
+export const wasmBase64 =
+  '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'

package/src/wasm/internal/crypto25519.ts

@@ -0,0 +1,43 @@
+import { wasmBase64 } from './crypto25519.wasm.js'
+import {
+  instantiate,
+  memoize,
+  type Module as WasmModule,
+} from './instantiate.js'
+
+export type Exports = {
+  ed25519_get_public_key(seed: number, publicKey: number): void
+  ed25519_sign(
+    seed: number,
+    message: number,
+    messageSize: number,
+    signature: number,
+  ): void
+  ed25519_to_montgomery_secret(seed: number, secretKey: number): void
+  ed25519_verify(
+    signature: number,
+    message: number,
+    messageSize: number,
+    publicKey: number,
+  ): number
+  mnemonic_to_seed(
+    password: number,
+    passwordSize: number,
+    salt: number,
+    saltSize: number,
+    seed: number,
+  ): void
+  x25519_get_public_key(privateKey: number, publicKey: number): void
+  x25519_get_shared_secret(
+    privateKey: number,
+    publicKey: number,
+    sharedSecret: number,
+  ): number
+  zero(pointer: number, length: number): void
+}
+
+/** Instantiated shared cryptographic module. */
+export type Module = WasmModule<Exports>
+
+/** Instantiates the shared Ed25519, X25519, and mnemonic module once. */
+export const load = memoize(() => instantiate<Exports>(wasmBase64))