@zapo-js/fake-server 0.3.0 → 1.1.0

package/dist/protocol/iq/privacy.d.ts

@@ -19,4 +19,3 @@ export declare function parseBlocklistChangeIq(iq: BinaryNode): {
     readonly action: 'block' | 'unblock';
 } | null;
 export declare function parsePrivacyDisallowedListGetIq(iq: BinaryNode): FakePrivacyCategoryName | null;
-//# sourceMappingURL=privacy.d.ts.map

package/dist/protocol/iq/privacy.js

@@ -9,8 +9,8 @@ exports.parsePrivacySetCategoryIq = parsePrivacySetCategoryIq;
 exports.parseBlocklistChangeIq = parseBlocklistChangeIq;
 exports.parsePrivacyDisallowedListGetIq = parsePrivacyDisallowedListGetIq;
 const router_1 = require("./router");
-exports.FAKE_DEFAULT_PRIVACY_SETTINGS = {
-    settings: {
+exports.FAKE_DEFAULT_PRIVACY_SETTINGS = Object.freeze({
+    settings: Object.freeze({
         readreceipts: 'all',
         last: 'all',
         online: 'all',
@@ -20,19 +20,19 @@ exports.FAKE_DEFAULT_PRIVACY_SETTINGS = {
         calladd: 'all',
         messages: 'all',
         defense: 'off'
-    },
-    disallowed: {
-        readreceipts: [],
-        last: [],
-        online: [],
-        profile: [],
-        status: [],
-        groupadd: [],
-        calladd: [],
-        messages: [],
-        defense: []
-    }
-};
+    }),
+    disallowed: Object.freeze({
+        readreceipts: Object.freeze([]),
+        last: Object.freeze([]),
+        online: Object.freeze([]),
+        profile: Object.freeze([]),
+        status: Object.freeze([]),
+        groupadd: Object.freeze([]),
+        calladd: Object.freeze([]),
+        messages: Object.freeze([]),
+        defense: Object.freeze([])
+    })
+});
 function buildPrivacySettingsResult(iq, state) {
     const result = (0, router_1.buildIqResult)(iq);
     return {
@@ -130,4 +130,3 @@ function parsePrivacyDisallowedListGetIq(iq) {
     const name = list.attrs.name;
     return name ?? null;
 }
-//# sourceMappingURL=privacy.js.map

package/dist/protocol/iq/profile.d.ts

@@ -19,4 +19,3 @@ export declare function parseSetProfilePictureIq(iq: BinaryNode): {
 export declare function parseSetStatusIq(iq: BinaryNode): {
     readonly text: string;
 } | null;
-//# sourceMappingURL=profile.d.ts.map

package/dist/protocol/iq/profile.js

@@ -77,4 +77,3 @@ function parseSetStatusIq(iq) {
     }
     return { text: '' };
 }
-//# sourceMappingURL=profile.js.map

package/dist/protocol/iq/router.d.ts

@@ -7,7 +7,13 @@ export interface WaFakeIqMatcher {
     readonly xmlns?: string;
     readonly childTag?: string;
 }
-export type WaFakeIqResponder = (iq: BinaryNode) => BinaryNode | Promise<BinaryNode>;
+/**
+ * Returns the response stanza, or `null` to fall through: the router keeps
+ * scanning lower-priority handlers as if this one had not matched. Lets a
+ * high-priority handler observe an IQ (capture, log, assert) while the
+ * default handler still answers it.
+ */
+export type WaFakeIqResponder = (iq: BinaryNode) => BinaryNode | null | Promise<BinaryNode | null>;
 export interface WaFakeIqHandler {
     readonly matcher: WaFakeIqMatcher;
     readonly respond: WaFakeIqResponder;
@@ -36,4 +42,3 @@ export declare function buildIqError(inbound: BinaryNode, options: {
     readonly text?: string;
     readonly from?: string;
 }): BinaryNode;
-//# sourceMappingURL=router.d.ts.map

package/dist/protocol/iq/router.js

@@ -30,12 +30,18 @@ class WaFakeIqRouter {
         }
         for (const handler of this.highPriorityHandlers) {
             if (matches(iq, handler.matcher)) {
-                return handler.respond(iq);
+                const response = await handler.respond(iq);
+                if (response !== null) {
+                    return response;
+                }
             }
         }
         for (const handler of this.handlers) {
             if (matches(iq, handler.matcher)) {
-                return handler.respond(iq);
+                const response = await handler.respond(iq);
+                if (response !== null) {
+                    return response;
+                }
             }
         }
         this.events.onUnhandled?.(iq);
@@ -115,4 +121,3 @@ function buildIqError(inbound, options) {
         ]
     };
 }
-//# sourceMappingURL=router.js.map

package/dist/protocol/iq/usync.d.ts

@@ -5,4 +5,3 @@ export interface UsyncUserDevicesResult {
     readonly deviceIds?: readonly number[];
 }
 export declare function buildUsyncDevicesResult(inboundIq: BinaryNode, users: readonly UsyncUserDevicesResult[]): BinaryNode;
-//# sourceMappingURL=usync.d.ts.map

package/dist/protocol/iq/usync.js

@@ -65,4 +65,3 @@ function extractUsyncSid(iq) {
     }
     return undefined;
 }
-//# sourceMappingURL=usync.js.map

package/dist/protocol/push/app-state-key-share.d.ts

@@ -14,4 +14,3 @@ export interface BuildAppStateSyncKeyShareInput {
     readonly keys: readonly FakeAppStateSyncKey[];
 }
 export declare function buildAppStateSyncKeyShareMessage(input: BuildAppStateSyncKeyShareInput): proto.IMessage;
-//# sourceMappingURL=app-state-key-share.d.ts.map

package/dist/protocol/push/app-state-key-share.js

@@ -27,4 +27,3 @@ function buildAppStateSyncKeyShareMessage(input) {
         }
     };
 }
