one 2.6.20 → 2.6.22

package/src/platform/crypto/aes.ts

@@ -0,0 +1,345 @@
+import { base64ToBytes, bytesToBase64, bytesToHex, concatBytes, exactBytes, hexToBytes } from './bytes'
+import type {
+  AESDecryptOptions,
+  AESEncryptOptions,
+  AESKeySize,
+  AESSealedDataConfig,
+  BinaryInput,
+} from './types'
+
+export type { AESDecryptOptions, AESEncryptOptions, AESKeySize, AESSealedDataConfig, BinaryInput }
+
+// expo-crypto's AES-GCM api over an injected engine: native is the shared
+// C++ hybrid object, web is SubtleCrypto. seal returns ciphertext with the
+// tag appended; open takes that form. everything else (key and sealed-data
+// handling, encodings, validation) is shared here so both entries behave
+// identically and the logic unit-tests in node.
+export interface AesEngine {
+  seal(
+    key: Uint8Array<ArrayBuffer>,
+    iv: Uint8Array<ArrayBuffer>,
+    plaintext: Uint8Array<ArrayBuffer>,
+    additionalData: Uint8Array<ArrayBuffer> | undefined,
+    tagLength: number
+  ): Promise<Uint8Array<ArrayBuffer>>
+  open(
+    key: Uint8Array<ArrayBuffer>,
+    iv: Uint8Array<ArrayBuffer>,
+    ciphertextWithTag: Uint8Array<ArrayBuffer>,
+    additionalData: Uint8Array<ArrayBuffer> | undefined,
+    tagLength: number
+  ): Promise<Uint8Array<ArrayBuffer>>
+  random(bytes: Uint8Array<ArrayBuffer>): void
+}
+
+const KEY_SIZES: readonly AESKeySize[] = [128, 192, 256]
+const TAG_LENGTHS: readonly number[] = [16, 15, 14, 13, 12, 8, 4]
+const DEFAULT_IV_LENGTH = 12
+const DEFAULT_TAG_LENGTH = 16
+
+export function assertTagLength(tagLength: number, verb: string): void {
+  if (!TAG_LENGTHS.includes(tagLength)) {
+    throw new Error(`${verb}: tagLength must be one of: ${TAG_LENGTHS.join(', ')}`)
+  }
+}
+
+export function toBytes(input: BinaryInput, verb: string): Uint8Array<ArrayBuffer> {
+  if (typeof input === 'string') return base64ToBytes(input, verb)
+  if (input instanceof ArrayBuffer) return new Uint8Array(input.slice(0))
+  if (ArrayBuffer.isView(input) && input.buffer instanceof ArrayBuffer) {
+    return exactBytes(new Uint8Array(input.buffer, input.byteOffset, input.byteLength))
+  }
+  throw new TypeError(`${verb}: expected a base64 string, Uint8Array, or ArrayBuffer`)
+}
+
+type SealedParts = {
+  iv: Uint8Array<ArrayBuffer>
+  ciphertext: Uint8Array<ArrayBuffer>
+  tag: Uint8Array<ArrayBuffer>
+}
+
+const sealedParts = new WeakMap<object, SealedParts>()
+const keyBytes = new WeakMap<object, Uint8Array<ArrayBuffer>>()
+
+function encodeParts(bytes: Uint8Array, encoding: 'base64' | 'bytes' | undefined) {
+  return encoding === 'base64' ? bytesToBase64(bytes) : exactBytes(bytes)
+}
+
+export function createAesApi(engine: AesEngine) {
+  class AESEncryptionKey {
+    readonly size: AESKeySize
+
+    // construct through generate or import; direct construction still
+    // validates, so a key object can never hold a non-AES length.
+    constructor(bytes: Uint8Array<ArrayBuffer>) {
+      if (!KEY_SIZES.includes((bytes.length * 8) as AESKeySize)) {
+        throw new Error(
+          `Crypto.AESEncryptionKey: key must be 128, 192, or 256 bits, got ${bytes.length * 8}`
+        )
+      }
+      this.size = (bytes.length * 8) as AESKeySize
+      keyBytes.set(this, exactBytes(bytes))
+    }
+
+    static async generate(size: AESKeySize = 256): Promise<AESEncryptionKey> {
+      if (!KEY_SIZES.includes(size)) {
+        throw new Error(`Crypto.AESEncryptionKey.generate: size must be one of: ${KEY_SIZES.join(', ')}`)
+      }
+      const bytes = new Uint8Array(size / 8)
+      engine.random(bytes)
+      return new AESEncryptionKey(bytes)
+    }
+
+    static async import(bytes: Uint8Array): Promise<AESEncryptionKey>
+    static async import(encoded: string, encoding: 'hex' | 'base64'): Promise<AESEncryptionKey>
+    static async import(
+      input: Uint8Array | string,
+      encoding?: 'hex' | 'base64'
+    ): Promise<AESEncryptionKey> {
+      const verb = 'Crypto.AESEncryptionKey.import'
+      let bytes: Uint8Array<ArrayBuffer>
+      if (typeof input === 'string') {
+        if (encoding === 'hex') bytes = hexToBytes(input, verb)
+        else if (encoding === 'base64') bytes = base64ToBytes(input, verb)
+        else throw new Error(`${verb}: encoding must be 'hex' or 'base64'`)
+      } else if (input instanceof Uint8Array) {
+        bytes = exactBytes(input)
+      } else {
+        throw new TypeError(`${verb}: expected bytes or an encoded string`)
+      }
+      if (!KEY_SIZES.includes((bytes.length * 8) as AESKeySize)) {
+        throw new Error(`${verb}: key must be 128, 192, or 256 bits, got ${bytes.length * 8}`)
+      }
+      return new AESEncryptionKey(bytes)
+    }
+
+    async bytes(): Promise<Uint8Array<ArrayBuffer>> {
+      return exactBytes(keyBytes.get(this)!)
+    }
+
+    async encoded(encoding: 'hex' | 'base64'): Promise<string> {
+      const bytes = keyBytes.get(this)!
+      if (encoding === 'hex') return bytesToHex(bytes)
+      if (encoding === 'base64') return bytesToBase64(bytes)
+      throw new Error(`Crypto.AESEncryptionKey.encoded: encoding must be 'hex' or 'base64'`)
+    }
+  }
+
+  class AESSealedData {
+    // construct through fromCombined or fromParts. direct construction still
+    // validates, so sealed data can never carry an empty iv or a tag gcm
+    // does not allow.
+    constructor(parts: SealedParts) {
+      if (parts.iv.length === 0) throw new Error('Crypto.AESSealedData: iv must not be empty')
+      assertTagLength(parts.tag.length, 'Crypto.AESSealedData')
+      sealedParts.set(this, parts)
+    }
+
+    static fromCombined(combined: BinaryInput, config: AESSealedDataConfig = {}): AESSealedData {
+      const verb = 'Crypto.AESSealedData.fromCombined'
+      const ivLength = config.ivLength ?? DEFAULT_IV_LENGTH
+      const tagLength = config.tagLength ?? DEFAULT_TAG_LENGTH
+      assertTagLength(tagLength, verb)
+      if (!Number.isInteger(ivLength) || ivLength <= 0) {
+        throw new Error(`${verb}: ivLength must be a positive integer`)
+      }
+      const bytes = toBytes(combined, verb)
+      if (bytes.length < ivLength + tagLength) {
+        throw new Error(`${verb}: combined data is shorter than its iv and tag`)
+      }
+      return new AESSealedData({
+        iv: exactBytes(bytes.subarray(0, ivLength)),
+        ciphertext: exactBytes(bytes.subarray(ivLength, bytes.length - tagLength)),
+        tag: exactBytes(bytes.subarray(bytes.length - tagLength)),
+      })
+    }
+
+    static fromParts(iv: BinaryInput, ciphertext: BinaryInput, tag: BinaryInput): AESSealedData
+    static fromParts(
+      iv: BinaryInput,
+      ciphertextWithTag: BinaryInput,
+      tagLength?: number
+    ): AESSealedData
+    static fromParts(
+      ivInput: BinaryInput,
+      ciphertextInput: BinaryInput,
+      tagOrLength?: BinaryInput | number
+    ): AESSealedData {
+      const verb = 'Crypto.AESSealedData.fromParts'
+      const iv = toBytes(ivInput, verb)
+      const ciphertext = toBytes(ciphertextInput, verb)
+      if (tagOrLength === undefined || typeof tagOrLength === 'number') {
+        const tagLength = tagOrLength ?? DEFAULT_TAG_LENGTH
+        assertTagLength(tagLength, verb)
+        if (ciphertext.length < tagLength) {
+          throw new Error(`${verb}: ciphertext is shorter than its tag`)
+        }
+        return new AESSealedData({
+          iv,
+          ciphertext: exactBytes(ciphertext.subarray(0, ciphertext.length - tagLength)),
+          tag: exactBytes(ciphertext.subarray(ciphertext.length - tagLength)),
+        })
+      }
+      const tag = toBytes(tagOrLength, verb)
+      assertTagLength(tag.length, verb)
+      return new AESSealedData({ iv, ciphertext, tag })
+    }
+
+    // internal: aesEncrypt builds sealed data from engine output without
+    // going through the public parsers (which would just re-split it).
+    static fromSeal(iv: Uint8Array<ArrayBuffer>, ciphertextWithTag: Uint8Array, tagLength: number) {
+      return new AESSealedData({
+        iv,
+        ciphertext: exactBytes(ciphertextWithTag.subarray(0, ciphertextWithTag.length - tagLength)),
+        tag: exactBytes(ciphertextWithTag.subarray(ciphertextWithTag.length - tagLength)),
+      })
+    }
+
+    get ivSize(): number {
+      return sealedParts.get(this)!.iv.length
+    }
+
+    get tagSize(): number {
+      return sealedParts.get(this)!.tag.length
+    }
+
+    get combinedSize(): number {
+      const parts = sealedParts.get(this)!
+      return parts.iv.length + parts.ciphertext.length + parts.tag.length
+    }
+
+    async iv(encoding: 'base64'): Promise<string>
+    async iv(encoding?: 'bytes'): Promise<Uint8Array<ArrayBuffer>>
+    async iv(encoding?: 'base64' | 'bytes') {
+      return encodeParts(sealedParts.get(this)!.iv, encoding)
+    }
+
+    async tag(encoding: 'base64'): Promise<string>
+    async tag(encoding?: 'bytes'): Promise<Uint8Array<ArrayBuffer>>
+    async tag(encoding?: 'base64' | 'bytes') {
+      return encodeParts(sealedParts.get(this)!.tag, encoding)
+    }
+
+    async ciphertext(options: {
+      encoding: 'base64'
+      includeTag: boolean
+    }): Promise<string>
+    async ciphertext(options: {
+      encoding: 'bytes'
+      includeTag: boolean
+    }): Promise<Uint8Array<ArrayBuffer>>
+    async ciphertext(options: { encoding: 'base64' | 'bytes'; includeTag: boolean }) {
+      const parts = sealedParts.get(this)!
+      const bytes = options?.includeTag
+        ? concatBytes([parts.ciphertext, parts.tag])
+        : parts.ciphertext
+      return encodeParts(bytes, options?.encoding)
+    }
+
+    async combined(encoding: 'base64'): Promise<string>
+    async combined(encoding?: 'bytes'): Promise<Uint8Array<ArrayBuffer>>
+    async combined(encoding?: 'base64' | 'bytes') {
+      const parts = sealedParts.get(this)!
+      return encodeParts(concatBytes([parts.iv, parts.ciphertext, parts.tag]), encoding)
+    }
+  }
+
+  async function keyMaterial(key: AESEncryptionKey, verb: string): Promise<Uint8Array<ArrayBuffer>> {
+    const own = keyBytes.get(key)
+    if (own) return exactBytes(own)
+    // a key minted by the other entry in the same bundle: read it back
+    // through its public shape instead of rejecting a foreign instance.
+    if (key && typeof key.bytes === 'function') return exactBytes(await key.bytes())
+    throw new TypeError(`${verb}: expected an AESEncryptionKey`)
+  }
+
+  async function partsOf(sealed: AESSealedData, verb: string): Promise<SealedParts> {
+    const own = sealedParts.get(sealed)
+    if (own) {
+      return {
+        iv: exactBytes(own.iv),
+        ciphertext: exactBytes(own.ciphertext),
+        tag: exactBytes(own.tag),
+      }
+    }
+    if (sealed && typeof sealed.iv === 'function' && typeof sealed.combined === 'function') {
+      const iv = exactBytes(await sealed.iv())
+      const tag = exactBytes(await sealed.tag())
+      const ciphertext = exactBytes(await sealed.ciphertext({ encoding: 'bytes', includeTag: false }))
+      return { iv, ciphertext, tag }
+    }
+    throw new TypeError(`${verb}: expected an AESSealedData`)
+  }
+
+  async function aesEncrypt(
+    plaintext: BinaryInput,
+    key: AESEncryptionKey,
+    options: AESEncryptOptions = {}
+  ): Promise<AESSealedData> {
+    const verb = 'Crypto.aesEncrypt'
+    const tagLength = options.tagLength ?? DEFAULT_TAG_LENGTH
+    assertTagLength(tagLength, verb)
+    let iv: Uint8Array<ArrayBuffer>
+    const nonce = options.nonce
+    if (nonce && 'bytes' in nonce && nonce.bytes !== undefined) {
+      iv = toBytes(nonce.bytes, verb)
+      if (iv.length === 0) throw new Error(`${verb}: nonce bytes must not be empty`)
+    } else {
+      const length = nonce && 'length' in nonce && nonce.length !== undefined ? nonce.length : DEFAULT_IV_LENGTH
+      if (!Number.isInteger(length) || length <= 0) {
+        throw new Error(`${verb}: nonce length must be a positive integer`)
+      }
+      iv = new Uint8Array(length)
+      engine.random(iv)
+    }
+    const additionalData =
+      options.additionalData === undefined ? undefined : toBytes(options.additionalData, verb)
+    const plainBytes = toBytes(plaintext, verb)
+    const sealed = await engine.seal(
+      await keyMaterial(key, verb),
+      iv,
+      plainBytes,
+      additionalData,
+      tagLength
+    )
+    // the apple engine always seals with a 16-byte tag, as expo-crypto does
+    // there: gcm ciphertext is plaintext-sized, so the sealed length says
+    // which tag the platform actually produced.
+    const actualTag = sealed.length - plainBytes.length
+    return AESSealedData.fromSeal(iv, sealed, actualTag > 0 ? actualTag : tagLength)
+  }
+
+  async function aesDecrypt(
+    sealedData: AESSealedData,
+    key: AESEncryptionKey,
+    options: AESDecryptOptions & { output: 'base64' }
+  ): Promise<string>
+  async function aesDecrypt(
+    sealedData: AESSealedData,
+    key: AESEncryptionKey,
+    options?: AESDecryptOptions
+  ): Promise<Uint8Array<ArrayBuffer>>
+  async function aesDecrypt(
+    sealedData: AESSealedData,
+    key: AESEncryptionKey,
+    options: AESDecryptOptions = {}
+  ): Promise<string | Uint8Array<ArrayBuffer>> {
+    const verb = 'Crypto.aesDecrypt'
+    const parts = await partsOf(sealedData, verb)
+    const additionalData =
+      options.additionalData === undefined ? undefined : toBytes(options.additionalData, verb)
+    const plaintext = await engine.open(
+      await keyMaterial(key, verb),
+      parts.iv,
+      concatBytes([parts.ciphertext, parts.tag]),
+      additionalData,
+      parts.tag.length
+    )
+    return options.output === 'base64' ? bytesToBase64(plaintext) : plaintext
+  }
+
+  return { AESEncryptionKey, AESSealedData, aesEncrypt, aesDecrypt }
+}
+
+export type AESEncryptionKey = InstanceType<ReturnType<typeof createAesApi>['AESEncryptionKey']>
+export type AESSealedData = InstanceType<ReturnType<typeof createAesApi>['AESSealedData']>

