ox 1.1.0 → 1.2.0

package/src/wasm/internal/mnemonic.ts

@@ -0,0 +1,56 @@
+import type { Module } from './crypto25519.js'
+
+const encoder = new TextEncoder()
+const seedSize = 64
+const wordCounts = [12, 15, 18, 21, 24]
+
+/** Derives a BIP-39 seed and clears encoded and staged secret material. */
+export function toSeed(
+  module: Module,
+  mnemonic: string,
+  passphrase = '',
+): Uint8Array {
+  const password = encoder.encode(normalize(mnemonic))
+  try {
+    const salt = encoder.encode(normalizeSalt(passphrase))
+    try {
+      const size = password.length + salt.length + seedSize
+      module.reserve(size)
+      const passwordPtr = module.heapBase
+      const saltPtr = passwordPtr + password.length
+      const seedPtr = saltPtr + salt.length
+      try {
+        const memory = module.view()
+        memory.set(password, passwordPtr)
+        memory.set(salt, saltPtr)
+        module.exports.mnemonic_to_seed(
+          passwordPtr,
+          password.length,
+          saltPtr,
+          salt.length,
+          seedPtr,
+        )
+        return module.view().slice(seedPtr, seedPtr + seedSize)
+      } finally {
+        module.exports.zero(passwordPtr, size)
+      }
+    } finally {
+      salt.fill(0)
+    }
+  } finally {
+    password.fill(0)
+  }
+}
+
+function normalize(mnemonic: string): string {
+  if (typeof mnemonic !== 'string')
+    throw new TypeError(`invalid mnemonic type: ${typeof mnemonic}`)
+  const normalized = mnemonic.normalize('NFKD')
+  if (!wordCounts.includes(normalized.split(' ').length))
+    throw new Error('Invalid mnemonic')
+  return normalized
+}
+
+function normalizeSalt(passphrase: string): string {
+  return `mnemonic${passphrase}`.normalize('NFKD')
+}

package/src/wasm/internal/pbkdf2.ts

@@ -0,0 +1,86 @@
+import { pbkdf2Sha256ScratchSize } from './hashes.wasm.js'
+import { MemoryError, type Module } from './instantiate.js'
+
+/** WASM exports used by the PBKDF2-HMAC-SHA256 loader. @internal */
+export type Exports = {
+  pbkdf2_sha256(
+    password: number,
+    passwordLength: number,
+    salt: number,
+    saltLength: number,
+    iterations: number,
+    out: number,
+    outLength: number,
+    scratch: number,
+  ): void
+  zero(ptr: number, length: number): void
+}
+
+const maximumUint32 = 0xffff_ffff
+const wasm32Size = 0x1_0000_0000
+
+/** Calls PBKDF2-HMAC-SHA256 and clears its complete linear-memory region. */
+export function pbkdf2Sha256(
+  module: Module<Exports>,
+  password: Uint8Array,
+  salt: Uint8Array,
+  options: { c: number; dkLen: number },
+): Uint8Array {
+  const { c, dkLen } = options
+  assertPositiveUint32(c, 'c')
+  assertPositiveUint32(dkLen, 'dkLen')
+
+  const passwordLength = password.length
+  const saltLength = salt.length
+  if (saltLength > maximumUint32 - 4)
+    throw new RangeError(
+      `"salt" length must be <= ${maximumUint32 - 4}, got ${saltLength}`,
+    )
+
+  const passwordPtr = module.heapBase
+  const saltPtr = passwordPtr + passwordLength
+  const outPtr = saltPtr + saltLength + 4
+  const scratchPtr = align4(outPtr + dkLen)
+  const end = scratchPtr + pbkdf2Sha256ScratchSize
+  if (!Number.isSafeInteger(end) || end > wasm32Size)
+    throw new MemoryError({
+      bytes: end,
+      cause: new RangeError('PBKDF2 workspace exceeds wasm32 memory.'),
+    })
+
+  module.reserve(end - passwordPtr)
+  const view = module.view()
+  try {
+    view.set(password, passwordPtr)
+    view.set(salt, saltPtr)
+    module.exports.pbkdf2_sha256(
+      passwordPtr,
+      passwordLength,
+      saltPtr,
+      saltLength,
+      c,
+      outPtr,
+      dkLen,
+      scratchPtr,
+    )
+    return module.view().slice(outPtr, outPtr + dkLen)
+  } finally {
+    // This includes the password, salt and counter, staged output, alignment
+    // padding, and every byte of PBKDF2/HMAC working state.
+    module.exports.zero(passwordPtr, end - passwordPtr)
+  }
+}
+
+function align4(value: number) {
+  return Math.ceil(value / 4) * 4
+}
+
+function assertPositiveUint32(value: number, name: string) {
+  if (typeof value !== 'number')
+    throw new TypeError(`"${name}" expected number, got ${typeof value}`)
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError(`"${name}" expected integer >= 0, got ${value}`)
+  if (value < 1) throw new Error(`"${name}" must be >= 1`)
+  if (value > maximumUint32)
+    throw new RangeError(`"${name}" must be <= ${maximumUint32}, got ${value}`)
+}

