@reallyme/crypto 0.2.0 → 0.3.1

package/dist/validateBytes.js

@@ -2,25 +2,79 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { ReallyMeCryptoError } from "./errors.js";
+// Match the structured operation boundary so direct primitive facades cannot
+// ask a provider to copy or allocate an attacker-controlled unbounded buffer.
+export const MAX_CRYPTO_INPUT_LENGTH = 1_048_576;
 export const ensureByteArray = (value) => {
     if (!(value instanceof Uint8Array)) {
         throw new ReallyMeCryptoError("invalid-input");
     }
 };
+export const ensureByteArrayAtMost = (value, maximumLength) => {
+    ensureByteArray(value);
+    if (value.length > maximumLength) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
 export const ensureBytes = (value, expectedLength) => {
     ensureByteArray(value);
     if (value.length !== expectedLength) {
         throw new ReallyMeCryptoError("invalid-input");
     }
 };
-export const readByteArrayProperty = (value, propertyName, expectedLength) => {
+export const byteArraysOverlap = (left, right) => {
+    if (left.buffer !== right.buffer) {
+        return false;
+    }
+    const leftEnd = left.byteOffset + left.byteLength;
+    const rightEnd = right.byteOffset + right.byteLength;
+    return left.byteOffset < rightEnd && right.byteOffset < leftEnd;
+};
+export const ensureIndependentByteArray = (value, disallowedViews) => {
+    // A disjoint view into the same ArrayBuffer is still not independently
+    // owned: transferring or detaching the caller's buffer would invalidate the
+    // provider output too. Provider results must own separate backing storage.
+    if (disallowedViews.some((view) => value.buffer === view.buffer)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+};
+const readProviderByteArrayProperty = (value, propertyName) => {
     if (typeof value !== "object" || value === null) {
         throw new ReallyMeCryptoError("provider-failure");
     }
-    const property = Reflect.get(value, propertyName);
+    let property;
+    try {
+        property = Reflect.get(value, propertyName);
+    }
+    catch (_error) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
     if (!(property instanceof Uint8Array)) {
         throw new ReallyMeCryptoError("provider-failure");
     }
-    ensureBytes(property, expectedLength);
     return property;
 };
+export const readIndependentByteArrayProperty = (value, propertyName, expectedLength, disallowedViews) => {
+    const property = readProviderByteArrayProperty(value, propertyName);
+    // Check ownership before cleanup so a malformed provider cannot make the
+    // validator erase a caller-owned input view.
+    ensureIndependentByteArray(property, disallowedViews);
+    if (property.length !== expectedLength) {
+        property.fill(0);
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return property;
+};
+export const readIndependentProviderBytes = (value, expectedLength, disallowedViews) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    // Provider-owned secret outputs are cleared on malformed length, but only
+    // after proving the provider did not hand back a caller-owned buffer.
+    ensureIndependentByteArray(value, disallowedViews);
+    if (value.length !== expectedLength) {
+        value.fill(0);
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};

package/dist/wasm/reallyme_crypto_wasm.js

@@ -32,6 +32,34 @@ export function aes128GcmSeal(key, nonce, aad, plaintext) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Unwrap key material with AES-128-KW.
+ * @param {Uint8Array} kek
+ * @param {Uint8Array} wrapped_key
+ * @returns {Uint8Array}
+ */
+export function aes128KwUnwrapKey(kek, wrapped_key) {
+    const ret = wasm.aes128KwUnwrapKey(kek, wrapped_key);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Wrap key material with AES-128-KW.
+ * @param {Uint8Array} kek
+ * @param {Uint8Array} key_data
+ * @returns {Uint8Array}
+ */
+export function aes128KwWrapKey(kek, key_data) {
+    const ret = wasm.aes128KwWrapKey(kek, key_data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Open and authenticate an AES-192-GCM `ciphertext || tag`.
  * @param {Uint8Array} key
@@ -64,6 +92,34 @@ export function aes192GcmSeal(key, nonce, aad, plaintext) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Unwrap key material with AES-192-KW.
+ * @param {Uint8Array} kek
+ * @param {Uint8Array} wrapped_key
+ * @returns {Uint8Array}
+ */
+export function aes192KwUnwrapKey(kek, wrapped_key) {
+    const ret = wasm.aes192KwUnwrapKey(kek, wrapped_key);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Wrap key material with AES-192-KW.
+ * @param {Uint8Array} kek
+ * @param {Uint8Array} key_data
+ * @returns {Uint8Array}
+ */
+export function aes192KwWrapKey(kek, key_data) {
+    const ret = wasm.aes192KwWrapKey(kek, key_data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Open and authenticate an AES-256-GCM `ciphertext || tag`.
  * @param {Uint8Array} key
@@ -129,7 +185,7 @@ export function aes256GcmSivSeal(key, nonce, aad, plaintext) {
 }
 
 /**
- * Unwrap an RFC 3394 AES-256-KW wrapped key.
+ * Unwrap key material with AES-256-KW.
  * @param {Uint8Array} kek
  * @param {Uint8Array} wrapped_key
  * @returns {Uint8Array}
@@ -143,7 +199,7 @@ export function aes256KwUnwrapKey(kek, wrapped_key) {
 }
 
 /**
- * Wrap key material with AES-256-KW and return the RFC 3394 wrapped key.
+ * Wrap key material with AES-256-KW.
  * @param {Uint8Array} kek
  * @param {Uint8Array} key_data
  * @returns {Uint8Array}
@@ -239,17 +295,15 @@ export function hpkeSealBase(suite, recipient_public_key, info, aad, plaintext)
 }
 
 /**
- * Deterministically seal one HPKE Base-mode message for conformance tests.
- * @param {number} suite
- * @param {Uint8Array} recipient_public_key
- * @param {Uint8Array} encapsulation_randomness
- * @param {Uint8Array} info
- * @param {Uint8Array} aad
- * @param {Uint8Array} plaintext
- * @returns {any}
+ * Derive key material with KMAC256.
+ * @param {Uint8Array} key
+ * @param {Uint8Array} context
+ * @param {Uint8Array} customization
+ * @param {number} output_length
+ * @returns {Uint8Array}
  */
-export function hpkeSealBaseDerand(suite, recipient_public_key, encapsulation_randomness, info, aad, plaintext) {
-    const ret = wasm.hpkeSealBaseDerand(suite, recipient_public_key, encapsulation_randomness, info, aad, plaintext);
+export function kmac256Derive(key, context, customization, output_length) {
+    const ret = wasm.kmac256Derive(key, context, customization, output_length);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -452,20 +506,6 @@ export function mlKem1024Encapsulate(public_key) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * Deterministically encapsulate to an ML-KEM-1024 public key.
- * @param {Uint8Array} public_key
- * @param {Uint8Array} randomness
- * @returns {any}
- */
-export function mlKem1024EncapsulateDerand(public_key, randomness) {
-    const ret = wasm.mlKem1024EncapsulateDerand(public_key, randomness);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
 /**
  * Generate an ML-KEM-1024 keypair.
  * @returns {any}
@@ -518,20 +558,6 @@ export function mlKem512Encapsulate(public_key) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * Deterministically encapsulate to an ML-KEM-512 public key.
- * @param {Uint8Array} public_key
- * @param {Uint8Array} randomness
- * @returns {any}
- */
-export function mlKem512EncapsulateDerand(public_key, randomness) {
-    const ret = wasm.mlKem512EncapsulateDerand(public_key, randomness);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
 /**
  * Generate an ML-KEM-512 keypair.
  * @returns {any}
@@ -585,13 +611,11 @@ export function mlKem768Encapsulate(public_key) {
 }
 
 /**
- * Deterministically encapsulate to an ML-KEM-768 public key.
- * @param {Uint8Array} public_key
- * @param {Uint8Array} randomness
+ * Generate an ML-KEM-768 keypair.
  * @returns {any}
  */
-export function mlKem768EncapsulateDerand(public_key, randomness) {
-    const ret = wasm.mlKem768EncapsulateDerand(public_key, randomness);
+export function mlKem768GenerateKeypair() {
+    const ret = wasm.mlKem768GenerateKeypair();
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -599,15 +623,23 @@ export function mlKem768EncapsulateDerand(public_key, randomness) {
 }
 
 /**
- * Generate an ML-KEM-768 keypair.
- * @returns {any}
+ * Execute one generated binary protobuf request and return a binary `CryptoOperationResponse`.
+ * @param {Uint8Array} request
+ * @returns {Uint8Array}
  */
-export function mlKem768GenerateKeypair() {
-    const ret = wasm.mlKem768GenerateKeypair();
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function processOperationResponse(request) {
+    const ret = wasm.processOperationResponse(request);
+    return ret;
+}
+
+/**
+ * Execute one generated ProtoJSON request and return a binary `CryptoOperationResponse`.
+ * @param {Uint8Array} request_json
+ * @returns {Uint8Array}
+ */
+export function processOperationResponseJson(request_json) {
+    const ret = wasm.processOperationResponseJson(request_json);
+    return ret;
 }
 
 /**
@@ -696,72 +728,6 @@ export function slhDsaSha2128sVerify(public_key, message, signature) {
     }
 }
 
-/**
- * Decapsulate an X-Wing-1024 ciphertext with a 32-byte secret seed.
- * @param {Uint8Array} ciphertext
- * @param {Uint8Array} secret_key
- * @returns {Uint8Array}
- */
-export function xWing1024Decapsulate(ciphertext, secret_key) {
-    const ret = wasm.xWing1024Decapsulate(ciphertext, secret_key);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Derive an X-Wing-1024 public key from a 32-byte secret seed.
- * @param {Uint8Array} secret_key
- * @returns {any}
- */
-export function xWing1024DeriveKeypair(secret_key) {
-    const ret = wasm.xWing1024DeriveKeypair(secret_key);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Randomly encapsulate to an X-Wing-1024 public key.
- * @param {Uint8Array} public_key
- * @returns {any}
- */
-export function xWing1024Encapsulate(public_key) {
-    const ret = wasm.xWing1024Encapsulate(public_key);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Deterministically encapsulate to an X-Wing-1024 public key for conformance tests.
- * @param {Uint8Array} public_key
- * @param {Uint8Array} seed
- * @returns {any}
- */
-export function xWing1024EncapsulateDerand(public_key, seed) {
-    const ret = wasm.xWing1024EncapsulateDerand(public_key, seed);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Generate a random X-Wing-1024 keypair for the TypeScript WASM provider.
- * @returns {any}
- */
-export function xWing1024GenerateKeypair() {
-    const ret = wasm.xWing1024GenerateKeypair();
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
 /**
  * Decapsulate an X-Wing-768 ciphertext with a 32-byte secret seed.
  * @param {Uint8Array} ciphertext
@@ -802,20 +768,6 @@ export function xWing768Encapsulate(public_key) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * Deterministically encapsulate to an X-Wing-768 public key for conformance tests.
- * @param {Uint8Array} public_key
- * @param {Uint8Array} seed
- * @returns {any}
- */
-export function xWing768EncapsulateDerand(public_key, seed) {
-    const ret = wasm.xWing768EncapsulateDerand(public_key, seed);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
 /**
  * Generate a random X-Wing-768 keypair for the TypeScript WASM provider.
  * @returns {any}
@@ -887,7 +839,12 @@ function __wbg_get_imports() {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;

package/dist/wasmModuleTypes.d.ts

@@ -4,6 +4,8 @@ export type ReallyMeWasmInitOutput = Readonly<{
 export declare function initSync(module: {
     module: Uint8Array;
 }): ReallyMeWasmInitOutput;
+export declare function processOperationResponse(request: Uint8Array): Uint8Array;
+export declare function processOperationResponseJson(requestJson: Uint8Array): Uint8Array;
 export declare function aes128GcmOpen(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array): Uint8Array;
 export declare function aes128GcmSeal(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
 export declare function aes192GcmOpen(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array): Uint8Array;
@@ -12,26 +14,27 @@ export declare function aes256GcmOpen(key: Uint8Array, nonce: Uint8Array, aad: U
 export declare function aes256GcmSeal(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
 export declare function aes256GcmSivOpen(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array): Uint8Array;
 export declare function aes256GcmSivSeal(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
+export declare function aes128KwUnwrapKey(wrappingKey: Uint8Array, wrappedKey: Uint8Array): Uint8Array;
+export declare function aes128KwWrapKey(wrappingKey: Uint8Array, keyToWrap: Uint8Array): Uint8Array;
+export declare function aes192KwUnwrapKey(wrappingKey: Uint8Array, wrappedKey: Uint8Array): Uint8Array;
+export declare function aes192KwWrapKey(wrappingKey: Uint8Array, keyToWrap: Uint8Array): Uint8Array;
 export declare function aes256KwUnwrapKey(wrappingKey: Uint8Array, wrappedKey: Uint8Array): Uint8Array;
 export declare function aes256KwWrapKey(wrappingKey: Uint8Array, keyToWrap: Uint8Array): Uint8Array;
 export declare function argon2idDeriveKey(kdfVersion: number, secret: Uint8Array, salt: Uint8Array): Uint8Array;
+export declare function kmac256Derive(key: Uint8Array, context: Uint8Array, customization: Uint8Array, outputLength: number): Uint8Array;
 export declare function hpkeOpenBase(suite: number, recipientSecretKey: Uint8Array, encapsulatedKey: Uint8Array, info: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array): Uint8Array;
 export declare function hpkeSealBase(suite: number, recipientPublicKey: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): unknown;
-export declare function hpkeSealBaseDerand(suite: number, recipientPublicKey: Uint8Array, encapsulationRandomness: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): unknown;
 export declare function mlKem512GenerateKeypair(): unknown;
 export declare function mlKem512DeriveKeypair(secretKey: Uint8Array): unknown;
 export declare function mlKem512Encapsulate(publicKey: Uint8Array): unknown;
-export declare function mlKem512EncapsulateDerand(publicKey: Uint8Array, randomness: Uint8Array): unknown;
 export declare function mlKem512Decapsulate(ciphertext: Uint8Array, secretKey: Uint8Array): Uint8Array;
 export declare function mlKem768GenerateKeypair(): unknown;
 export declare function mlKem768DeriveKeypair(secretKey: Uint8Array): unknown;
 export declare function mlKem768Encapsulate(publicKey: Uint8Array): unknown;
-export declare function mlKem768EncapsulateDerand(publicKey: Uint8Array, randomness: Uint8Array): unknown;
 export declare function mlKem768Decapsulate(ciphertext: Uint8Array, secretKey: Uint8Array): Uint8Array;
 export declare function mlKem1024GenerateKeypair(): unknown;
 export declare function mlKem1024DeriveKeypair(secretKey: Uint8Array): unknown;
 export declare function mlKem1024Encapsulate(publicKey: Uint8Array): unknown;
-export declare function mlKem1024EncapsulateDerand(publicKey: Uint8Array, randomness: Uint8Array): unknown;
 export declare function mlKem1024Decapsulate(ciphertext: Uint8Array, secretKey: Uint8Array): Uint8Array;
 export declare function mlDsa44GenerateKeypair(): unknown;
 export declare function mlDsa44DeriveKeypair(secretKey: Uint8Array): unknown;
@@ -55,13 +58,7 @@ export declare function chacha20Poly1305Open(key: Uint8Array, nonce: Uint8Array,
 export declare function chacha20Poly1305Seal(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
 export declare function xchacha20Poly1305Open(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array): Uint8Array;
 export declare function xchacha20Poly1305Seal(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
-export declare function xWing1024Decapsulate(ciphertext: Uint8Array, secretKey: Uint8Array): Uint8Array;
-export declare function xWing1024DeriveKeypair(secretKey: Uint8Array): unknown;
-export declare function xWing1024Encapsulate(publicKey: Uint8Array): unknown;
-export declare function xWing1024EncapsulateDerand(publicKey: Uint8Array, seed: Uint8Array): unknown;
-export declare function xWing1024GenerateKeypair(): unknown;
 export declare function xWing768Decapsulate(ciphertext: Uint8Array, secretKey: Uint8Array): Uint8Array;
 export declare function xWing768DeriveKeypair(secretKey: Uint8Array): unknown;
 export declare function xWing768Encapsulate(publicKey: Uint8Array): unknown;
-export declare function xWing768EncapsulateDerand(publicKey: Uint8Array, seed: Uint8Array): unknown;
 export declare function xWing768GenerateKeypair(): unknown;

package/dist/wasmProvider.d.ts

@@ -1,21 +1,24 @@
 type GenerateKeypairFn = () => unknown;
 type GenerateKeypairFromSeedFn = (seed: Uint8Array) => unknown;
 type Argon2idFn = (kdfVersion: number, secret: Uint8Array, salt: Uint8Array) => unknown;
+type KmacFn = (key: Uint8Array, context: Uint8Array, customization: Uint8Array, outputLength: number) => unknown;
 type AeadFn = (key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, text: Uint8Array) => unknown;
-type KeyWrapFn = (wrappingKey: Uint8Array, keyMaterial: Uint8Array) => unknown;
+type TwoByteArraysFn = (first: Uint8Array, second: Uint8Array) => unknown;
+type KeyWrapFn = TwoByteArraysFn;
 type SignatureSignFn = (secretKey: Uint8Array, message: Uint8Array) => unknown;
 type SignatureVerifyFn = (publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => unknown;
 type RsaPkcs1v15VerifyFn = (publicKeyDer: Uint8Array, publicKeyEncoding: number, hashSuite: number, message: Uint8Array, signature: Uint8Array) => unknown;
 type RsaPssVerifyFn = (publicKeyDer: Uint8Array, publicKeyEncoding: number, messageHashSuite: number, mgf1HashSuite: number, saltLength: number, message: Uint8Array, signature: Uint8Array) => unknown;
 type HpkeOpenFn = (suite: number, recipientSecretKey: Uint8Array, encapsulatedKey: Uint8Array, info: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array) => unknown;
 type HpkeSealFn = (suite: number, recipientPublicKey: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => unknown;
-type HpkeSealDerandFn = (suite: number, recipientPublicKey: Uint8Array, encapsulationRandomness: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => unknown;
 type DeriveKeypairFn = (secretKey: Uint8Array) => unknown;
 type SlhDsaDeriveKeypairFn = (skSeed: Uint8Array, skPrf: Uint8Array, pkSeed: Uint8Array) => unknown;
 type EncapsulateFn = (publicKey: Uint8Array) => unknown;
-type EncapsulateDerandFn = (publicKey: Uint8Array, seed: Uint8Array) => unknown;
 type DecapsulateFn = (ciphertext: Uint8Array, secretKey: Uint8Array) => unknown;
+type BytesToBytesFn = (bytes: Uint8Array) => unknown;
 export type ReallyMeWasmProvider = Readonly<{
+    processOperationResponse: BytesToBytesFn;
+    processOperationResponseJson: BytesToBytesFn;
     aes128GcmSeal: AeadFn;
     aes128GcmOpen: AeadFn;
     aes192GcmSeal: AeadFn;
@@ -28,11 +31,15 @@ export type ReallyMeWasmProvider = Readonly<{
     chacha20Poly1305Open: AeadFn;
     xchacha20Poly1305Seal: AeadFn;
     xchacha20Poly1305Open: AeadFn;
+    aes128KwWrapKey: KeyWrapFn;
+    aes128KwUnwrapKey: KeyWrapFn;
+    aes192KwWrapKey: KeyWrapFn;
+    aes192KwUnwrapKey: KeyWrapFn;
     aes256KwWrapKey: KeyWrapFn;
     aes256KwUnwrapKey: KeyWrapFn;
     argon2idDeriveKey: Argon2idFn;
+    kmac256Derive: KmacFn;
     hpkeSealBase: HpkeSealFn;
-    hpkeSealBaseDerand: HpkeSealDerandFn;
     hpkeOpenBase: HpkeOpenFn;
     mlDsa44GenerateKeypair: GenerateKeypairFn;
     mlDsa44DeriveKeypair: GenerateKeypairFromSeedFn;
@@ -49,17 +56,14 @@ export type ReallyMeWasmProvider = Readonly<{
     mlKem512GenerateKeypair: GenerateKeypairFn;
     mlKem512DeriveKeypair: GenerateKeypairFromSeedFn;
     mlKem512Encapsulate: EncapsulateFn;
-    mlKem512EncapsulateDerand: EncapsulateDerandFn;
     mlKem512Decapsulate: DecapsulateFn;
     mlKem768GenerateKeypair: GenerateKeypairFn;
     mlKem768DeriveKeypair: GenerateKeypairFromSeedFn;
     mlKem768Encapsulate: EncapsulateFn;
-    mlKem768EncapsulateDerand: EncapsulateDerandFn;
     mlKem768Decapsulate: DecapsulateFn;
     mlKem1024GenerateKeypair: GenerateKeypairFn;
     mlKem1024DeriveKeypair: GenerateKeypairFromSeedFn;
     mlKem1024Encapsulate: EncapsulateFn;
-    mlKem1024EncapsulateDerand: EncapsulateDerandFn;
     mlKem1024Decapsulate: DecapsulateFn;
     slhDsaSha2128sGenerateKeypair: GenerateKeypairFn;
     slhDsaSha2128sDeriveKeypair: SlhDsaDeriveKeypairFn;
@@ -70,13 +74,7 @@ export type ReallyMeWasmProvider = Readonly<{
     xWing768GenerateKeypair: GenerateKeypairFn;
     xWing768DeriveKeypair: DeriveKeypairFn;
     xWing768Encapsulate: EncapsulateFn;
-    xWing768EncapsulateDerand: EncapsulateDerandFn;
     xWing768Decapsulate: DecapsulateFn;
-    xWing1024GenerateKeypair: GenerateKeypairFn;
-    xWing1024DeriveKeypair: DeriveKeypairFn;
-    xWing1024Encapsulate: EncapsulateFn;
-    xWing1024EncapsulateDerand: EncapsulateDerandFn;
-    xWing1024Decapsulate: DecapsulateFn;
 }>;
 export declare const createReallyMeWasmProvider: (module: unknown) => ReallyMeWasmProvider;
 export declare const installReallyMeWasmProvider: (module: unknown) => void;

package/dist/wasmProvider.js

@@ -25,15 +25,15 @@ const requireFunction = (module, name) => {
 };
 const wasmErrorCode = (error) => {
     switch (error) {
-        case "invalid-input":
+        case 1 /* WasmErrorCode.InvalidInput */:
             return "invalid-input";
-        case "invalid-signature":
+        case 2 /* WasmErrorCode.InvalidSignature */:
             return "invalid-signature";
-        case "authentication-failed":
+        case 3 /* WasmErrorCode.AuthenticationFailed */:
             return "authentication-failed";
-        case "unsupported-algorithm":
+        case 5 /* WasmErrorCode.UnsupportedAlgorithm */:
             return "unsupported-algorithm";
-        case "provider-failure":
+        case 4 /* WasmErrorCode.ProviderFailure */:
         default:
             return "provider-failure";
     }
@@ -66,13 +66,13 @@ const argon2idFunction = (module, name) => {
     const callable = requireFunction(module, name);
     return (kdfVersion, secret, salt) => callable(kdfVersion, secret, salt);
 };
-const hpkeSealFunction = (module, name) => {
+const kmacFunction = (module, name) => {
     const callable = requireFunction(module, name);
-    return (suite, recipientPublicKey, info, aad, plaintext) => callable(suite, recipientPublicKey, info, aad, plaintext);
+    return (key, context, customization, outputLength) => callable(key, context, customization, outputLength);
 };
-const hpkeSealDerandFunction = (module, name) => {
+const hpkeSealFunction = (module, name) => {
     const callable = requireFunction(module, name);
-    return (suite, recipientPublicKey, encapsulationRandomness, info, aad, plaintext) => callable(suite, recipientPublicKey, encapsulationRandomness, info, aad, plaintext);
+    return (suite, recipientPublicKey, info, aad, plaintext) => callable(suite, recipientPublicKey, info, aad, plaintext);
 };
 const hpkeOpenFunction = (module, name) => {
     const callable = requireFunction(module, name);
@@ -89,6 +89,8 @@ const rsaPssVerifyFunction = (module, name) => {
 export const createReallyMeWasmProvider = (module) => {
     const providerModule = requireObject(module);
     return {
+        processOperationResponse: function1(providerModule, "processOperationResponse"),
+        processOperationResponseJson: function1(providerModule, "processOperationResponseJson"),
         aes128GcmSeal: function4(providerModule, "aes128GcmSeal"),
         aes128GcmOpen: function4(providerModule, "aes128GcmOpen"),
         aes192GcmSeal: function4(providerModule, "aes192GcmSeal"),
@@ -101,11 +103,15 @@ export const createReallyMeWasmProvider = (module) => {
         chacha20Poly1305Open: function4(providerModule, "chacha20Poly1305Open"),
         xchacha20Poly1305Seal: function4(providerModule, "xchacha20Poly1305Seal"),
         xchacha20Poly1305Open: function4(providerModule, "xchacha20Poly1305Open"),
+        aes128KwWrapKey: function2(providerModule, "aes128KwWrapKey"),
+        aes128KwUnwrapKey: function2(providerModule, "aes128KwUnwrapKey"),
+        aes192KwWrapKey: function2(providerModule, "aes192KwWrapKey"),
+        aes192KwUnwrapKey: function2(providerModule, "aes192KwUnwrapKey"),
         aes256KwWrapKey: function2(providerModule, "aes256KwWrapKey"),
         aes256KwUnwrapKey: function2(providerModule, "aes256KwUnwrapKey"),
         argon2idDeriveKey: argon2idFunction(providerModule, "argon2idDeriveKey"),
+        kmac256Derive: kmacFunction(providerModule, "kmac256Derive"),
         hpkeSealBase: hpkeSealFunction(providerModule, "hpkeSealBase"),
-        hpkeSealBaseDerand: hpkeSealDerandFunction(providerModule, "hpkeSealBaseDerand"),
         hpkeOpenBase: hpkeOpenFunction(providerModule, "hpkeOpenBase"),
         mlDsa44GenerateKeypair: function0(providerModule, "mlDsa44GenerateKeypair"),
         mlDsa44DeriveKeypair: function1(providerModule, "mlDsa44DeriveKeypair"),
@@ -122,17 +128,14 @@ export const createReallyMeWasmProvider = (module) => {
         mlKem512GenerateKeypair: function0(providerModule, "mlKem512GenerateKeypair"),
         mlKem512DeriveKeypair: function1(providerModule, "mlKem512DeriveKeypair"),
         mlKem512Encapsulate: function1(providerModule, "mlKem512Encapsulate"),
-        mlKem512EncapsulateDerand: function2(providerModule, "mlKem512EncapsulateDerand"),
         mlKem512Decapsulate: function2(providerModule, "mlKem512Decapsulate"),
         mlKem768GenerateKeypair: function0(providerModule, "mlKem768GenerateKeypair"),
         mlKem768DeriveKeypair: function1(providerModule, "mlKem768DeriveKeypair"),
         mlKem768Encapsulate: function1(providerModule, "mlKem768Encapsulate"),
-        mlKem768EncapsulateDerand: function2(providerModule, "mlKem768EncapsulateDerand"),
         mlKem768Decapsulate: function2(providerModule, "mlKem768Decapsulate"),
         mlKem1024GenerateKeypair: function0(providerModule, "mlKem1024GenerateKeypair"),
         mlKem1024DeriveKeypair: function1(providerModule, "mlKem1024DeriveKeypair"),
         mlKem1024Encapsulate: function1(providerModule, "mlKem1024Encapsulate"),
-        mlKem1024EncapsulateDerand: function2(providerModule, "mlKem1024EncapsulateDerand"),
         mlKem1024Decapsulate: function2(providerModule, "mlKem1024Decapsulate"),
         slhDsaSha2128sGenerateKeypair: function0(providerModule, "slhDsaSha2128sGenerateKeypair"),
         slhDsaSha2128sDeriveKeypair: deriveSlhDsaFunction3(providerModule, "slhDsaSha2128sDeriveKeypair"),
@@ -143,13 +146,7 @@ export const createReallyMeWasmProvider = (module) => {
         xWing768GenerateKeypair: function0(providerModule, "xWing768GenerateKeypair"),
         xWing768DeriveKeypair: function1(providerModule, "xWing768DeriveKeypair"),
         xWing768Encapsulate: function1(providerModule, "xWing768Encapsulate"),
-        xWing768EncapsulateDerand: function2(providerModule, "xWing768EncapsulateDerand"),
         xWing768Decapsulate: function2(providerModule, "xWing768Decapsulate"),
-        xWing1024GenerateKeypair: function0(providerModule, "xWing1024GenerateKeypair"),
-        xWing1024DeriveKeypair: function1(providerModule, "xWing1024DeriveKeypair"),
-        xWing1024Encapsulate: function1(providerModule, "xWing1024Encapsulate"),
-        xWing1024EncapsulateDerand: function2(providerModule, "xWing1024EncapsulateDerand"),
-        xWing1024Decapsulate: function2(providerModule, "xWing1024Decapsulate"),
     };
 };
 export const installReallyMeWasmProvider = (module) => {

package/dist/xWing.d.ts

@@ -1,12 +1,9 @@
 import type { ReallyMeKemAlgorithm } from "./algorithms.js";
 import type { ReallyMeWasmProvider } from "./wasmProvider.js";
 export declare const X_WING_SECRET_KEY_LENGTH = 32;
-export declare const X_WING_ENCAPSULATION_SEED_LENGTH = 64;
 export declare const X_WING_SHARED_SECRET_LENGTH = 32;
 export declare const X_WING_768_PUBLIC_KEY_LENGTH = 1216;
 export declare const X_WING_768_CIPHERTEXT_LENGTH = 1120;
-export declare const X_WING_1024_PUBLIC_KEY_LENGTH = 1600;
-export declare const X_WING_1024_CIPHERTEXT_LENGTH = 1600;
 export type ReallyMeXWingKeyPair = Readonly<{
     publicKey: Uint8Array;
     secretKey: Uint8Array;
@@ -25,5 +22,3 @@ export declare const ReallyMeXWing: {
     readonly decapsulate: (algorithm: ReallyMeKemAlgorithm, ciphertext: Uint8Array, secretKey: Uint8Array) => Uint8Array;
     readonly decapsulateWithProvider: (provider: ReallyMeWasmProvider, algorithm: ReallyMeKemAlgorithm, ciphertext: Uint8Array, secretKey: Uint8Array) => Uint8Array;
 };
-export declare const encapsulateXWingDeterministicallyForTest: (algorithm: ReallyMeKemAlgorithm, publicKey: Uint8Array, seed: Uint8Array) => ReallyMeXWingEncapsulation;
-export declare const encapsulateXWingDeterministicallyWithProviderForTest: (provider: ReallyMeWasmProvider, algorithm: ReallyMeKemAlgorithm, publicKey: Uint8Array, seed: Uint8Array) => ReallyMeXWingEncapsulation;