-//# sourceMappingURL=app-state-key-share.js.map

package/dist/protocol/push/call-failure.d.ts

@@ -13,4 +13,3 @@ export interface BuildFailureInput {
     readonly extraAttrs?: Readonly<Record<string, string>>;
 }
 export declare function buildFailure(input: BuildFailureInput): BinaryNode;
-//# sourceMappingURL=call-failure.d.ts.map

package/dist/protocol/push/call-failure.js

@@ -29,4 +29,3 @@ function buildFailure(input) {
         attrs
     };
 }
-//# sourceMappingURL=call-failure.js.map

package/dist/protocol/push/chatstate.d.ts

@@ -12,4 +12,3 @@ export interface BuildChatstateInput {
     readonly state: FakeChatstateState;
 }
 export declare function buildChatstate(input: BuildChatstateInput): BinaryNode;
-//# sourceMappingURL=chatstate.d.ts.map

package/dist/protocol/push/chatstate.js

@@ -24,4 +24,3 @@ function buildChatstate(input) {
         content: [stateChild]
     };
 }
-//# sourceMappingURL=chatstate.js.map

package/dist/protocol/push/error-stanza.d.ts

@@ -5,4 +5,3 @@ export interface BuildIncomingErrorStanzaInput {
     readonly from?: string;
 }
 export declare function buildIncomingErrorStanza(input: BuildIncomingErrorStanzaInput): BinaryNode;
-//# sourceMappingURL=error-stanza.d.ts.map

package/dist/protocol/push/error-stanza.js

@@ -14,4 +14,3 @@ function buildIncomingErrorStanza(input) {
         attrs
     };
 }
-//# sourceMappingURL=error-stanza.js.map

package/dist/protocol/push/history-sync.d.ts

@@ -43,4 +43,3 @@ export interface BuildHistorySyncExternalInput {
 export declare function buildHistorySyncMessage(input?: BuildHistorySyncInput): Promise<proto.IMessage>;
 export declare function encodeHistorySyncPlaintext(input?: BuildHistorySyncInput): Promise<Uint8Array>;
 export declare function buildHistorySyncExternalMessage(input: BuildHistorySyncExternalInput): proto.IMessage;
-//# sourceMappingURL=history-sync.d.ts.map

package/dist/protocol/push/history-sync.js

@@ -114,4 +114,3 @@ function buildHistorySyncExternalMessage(input) {
         }
     };
 }
-//# sourceMappingURL=history-sync.js.map

package/dist/protocol/push/message.d.ts

@@ -18,4 +18,3 @@ export interface BuildMessageInput {
     readonly extraChildren?: readonly BinaryNode[];
 }
 export declare function buildMessage(input: BuildMessageInput): BinaryNode;
-//# sourceMappingURL=message.d.ts.map

package/dist/protocol/push/message.js