package/src/wasm/internal/scrypt.ts

@@ -0,0 +1,131 @@
+import {
+  scryptMaxMemory,
+  scryptScratchSize,
+  wasmBase64,
+} from './scrypt.wasm.js'
+import * as internal from './instantiate.js'
+
+/** Exports supplied by the standalone scrypt artifact. @internal */
+export type Exports = {
+  scrypt(
+    password: number,
+    passwordLength: number,
+    salt: number,
+    saltLength: number,
+    N: number,
+    r: number,
+    p: number,
+    out: number,
+    outLength: number,
+    B: number,
+    V: number,
+    tmp: number,
+    scratch: number,
+  ): void
+  zero(ptr: number, length: number): void
+}
+
+const maximumWorkspace = 1024 ** 3 + 1024
+const pow32 = 2 ** 32
+const active = new WeakSet<internal.Module<Exports>>()
+
+const instantiate = /*#__PURE__*/ internal.memoize(() =>
+  internal.instantiate<Exports>(wasmBase64),
+)
+
+/** Returns the one memoized scrypt instance shared by its providers. */
+export function load() {
+  return instantiate()
+}
+
+/** Derives a key through a loaded scrypt module. @internal */
+export function derive(
+  module: internal.Module<Exports>,
+  password: Uint8Array,
+  salt: Uint8Array,
+  options: { N: number; dkLen: number; p: number; r: number },
+): Uint8Array {
+  const { N, dkLen, p, r } = options
+  assertNumber(N, 'N')
+  assertNumber(r, 'r')
+  assertNumber(p, 'p')
+  assertNumber(dkLen, 'dkLen')
+
+  const blockSize = 128 * r
+  if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32)
+    throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32')
+  if (p < 1 || p > ((pow32 - 1) * 32) / blockSize)
+    throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)')
+  if (dkLen < 1 || dkLen > (pow32 - 1) * 32)
+    throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32')
+
+  const workspace = blockSize * (N + p + 1)
+  if (workspace > maximumWorkspace)
+    throw new Error(
+      `"maxmem" limit was hit: memUsed(128*r*(N+p+1))=${workspace}, maxmem=${maximumWorkspace}`,
+    )
+  if (blockSize === 0) throw new Error('"dkLen" must be >= 1')
+
+  const passwordPtr = module.heapBase
+  const saltPtr = passwordPtr + password.length
+  const outPtr = saltPtr + salt.length + 4
+  const bPtr = align4(outPtr + dkLen)
+  const bLength = blockSize * p
+  const vPtr = align4(bPtr + bLength + 4)
+  const vLength = blockSize * N
+  const tmpPtr = vPtr + vLength
+  const scratchPtr = align4(tmpPtr + blockSize)
+  const end = scratchPtr + scryptScratchSize
+  if (!Number.isSafeInteger(end) || end > scryptMaxMemory)
+    throw new internal.MemoryError({
+      bytes: end,
+      cause: new RangeError('Scrypt workspace exceeds the WASM memory limit.'),
+    })
+
+  if (active.has(module))
+    throw new Error('The scrypt WASM instance is already deriving a key.')
+  active.add(module)
+
+  const size = end - passwordPtr
+  let reserved = false
+  try {
+    module.reserve(size)
+    reserved = true
+    const view = module.view()
+    view.set(password, passwordPtr)
+    view.set(salt, saltPtr)
+    module.exports.scrypt(
+      passwordPtr,
+      password.length,
+      saltPtr,
+      salt.length,
+      N,
+      r,
+      p,
+      outPtr,
+      dkLen,
+      bPtr,
+      vPtr,
+      tmpPtr,
+      scratchPtr,
+    )
+    return module.view().slice(outPtr, outPtr + dkLen)
+  } finally {
+    try {
+      if (reserved) module.exports.zero(passwordPtr, size)
+    } finally {
+      active.delete(module)
+    }
+  }
+}
+
+function align4(value: number) {
+  return Math.ceil(value / 4) * 4
+}
+
+function assertNumber(value: number, name: string) {
+  if (typeof value !== 'number')
+    throw new TypeError(`"${name}" expected number, got ${typeof value}`)
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError(`"${name}" expected integer >= 0, got ${value}`)
+}