package/src/platform/crypto/bytes.ts

@@ -0,0 +1,120 @@
+// pure byte encodings for the crypto api: hex, base64 and utf-8 without
+// depending on host globals (Hermes has no TextEncoder and atob/btoa are
+// string-in/string-out with latin1 semantics, so binary hosted there would
+// corrupt bytes above 127).
+
+const HEX_DIGITS = '0123456789abcdef'
+
+export function bytesToHex(bytes: Uint8Array): string {
+  let out = ''
+  for (const byte of bytes) out += HEX_DIGITS[byte >> 4] + HEX_DIGITS[byte & 15]
+  return out
+}
+
+export function hexToBytes(hex: string, verb: string): Uint8Array<ArrayBuffer> {
+  if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex)) {
+    throw new Error(`${verb}: expected an even-length hex string`)
+  }
+  const out = new Uint8Array(hex.length / 2)
+  for (let index = 0; index < out.length; index++) {
+    out[index] = parseInt(hex.slice(index * 2, index * 2 + 2), 16)
+  }
+  return out
+}
+
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+const BASE64_VALUES = new Int16Array(128).fill(-1)
+for (let index = 0; index < BASE64_ALPHABET.length; index++) {
+  BASE64_VALUES[BASE64_ALPHABET.charCodeAt(index)] = index
+}
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  let out = ''
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index]
+    const second = bytes[index + 1]
+    const third = bytes[index + 2]
+    out += BASE64_ALPHABET[first >> 2]
+    out += BASE64_ALPHABET[((first & 3) << 4) | ((second ?? 0) >> 4)]
+    out += second === undefined ? '=' : BASE64_ALPHABET[((second & 15) << 2) | ((third ?? 0) >> 6)]
+    out += third === undefined ? '=' : BASE64_ALPHABET[third & 63]
+  }
+  return out
+}
+
+// strict: standard alphabet, length a multiple of four, padding only at the
+// end. anything else throws instead of decoding to a best guess.
+export function base64ToBytes(base64: string, verb: string): Uint8Array<ArrayBuffer> {
+  if (base64.length % 4 !== 0 || /[^A-Za-z0-9+/=]/.test(base64)) {
+    throw new Error(`${verb}: expected a base64 string`)
+  }
+  const padding = base64.endsWith('==') ? 2 : base64.endsWith('=') ? 1 : 0
+  if (base64.slice(0, base64.length - padding).includes('=')) {
+    throw new Error(`${verb}: expected a base64 string`)
+  }
+  const out = new Uint8Array((base64.length / 4) * 3 - padding)
+  let at = 0
+  for (let index = 0; index < base64.length; index += 4) {
+    const values = [0, 1, 2, 3].map((offset) => {
+      const code = base64.charCodeAt(index + offset)
+      return code === 61 ? 0 : BASE64_VALUES[code]
+    })
+    if (values.some((value) => value < 0)) throw new Error(`${verb}: expected a base64 string`)
+    if (at < out.length) out[at++] = (values[0] << 2) | (values[1] >> 4)
+    if (at < out.length) out[at++] = ((values[1] & 15) << 4) | (values[2] >> 2)
+    if (at < out.length) out[at++] = ((values[2] & 3) << 6) | values[3]
+  }
+  return out
+}
+
+// utf-8 encoding for digestString. unpaired surrogates encode as the
+// replacement character, matching TextEncoder.
+export function utf8Encode(text: string): Uint8Array<ArrayBuffer> {
+  const bytes: number[] = []
+  for (let index = 0; index < text.length; index++) {
+    let code = text.charCodeAt(index)
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = text.charCodeAt(index + 1)
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        code = 0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00)
+        index++
+      } else {
+        code = 0xfffd
+      }
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      code = 0xfffd
+    }
+    if (code < 0x80) {
+      bytes.push(code)
+    } else if (code < 0x800) {
+      bytes.push(0xc0 | (code >> 6), 0x80 | (code & 63))
+    } else if (code < 0x10000) {
+      bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 63), 0x80 | (code & 63))
+    } else {
+      bytes.push(
+        0xf0 | (code >> 18),
+        0x80 | ((code >> 12) & 63),
+        0x80 | ((code >> 6) & 63),
+        0x80 | (code & 63)
+      )
+    }
+  }
+  return new Uint8Array(bytes)
+}
+
+// a fresh exact-size copy: what native receives, so a caller mutating its
+// view after the call cannot change bytes in flight.
+export function exactBytes(view: Uint8Array): Uint8Array<ArrayBuffer> {
+  return new Uint8Array(view)
+}
+
+export function concatBytes(parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
+  const length = parts.reduce((sum, part) => sum + part.length, 0)
+  const out = new Uint8Array(length)
+  let at = 0
+  for (const part of parts) {
+    out.set(part, at)
+    at += part.length
+  }
+  return out
+}