@@ -39,4 +39,3 @@ function buildMessage(input) {
         content: children
     };
 }
-//# sourceMappingURL=message.js.map

package/dist/protocol/push/notification.d.ts

@@ -18,4 +18,3 @@ export interface BuildGroupNotificationInput {
     readonly children: readonly BinaryNode[];
 }
 export declare function buildGroupNotification(input: BuildGroupNotificationInput): BinaryNode;
-//# sourceMappingURL=notification.d.ts.map

package/dist/protocol/push/notification.js

@@ -31,4 +31,3 @@ function buildGroupNotification(input) {
         content: input.children
     });
 }
-//# sourceMappingURL=notification.js.map

package/dist/protocol/push/presence.d.ts

@@ -8,4 +8,3 @@ export interface BuildIncomingPresenceInput {
     readonly last?: number | FakePresenceLastSentinel;
 }
 export declare function buildIncomingPresence(input: BuildIncomingPresenceInput): BinaryNode;
-//# sourceMappingURL=presence.d.ts.map

package/dist/protocol/push/presence.js

@@ -15,4 +15,3 @@ function buildIncomingPresence(input) {
         attrs
     };
 }
-//# sourceMappingURL=presence.js.map

package/dist/protocol/push/receipt.d.ts

@@ -11,4 +11,3 @@ export interface BuildReceiptInput {
     readonly content?: readonly BinaryNode[];
 }
 export declare function buildReceipt(input: BuildReceiptInput): BinaryNode;
-//# sourceMappingURL=receipt.d.ts.map

package/dist/protocol/push/receipt.js

@@ -22,4 +22,3 @@ function buildReceipt(input) {
         ...(input.content ? { content: input.content } : {})
     };
 }
-//# sourceMappingURL=receipt.js.map

package/dist/protocol/signal/fake-app-state-crypto.d.ts

@@ -1,13 +1,12 @@
 /** App-state crypto helpers mirrored from WhatsApp Web behavior. */
-import { type CryptoKey } from '../../transport/crypto';
 import { type Proto } from '../../transport/protos';