package/src/wasm/internal/scrypt.wasm.ts

@@ -0,0 +1,17 @@
+// Generated by `pnpm wasm:build --target=scrypt`. Do not edit.
+//
+// Compiled from wasm/src/scrypt.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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'
+
+/** Constant shared with the module's C source. */
+export const scryptMaxMemory = 1074790400
+
+/** Constant shared with the module's C source. */
+export const scryptScratchSize = 672

package/src/wasm/internal/secp256k1.ts

@@ -0,0 +1,62 @@
+import { wasmBase64 } from './secp256k1.wasm.js'
+import {
+  instantiate,
+  memoize,
+  type Module as WasmModule,
+} from './instantiate.js'
+
+export type Exports = {
+  secp256k1_get_public_key(privateKey: number, publicKey: number): number
+  secp256k1_get_shared_secret(
+    privateKey: number,
+    publicKey: number,
+    publicKeySize: number,
+    sharedSecret: number,
+  ): number
+  secp256k1_init(): number
+  secp256k1_randomize(seed: number): number
+  secp256k1_recover_public_key(
+    signature: number,
+    message: number,
+    messageSize: number,
+    publicKey: number,
+  ): number
+  secp256k1_sign(
+    message: number,
+    messageSize: number,
+    privateKey: number,
+    entropy: number,
+    entropySize: number,
+    prehash: number,
+    signature: number,
+  ): number
+  secp256k1_verify(
+    signature: number,
+    message: number,
+    messageSize: number,
+    publicKey: number,
+    publicKeySize: number,
+    prehash: number,
+  ): number
+  zero(pointer: number, length: number): void
+}
+
+/** Instantiated secp256k1 module. */
+export type Module = WasmModule<Exports>
+
+/** Instantiates and initializes the secp256k1 module once. */
+export const load = memoize(async () => {
+  const module = await instantiate<Exports>(wasmBase64)
+  if (module.exports.secp256k1_init() !== 1)
+    throw new Error('WASM secp256k1 context could not be initialized.')
+  const seed = crypto.getRandomValues(new Uint8Array(32))
+  module.reserve(seed.length)
+  try {
+    module.view().set(seed, module.heapBase)
+    if (module.exports.secp256k1_randomize(module.heapBase) !== 1)
+      throw new Error('WASM secp256k1 context could not be randomized.')
+  } finally {
+    module.exports.zero(module.heapBase, seed.length)
+  }
+  return module
+})