package/src/platform/crypto/digest-api.ts

@@ -0,0 +1,50 @@
+import { bytesToBase64, bytesToHex, utf8Encode } from './bytes'
+import { bufferSourceRange, type DigestSource } from './digest'
+import type { DigestAlgorithm, DigestStringOptions } from './types'
+
+// expo-crypto's digest contract over the shared digest source: algorithm
+// names are Expo's strings, unknown ones throw at the js boundary on web and
+// native alike, and digestString hashes the string's utf-8 bytes.
+export const DIGEST_ALGORITHMS: readonly DigestAlgorithm[] = [
+  'MD5',
+  'SHA-1',
+  'SHA-256',
+  'SHA-384',
+  'SHA-512',
+]
+
+export function assertDigestAlgorithm(algorithm: DigestAlgorithm, verb: string): void {
+  if (!DIGEST_ALGORITHMS.includes(algorithm)) {
+    throw new Error(
+      `${verb}: unknown algorithm ${JSON.stringify(algorithm)}. Expected one of: ${DIGEST_ALGORITHMS.join(', ')}`
+    )
+  }
+}
+
+export function createDigestApi(source: DigestSource) {
+  async function digest(algorithm: DigestAlgorithm, data: BufferSource): Promise<ArrayBuffer> {
+    assertDigestAlgorithm(algorithm, 'Crypto.digest')
+    const { buffer, offset, length } = bufferSourceRange(data, 'Crypto.digest')
+    return source(algorithm, buffer, offset, length)
+  }
+
+  async function digestString(
+    algorithm: DigestAlgorithm,
+    data: string,
+    options: DigestStringOptions = {}
+  ): Promise<string> {
+    assertDigestAlgorithm(algorithm, 'Crypto.digestString')
+    if (typeof data !== 'string') {
+      throw new TypeError('Crypto.digestString: data must be a string')
+    }
+    const encoding = options?.encoding ?? 'hex'
+    if (encoding !== 'hex' && encoding !== 'base64') {
+      throw new Error(`Crypto.digestString: encoding must be 'hex' or 'base64'`)
+    }
+    const bytes = utf8Encode(data)
+    const hashed = new Uint8Array(await source(algorithm, bytes.buffer, 0, bytes.length))
+    return encoding === 'base64' ? bytesToBase64(hashed) : bytesToHex(hashed)
+  }
+
+  return { digest, digestString }
+}