-export declare const APP_STATE_EMPTY_LT_HASH: Uint8Array<ArrayBuffer>;
+export declare const APP_STATE_EMPTY_LT_HASH: Readonly<Uint8Array>;
 export interface FakeAppStateDerivedKeys {
-    readonly indexHmacKey: CryptoKey;
-    readonly valueEncryptionAesKey: CryptoKey;
-    readonly valueMacHmacKey: CryptoKey;
-    readonly snapshotMacHmacKey: CryptoKey;
-    readonly patchMacHmacKey: CryptoKey;
+    readonly indexHmacKey: Uint8Array;
+    readonly valueEncryptionAesKey: Uint8Array;
+    readonly valueMacHmacKey: Uint8Array;
+    readonly snapshotMacHmacKey: Uint8Array;
+    readonly patchMacHmacKey: Uint8Array;
 }
 export interface FakeAppStateEncryptedMutation {
     readonly indexMac: Uint8Array;
@@ -24,7 +23,7 @@ export interface FakeAppStateMutationInput {
     readonly iv?: Uint8Array;
 }
 export declare class FakeAppStateCrypto {
-    deriveKeys(keyData: Uint8Array): Promise<FakeAppStateDerivedKeys>;
+    deriveKeys(keyData: Uint8Array): FakeAppStateDerivedKeys;
     encryptMutation(input: FakeAppStateMutationInput): Promise<FakeAppStateEncryptedMutation>;
     decryptMutation(input: {
         readonly operation: 'set' | 'remove';
@@ -46,4 +45,3 @@ export declare class FakeAppStateCrypto {
     private ltHashApply;
     private generateValueMac;
 }
-//# sourceMappingURL=fake-app-state-crypto.d.ts.map

package/dist/protocol/signal/fake-app-state-crypto.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FakeAppStateCrypto = exports.APP_STATE_EMPTY_LT_HASH = void 0;
 const crypto_1 = require("../../transport/crypto");
 const protos_1 = require("../../transport/protos");
+const util_1 = require("../../transport/util");
 const APP_STATE_DERIVED_KEY_LENGTH = 160;
 const APP_STATE_DERIVED_INDEX_KEY_END = 32;
 const APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END = 64;
@@ -15,29 +16,22 @@ const APP_STATE_MAC_OCTET_LENGTH = 8;
 const APP_STATE_IV_LENGTH = 16;
 const APP_STATE_LT_HASH_SIZE = 128;
 const APP_STATE_POINT_SIZE = 2;
-const KDF_INFO_MUTATION_KEYS = 'WhatsApp Mutation Keys';
-const KDF_INFO_PATCH_INTEGRITY = 'WhatsApp Patch Integrity';
+const KDF_INFO_MUTATION_KEYS = util_1.TEXT_ENCODER.encode('WhatsApp Mutation Keys');
+const KDF_INFO_PATCH_INTEGRITY = util_1.TEXT_ENCODER.encode('WhatsApp Patch Integrity');
 exports.APP_STATE_EMPTY_LT_HASH = new Uint8Array(APP_STATE_LT_HASH_SIZE);
 class FakeAppStateCrypto {
-    async deriveKeys(keyData) {
-        const derived = await (0, crypto_1.hkdf)(keyData, null, KDF_INFO_MUTATION_KEYS, APP_STATE_DERIVED_KEY_LENGTH);
-        const [indexHmacKey, valueEncryptionAesKey, valueMacHmacKey, snapshotMacHmacKey, patchMacHmacKey] = await Promise.all([
-            (0, crypto_1.importHmacKey)(derived.subarray(0, APP_STATE_DERIVED_INDEX_KEY_END)),
-            (0, crypto_1.importAesCbcKey)(derived.subarray(APP_STATE_DERIVED_INDEX_KEY_END, APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END)),
-            (0, crypto_1.importHmacSha512Key)(derived.subarray(APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, APP_STATE_DERIVED_VALUE_MAC_KEY_END)),
-            (0, crypto_1.importHmacKey)(derived.subarray(APP_STATE_DERIVED_VALUE_MAC_KEY_END, APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END)),
-            (0, crypto_1.importHmacKey)(derived.subarray(APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, APP_STATE_DERIVED_PATCH_MAC_KEY_END))
-        ]);
+    deriveKeys(keyData) {
+        const derived = (0, crypto_1.hkdf)(keyData, null, KDF_INFO_MUTATION_KEYS, APP_STATE_DERIVED_KEY_LENGTH);
         return {
-            indexHmacKey,
-            valueEncryptionAesKey,
-            valueMacHmacKey,
-            snapshotMacHmacKey,
-            patchMacHmacKey
+            indexHmacKey: derived.subarray(0, APP_STATE_DERIVED_INDEX_KEY_END),
+            valueEncryptionAesKey: derived.subarray(APP_STATE_DERIVED_INDEX_KEY_END, APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END),
+            valueMacHmacKey: derived.subarray(APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, APP_STATE_DERIVED_VALUE_MAC_KEY_END),
+            snapshotMacHmacKey: derived.subarray(APP_STATE_DERIVED_VALUE_MAC_KEY_END, APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END),
+            patchMacHmacKey: derived.subarray(APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, APP_STATE_DERIVED_PATCH_MAC_KEY_END)
         };
     }
     async encryptMutation(input) {
-        const derivedKeys = await this.deriveKeys(input.keyData);
+        const derivedKeys = this.deriveKeys(input.keyData);
         const indexBytes = new TextEncoder().encode(input.index);
         const encoded = protos_1.proto.SyncActionData.encode({
             index: indexBytes,
@@ -49,33 +43,34 @@ class FakeAppStateCrypto {
         if (iv.byteLength !== APP_STATE_IV_LENGTH) {
             throw new Error(`invalid IV length ${iv.byteLength}`);
         }
-        const indexMac = await (0, crypto_1.hmacSign)(derivedKeys.indexHmacKey, indexBytes);
-        const cipherText = await (0, crypto_1.aesCbcEncrypt)(derivedKeys.valueEncryptionAesKey, iv, encoded);
+        const indexMac = (0, crypto_1.hmacSha256Sign)(derivedKeys.indexHmacKey, indexBytes);
+        const cipherText = (0, crypto_1.aesCbcEncrypt)(derivedKeys.valueEncryptionAesKey, iv, encoded);
         const cipherWithIv = concatBytes([iv, cipherText]);
         const associatedData = generateAssociatedData(input.operation, input.keyId);
-        const valueMac = await this.generateValueMac(derivedKeys.valueMacHmacKey, associatedData, cipherWithIv);
+        const valueMac = this.generateValueMac(derivedKeys.valueMacHmacKey, associatedData, cipherWithIv);
         return {
             indexMac,
             valueBlob: concatBytes([cipherWithIv, valueMac]),
             valueMac
         };
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async decryptMutation(input) {
         if (input.valueBlob.byteLength < APP_STATE_IV_LENGTH + APP_STATE_VALUE_MAC_LENGTH) {
             throw new Error('invalid mutation value blob');
         }
-        const derivedKeys = await this.deriveKeys(input.keyData);
+        const derivedKeys = this.deriveKeys(input.keyData);
         const iv = input.valueBlob.subarray(0, APP_STATE_IV_LENGTH);
         const macStart = input.valueBlob.byteLength - APP_STATE_VALUE_MAC_LENGTH;
         const valueMac = input.valueBlob.subarray(macStart);
         const cipherText = input.valueBlob.subarray(APP_STATE_IV_LENGTH, macStart);
         const cipherWithIv = input.valueBlob.subarray(0, macStart);
         const associatedData = generateAssociatedData(input.operation, input.keyId);
-        const expectedMac = await this.generateValueMac(derivedKeys.valueMacHmacKey, associatedData, cipherWithIv);
+        const expectedMac = this.generateValueMac(derivedKeys.valueMacHmacKey, associatedData, cipherWithIv);
         if (!uint8Equal(expectedMac, valueMac)) {
             throw new Error('mutation value MAC mismatch');
         }
-        const plaintext = await (0, crypto_1.aesCbcDecrypt)(derivedKeys.valueEncryptionAesKey, iv, cipherText);
+        const plaintext = (0, crypto_1.aesCbcDecrypt)(derivedKeys.valueEncryptionAesKey, iv, cipherText);
         const syncActionData = protos_1.proto.SyncActionData.decode(plaintext);
         if (!syncActionData.index) {
             throw new Error('missing sync action index');
@@ -83,7 +78,7 @@ class FakeAppStateCrypto {
         if (syncActionData.version === null || syncActionData.version === undefined) {
             throw new Error('missing sync action version');
         }
-        const generatedIndexMac = await (0, crypto_1.hmacSign)(derivedKeys.indexHmacKey, syncActionData.index);
+        const generatedIndexMac = (0, crypto_1.hmacSha256Sign)(derivedKeys.indexHmacKey, syncActionData.index);
         if (!uint8Equal(generatedIndexMac, input.indexMac)) {
             throw new Error('mutation index MAC mismatch');
         }
@@ -95,36 +90,40 @@ class FakeAppStateCrypto {
             valueMac
         };
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async generateSnapshotMac(keyData, ltHash, version, collectionName) {
-        const derivedKeys = await this.deriveKeys(keyData);
+        const derivedKeys = this.deriveKeys(keyData);
         const payload = concatBytes([
             ltHash,
             intToBytesBe(8, version),
             new TextEncoder().encode(collectionName)
         ]);
-        return (0, crypto_1.hmacSign)(derivedKeys.snapshotMacHmacKey, payload);
+        return (0, crypto_1.hmacSha256Sign)(derivedKeys.snapshotMacHmacKey, payload);
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async generatePatchMac(keyData, snapshotMac, valueMacs, version, collectionName) {
-        const derivedKeys = await this.deriveKeys(keyData);
+        const derivedKeys = this.deriveKeys(keyData);
         const payload = concatBytes([
             snapshotMac,
             ...valueMacs,
             intToBytesBe(8, version),
             new TextEncoder().encode(collectionName)
         ]);
-        return (0, crypto_1.hmacSign)(derivedKeys.patchMacHmacKey, payload);
+        return (0, crypto_1.hmacSha256Sign)(derivedKeys.patchMacHmacKey, payload);
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async ltHashAdd(base, addValues) {
         return this.ltHashApply(base, addValues, (left, right) => left + right);
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async ltHashSubtract(base, removeValues) {
         return this.ltHashApply(base, removeValues, (left, right) => left - right);
     }
-    async ltHashApply(base, values, combine) {
+    ltHashApply(base, values, combine) {
         if (values.length === 0) {
             return base.slice();
         }
-        const expandedValues = await Promise.all(values.map((value) => (0, crypto_1.hkdf)(value, null, KDF_INFO_PATCH_INTEGRITY, APP_STATE_LT_HASH_SIZE)));
+        const expandedValues = values.map((value) => (0, crypto_1.hkdf)(value, null, KDF_INFO_PATCH_INTEGRITY, APP_STATE_LT_HASH_SIZE));
         const out = new Uint8Array(base.byteLength);
         pointwise(base, expandedValues[0], combine, out);
         for (let index = 1; index < expandedValues.length; index += 1) {
@@ -132,10 +131,10 @@ class FakeAppStateCrypto {
         }
         return out;
     }
-    async generateValueMac(valueMacHmacKey, associatedData, cipherWithIv) {
+    generateValueMac(valueMacHmacKey, associatedData, cipherWithIv) {
         const octetLength = new Uint8Array(APP_STATE_MAC_OCTET_LENGTH);
         octetLength[octetLength.length - 1] = associatedData.byteLength & 0xff;
-        const full = await (0, crypto_1.hmacSign)(valueMacHmacKey, concatBytes([associatedData, cipherWithIv, octetLength]));
+        const full = (0, crypto_1.hmacSha512Sign)(valueMacHmacKey, concatBytes([associatedData, cipherWithIv, octetLength]));
         return full.subarray(0, APP_STATE_VALUE_MAC_LENGTH);
     }
 }
@@ -199,4 +198,3 @@ function concatBytes(parts) {
     }
     return out;
 }
-//# sourceMappingURL=fake-app-state-crypto.js.map

package/dist/protocol/signal/fake-peer-double-ratchet.d.ts

@@ -35,4 +35,3 @@ export declare class FakePeerDoubleRatchet {
     private runRecvRatchetStep;
     private rotateSendRatchet;
 }
-//# sourceMappingURL=fake-peer-double-ratchet.d.ts.map

package/dist/protocol/signal/fake-peer-double-ratchet.js

@@ -4,11 +4,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FakePeerDoubleRatchet = exports.FakePeerDoubleRatchetError = void 0;
 const crypto_1 = require("../../transport/crypto");
 const protos_1 = require("../../transport/protos");
+const util_1 = require("../../transport/util");
 const SIGNAL_VERSION = 3;
 const SIGNAL_MAC_SIZE = 8;
 const SIGNAL_PREFIX_FF = new Uint8Array(32).fill(0xff);
 const MESSAGE_KEY_LABEL = new Uint8Array([1]);
 const CHAIN_KEY_LABEL = new Uint8Array([2]);
+const WHISPER_TEXT_INFO = util_1.TEXT_ENCODER.encode('WhisperText');
+const WHISPER_RATCHET_INFO = util_1.TEXT_ENCODER.encode('WhisperRatchet');
+const WHISPER_MESSAGE_KEYS_INFO = util_1.TEXT_ENCODER.encode('WhisperMessageKeys');
 class FakePeerDoubleRatchetError extends Error {
     constructor(message) {
         super(message);
@@ -58,11 +62,11 @@ class FakePeerDoubleRatchet {
         if (dh4)
             sharedParts.push(dh4);
         const shared = concatBytes(sharedParts);
-        const [rootKey, _chainKey] = await (0, crypto_1.hkdfSplit)(shared, null, 'WhisperText');
+        const [rootKey, _chainKey] = (0, crypto_1.hkdfSplit)(shared, null, WHISPER_TEXT_INFO);
         void _chainKey;
         const sendRatchet = await crypto_1.X25519.generateKeyPair();
         const ratchetSecret = await crypto_1.X25519.scalarMult(sendRatchet.privKey, (0, crypto_1.toRawPubKey)(remoteSigned));
-        const [nextRootKey, sendChainKey] = await (0, crypto_1.hkdfSplit)(ratchetSecret, rootKey, 'WhisperRatchet');
+        const [nextRootKey, sendChainKey] = (0, crypto_1.hkdfSplit)(ratchetSecret, rootKey, WHISPER_RATCHET_INFO);
         this.rootKey = nextRootKey;
         this.remoteIdentityPubSerialized = remoteIdentity;
         this.sendChain = {
@@ -78,6 +82,7 @@ class FakePeerDoubleRatchet {
             baseKey: localBaseSerialized
         };
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async encrypt(plaintext) {
         if (!this.sendChain) {
             throw new FakePeerDoubleRatchetError('cannot encrypt: session has no send chain (call initiateOutbound first)');
@@ -85,12 +90,8 @@ class FakePeerDoubleRatchet {
         if (!this.remoteIdentityPubSerialized) {
             throw new FakePeerDoubleRatchetError('remote identity not set');
         }
-        const { nextChainKey, messageKey } = await deriveMessageKey(this.sendChain.nextIndex, this.sendChain.chainKey);
-        const [cipherKey, macKey] = await Promise.all([
-            (0, crypto_1.importAesCbcKey)(messageKey.cipherKey),
-            (0, crypto_1.importHmacKey)(messageKey.macKey)
-        ]);
-        const ciphertext = await (0, crypto_1.aesCbcEncrypt)(cipherKey, messageKey.iv, plaintext);
+        const { nextChainKey, messageKey } = deriveMessageKey(this.sendChain.nextIndex, this.sendChain.chainKey);
+        const ciphertext = (0, crypto_1.aesCbcEncrypt)(messageKey.cipherKey, messageKey.iv, plaintext);
         const signalPayload = protos_1.proto.SignalMessage.encode({
             ratchetKey: this.sendChain.ratchetPubSerialized,
             counter: messageKey.index,
@@ -103,7 +104,7 @@ class FakePeerDoubleRatchet {
             this.remoteIdentityPubSerialized,
             versioned
         ]);
-        const fullMac = await (0, crypto_1.hmacSign)(macKey, macInput);
+        const fullMac = (0, crypto_1.hmacSha256Sign)(messageKey.macKey, macInput);
         const mac = fullMac.subarray(0, SIGNAL_MAC_SIZE);
         const inner = concatBytes([versioned, mac]);
         this.sendChain = {
@@ -167,7 +168,7 @@ class FakePeerDoubleRatchet {
         if (dh4)
             sharedParts.push(dh4);
         const shared = concatBytes(sharedParts);
-        const [rootKey, chainKey] = await (0, crypto_1.hkdfSplit)(shared, null, 'WhisperText');
+        const [rootKey, chainKey] = (0, crypto_1.hkdfSplit)(shared, null, WHISPER_TEXT_INFO);
         this.remoteIdentityPubSerialized = (0, crypto_1.toSerializedPubKey)(remoteIdentity);
         this.rootKey = rootKey;
         this.bootstrapChainKey = chainKey;
@@ -201,7 +202,7 @@ class FakePeerDoubleRatchet {
                 throw new FakePeerDoubleRatchetError('bootstrap state missing');
             }
             const ratchetShared = await crypto_1.X25519.scalarMult(this.keyBundle.signedPreKey.keyPair.privKey, (0, crypto_1.toRawPubKey)(ratchetKey));
-            const [nextRootKey, recvChainKey] = await (0, crypto_1.hkdfSplit)(ratchetShared, this.rootKey, 'WhisperRatchet');
+            const [nextRootKey, recvChainKey] = (0, crypto_1.hkdfSplit)(ratchetShared, this.rootKey, WHISPER_RATCHET_INFO);
             this.rootKey = nextRootKey;
             this.bootstrapChainKey = null;
             this.recvChain = {
@@ -247,7 +248,7 @@ class FakePeerDoubleRatchet {
             const newlyStashed = [];
             let walkIndex = this.recvChain.nextIndex;
             while (walkIndex <= counter) {
-                const derived = await deriveMessageKeyFromChain(chainKey);
+                const derived = deriveMessageKeyFromChain(chainKey);
                 chainKey = derived.nextChainKey;
                 if (walkIndex === counter) {
                     messageKey = derived.messageKey;
@@ -284,14 +285,12 @@ class FakePeerDoubleRatchet {
             this.localIdentityPubSerialized,
             versionedBody
         ]);
-        const macKeyHandle = await (0, crypto_1.importHmacKey)(messageKey.macKey);
-        const expectedFullMac = await (0, crypto_1.hmacSign)(macKeyHandle, macInput);
+        const expectedFullMac = (0, crypto_1.hmacSha256Sign)(messageKey.macKey, macInput);
         const expectedMac = expectedFullMac.subarray(0, SIGNAL_MAC_SIZE);
         if (!uint8Equal(expectedMac, macBytes)) {
             throw new FakePeerDoubleRatchetError('signal message MAC mismatch');
         }
-        const cipherKeyHandle = await (0, crypto_1.importAesCbcKey)(messageKey.cipherKey);
-        const padded = await (0, crypto_1.aesCbcDecrypt)(cipherKeyHandle, messageKey.iv, ciphertext);
+        const padded = (0, crypto_1.aesCbcDecrypt)(messageKey.cipherKey, messageKey.iv, ciphertext);
         return unpadPkcs7(padded);
     }
     async runRecvRatchetStep(remoteRatchetPub) {
@@ -303,7 +302,7 @@ class FakePeerDoubleRatchet {
         }
         const remoteRatchetRaw = (0, crypto_1.toRawPubKey)(remoteRatchetPub);
         const ratchetShared = await crypto_1.X25519.scalarMult(this.sendChain.ratchetKeyPair.privKey, remoteRatchetRaw);
-        const [nextRootKey, recvChainKey] = await (0, crypto_1.hkdfSplit)(ratchetShared, this.rootKey, 'WhisperRatchet');
+        const [nextRootKey, recvChainKey] = (0, crypto_1.hkdfSplit)(ratchetShared, this.rootKey, WHISPER_RATCHET_INFO);
         this.rootKey = nextRootKey;
         this.recvChain = {
             ratchetPubKey: (0, crypto_1.toSerializedPubKey)(remoteRatchetPub),
@@ -319,7 +318,7 @@ class FakePeerDoubleRatchet {
         }
         const newRatchet = await crypto_1.X25519.generateKeyPair();
         const ratchetShared = await crypto_1.X25519.scalarMult(newRatchet.privKey, (0, crypto_1.toRawPubKey)(remoteRatchetPub));
-        const [nextRootKey, sendChainKey] = await (0, crypto_1.hkdfSplit)(ratchetShared, this.rootKey, 'WhisperRatchet');
+        const [nextRootKey, sendChainKey] = (0, crypto_1.hkdfSplit)(ratchetShared, this.rootKey, WHISPER_RATCHET_INFO);
         this.rootKey = nextRootKey;
         this.sendChain = {
             ratchetKeyPair: newRatchet,
@@ -331,13 +330,10 @@ class FakePeerDoubleRatchet {
     }
 }
 exports.FakePeerDoubleRatchet = FakePeerDoubleRatchet;
-async function deriveMessageKey(index, chainKey) {
-    const hmacKey = await (0, crypto_1.importHmacKey)(chainKey);
-    const [messageInputKey, nextChainRaw] = await Promise.all([
-        (0, crypto_1.hmacSign)(hmacKey, MESSAGE_KEY_LABEL),
-        (0, crypto_1.hmacSign)(hmacKey, CHAIN_KEY_LABEL)
-    ]);
-    const expanded = await (0, crypto_1.hkdf)(messageInputKey, null, 'WhisperMessageKeys', 80);
+function deriveMessageKey(index, chainKey) {
+    const messageInputKey = (0, crypto_1.hmacSha256Sign)(chainKey, MESSAGE_KEY_LABEL);
+    const nextChainRaw = (0, crypto_1.hmacSha256Sign)(chainKey, CHAIN_KEY_LABEL);
+    const expanded = (0, crypto_1.hkdf)(messageInputKey, null, WHISPER_MESSAGE_KEYS_INFO, 80);
     return {
         nextChainKey: nextChainRaw.subarray(0, 32),
         messageKey: {
@@ -348,8 +344,8 @@ async function deriveMessageKey(index, chainKey) {
         }
     };
 }
-async function deriveMessageKeyFromChain(chainKey) {
-    const result = await deriveMessageKey(0, chainKey);
+function deriveMessageKeyFromChain(chainKey) {
+    const result = deriveMessageKey(0, chainKey);
     return {
         nextChainKey: result.nextChainKey,
         messageKey: {
@@ -405,4 +401,3 @@ function requireBytes(value, label) {
         throw new FakePeerDoubleRatchetError(`${label} missing`);
     return value;
 }
-//# sourceMappingURL=fake-peer-double-ratchet.js.map

package/dist/protocol/signal/fake-peer-group-recv-session.d.ts

@@ -7,4 +7,3 @@ export declare class FakePeerGroupRecvSession {
     addDistribution(groupId: string, senderJid: string, axolotlBytes: Uint8Array): void;
     decryptGroupMessage(groupId: string, senderJid: string, skmsgBytes: Uint8Array): Promise<Uint8Array>;
 }
-//# sourceMappingURL=fake-peer-group-recv-session.d.ts.map