package/src/platform/crypto/digest.ts

@@ -21,6 +21,29 @@ function namedError(name: string, message: string): Error {
   return error
 }
 
+// the exact byte range a BufferSource names, or a TypeError. detached
+// buffers throw from the view construction, before any native call.
+export function bufferSourceRange(
+  data: BufferSource,
+  verb: string
+): { buffer: ArrayBuffer; offset: number; length: number } {
+  let buffer: ArrayBuffer
+  let offset = 0
+  let length: number
+  if (data instanceof ArrayBuffer) {
+    buffer = data
+    length = data.byteLength
+  } else if (ArrayBuffer.isView(data) && data.buffer instanceof ArrayBuffer) {
+    buffer = data.buffer
+    offset = data.byteOffset
+    length = data.byteLength
+  } else {
+    throw new TypeError(`${verb}: expected an ArrayBuffer or view.`)
+  }
+  new Uint8Array(buffer, offset, length)
+  return { buffer, offset, length }
+}
+
 export function installDigestPolyfill(
   source: DigestSource,
   target: DigestTarget = globalThis
@@ -31,21 +54,7 @@ export function installDigestPolyfill(
     algorithm: AlgorithmIdentifier,
     data: BufferSource
   ): Promise<ArrayBuffer> => {
-    let buffer: ArrayBuffer
-    let offset = 0
-    let length: number
-    if (data instanceof ArrayBuffer) {
-      buffer = data
-      length = data.byteLength
-    } else if (ArrayBuffer.isView(data) && data.buffer instanceof ArrayBuffer) {
-      buffer = data.buffer
-      offset = data.byteOffset
-      length = data.byteLength
-    } else {
-      throw new TypeError('crypto.subtle.digest: expected an ArrayBuffer or view.')
-    }
-    // reject detached buffers before entering native code, including empty views.
-    new Uint8Array(buffer, offset, length)
+    const { buffer, offset, length } = bufferSourceRange(data, 'crypto.subtle.digest')
     let name: string
     if (
       algorithm !== null &&

package/src/platform/crypto/index.native.ts

@@ -1,7 +1,24 @@
+import { createAesApi, type AesEngine } from './aes'
 import { installDigestPolyfill } from './digest'
+import { createDigestApi } from './digest-api'
 import { NitroModules } from 'react-native-nitro-modules'
 import type { OneCrypto } from '../specs/OneCrypto.nitro'
 import { installCryptoPolyfill, type RandomSource } from './random'
+import type { Crypto as CryptoApi } from './types'
+
+export type {
+  AESDecryptOptions,
+  AESEncryptOptions,
+  AESKeySize,
+  AESSealedDataConfig,
+  BinaryInput,
+  CryptoApi,
+  DigestAlgorithm,
+  DigestEncoding,
+  DigestStringOptions,
+  GCMNonceParam,
+} from './types'
+export type { AESEncryptionKey as AESEncryptionKeyType, AESSealedData as AESSealedDataType } from './aes'
 
 // secure random from the platform csprng (arc4random_buf on both) through the
 // OneCrypto c++ hybrid object, created on first use and cached. bytes land in
@@ -25,6 +42,57 @@ const nativeSource: RandomSource = {
 // lacks them. no-ops when the binary has no OneCrypto: installing a throwing
 // source would only replace a clear missing-crypto error with a confusing
 // one at the call site.
+// the public One.Crypto api over the same hybrid object: throwing module
+// access is right here, unlike installCrypto below. a caller asking for a
+// digest or a seal must learn the binary predates it, not get a fake.
+function required(): OneCrypto {
+  if (!NitroModules.hasHybridObject('OneCrypto')) {
+    throw new Error('Crypto needs a native build that includes one')
+  }
+  return native()
+}
+
+const aesEngine: AesEngine = {
+  async seal(key, iv, plaintext, additionalData, tagLength) {
+    const sealed = await required().aesEncrypt(
+      key.buffer,
+      iv.buffer,
+      plaintext.buffer,
+      additionalData?.buffer,
+      tagLength
+    )
+    return new Uint8Array(sealed)
+  },
+  async open(key, iv, ciphertextWithTag, additionalData, tagLength) {
+    const opened = await required().aesDecrypt(
+      key.buffer,
+      iv.buffer,
+      ciphertextWithTag.buffer,
+      additionalData?.buffer,
+      tagLength
+    )
+    return new Uint8Array(opened)
+  },
+  random(bytes) {
+    required().fillRandomBytes(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  },
+}
+
+const aes = createAesApi(aesEngine)
+const digestApi = createDigestApi((algorithm, buffer, offset, length) =>
+  required().digest(algorithm, buffer, offset, length)
+)
+
+export const AESEncryptionKey = aes.AESEncryptionKey
+export const AESSealedData = aes.AESSealedData
+
+export const Crypto: CryptoApi = Object.freeze({
+  digest: digestApi.digest,
+  digestString: digestApi.digestString,
+  aesEncrypt: aes.aesEncrypt,
+  aesDecrypt: aes.aesDecrypt,
+})
+
 export function installCrypto(): void {
   if (!NitroModules.hasHybridObject('OneCrypto')) {
     return

package/src/platform/crypto/index.ts

@@ -1,4 +1,22 @@
+import { createAesApi } from './aes'
+import { createDigestApi } from './digest-api'
 import { formatUuidV4, installCryptoPolyfill, type RandomSource } from './random'
+import type { Crypto as CryptoApi } from './types'
+import { webAesEngine, webDigestSource } from './web'
+
+export type {
+  AESDecryptOptions,
+  AESEncryptOptions,
+  AESKeySize,
+  AESSealedDataConfig,
+  BinaryInput,
+  CryptoApi,
+  DigestAlgorithm,
+  DigestEncoding,
+  DigestStringOptions,
+  GCMNonceParam,
+} from './types'
+export type { AESEncryptionKey as AESEncryptionKeyType, AESSealedData as AESSealedDataType } from './aes'
 
 // web entry. same shape as the native entry, but the random source is the
 // platform crypto itself: installCrypto only fills genuinely missing
@@ -23,3 +41,16 @@ const source: RandomSource = {
 export function installCrypto(): void {
   installCryptoPolyfill(source)
 }
+
+const aes = createAesApi(webAesEngine)
+const digestApi = createDigestApi(webDigestSource)
+
+export const AESEncryptionKey = aes.AESEncryptionKey
+export const AESSealedData = aes.AESSealedData
+
+export const Crypto: CryptoApi = Object.freeze({
+  digest: digestApi.digest,
+  digestString: digestApi.digestString,
+  aesEncrypt: aes.aesEncrypt,
+  aesDecrypt: aes.aesDecrypt,
+})