@neykoor/libsignal-node 1.0.1

package/lib/numeric-fingerprint.js

@@ -0,0 +1,54 @@
+import * as crypto from './crypto.js';
+const VERSION = 0;
+function iterateHash(data, key, count) {
+    let result = Buffer.from(data);
+    for (let i = 0; i < count; i++) {
+        const combined = Buffer.concat([result, Buffer.from(key)]);
+        result = crypto.hash(combined);
+    }
+    return new Uint8Array(result).buffer;
+}
+function shortToArrayBuffer(number) {
+    return new Uint16Array([number]).buffer;
+}
+function getEncodedChunk(hash, offset) {
+    const chunk = (hash[offset] * Math.pow(2, 32) +
+        hash[offset + 1] * Math.pow(2, 24) +
+        hash[offset + 2] * Math.pow(2, 16) +
+        hash[offset + 3] * Math.pow(2, 8) +
+        hash[offset + 4]) %
+        100000;
+    let s = chunk.toString();
+    while (s.length < 5) {
+        s = '0' + s;
+    }
+    return s;
+}
+async function getDisplayStringFor(identifier, key, iterations) {
+    const bytes = Buffer.concat([Buffer.from(shortToArrayBuffer(VERSION)), Buffer.from(key), Buffer.from(identifier)]);
+    const arraybuf = new Uint8Array(bytes).buffer;
+    const output = new Uint8Array(iterateHash(arraybuf, key, iterations));
+    return (getEncodedChunk(output, 0) +
+        getEncodedChunk(output, 5) +
+        getEncodedChunk(output, 10) +
+        getEncodedChunk(output, 15) +
+        getEncodedChunk(output, 20) +
+        getEncodedChunk(output, 25));
+}
+export class FingerprintGenerator {
+    constructor(iterations) {
+        this.iterations = iterations;
+    }
+    createFor(localIdentifier, localIdentityKey, remoteIdentifier, remoteIdentityKey) {
+        if (typeof localIdentifier !== 'string' ||
+            typeof remoteIdentifier !== 'string' ||
+            !(localIdentityKey instanceof ArrayBuffer) ||
+            !(remoteIdentityKey instanceof ArrayBuffer)) {
+            throw new Error('Invalid arguments');
+        }
+        return Promise.all([
+            getDisplayStringFor(localIdentifier, localIdentityKey, this.iterations),
+            getDisplayStringFor(remoteIdentifier, remoteIdentityKey, this.iterations)
+        ]).then(fingerprints => fingerprints.sort().join(''));
+    }
+}

package/lib/prekey-bundle-validator.d.ts

@@ -0,0 +1,2 @@
+import type { DeviceKeyBundle } from './types.js';
+export declare function assertValidDeviceKeyBundle(bundle: DeviceKeyBundle): void;

package/lib/prekey-bundle-validator.js

@@ -0,0 +1,44 @@
+import { PreKeyError } from './errors.js';
+const MIN_REGISTRATION_ID = 1;
+const MAX_REGISTRATION_ID = 0x3fff;
+const IDENTITY_KEY_LENGTH = 33;
+const PUBLIC_KEY_LENGTH = 33;
+const SIGNATURE_LENGTH = 64;
+const MAX_KEY_ID = 0xffffff;
+function isNonNegativeInteger(n) {
+    return typeof n === 'number' && Number.isInteger(n) && n >= 0;
+}
+function assertBufferLength(value, length, field) {
+    if (!(value instanceof Uint8Array)) {
+        throw new PreKeyError(`${field} must be a Uint8Array`);
+    }
+    if (value.byteLength !== length) {
+        throw new PreKeyError(`${field} has invalid length: expected ${length}, got ${value.byteLength}`);
+    }
+}
+function assertKeyId(value, field) {
+    if (!isNonNegativeInteger(value) || value > MAX_KEY_ID) {
+        throw new PreKeyError(`${field} is out of range: ${String(value)}`);
+    }
+}
+export function assertValidDeviceKeyBundle(bundle) {
+    if (!bundle || typeof bundle !== 'object') {
+        throw new PreKeyError('Device key bundle must be an object');
+    }
+    if (!isNonNegativeInteger(bundle.registrationId) ||
+        bundle.registrationId < MIN_REGISTRATION_ID ||
+        bundle.registrationId > MAX_REGISTRATION_ID) {
+        throw new PreKeyError(`Invalid registrationId: ${String(bundle.registrationId)}`);
+    }
+    assertBufferLength(bundle.identityKey, IDENTITY_KEY_LENGTH, 'identityKey');
+    if (!bundle.signedPreKey || typeof bundle.signedPreKey !== 'object') {
+        throw new PreKeyError('Missing signedPreKey');
+    }
+    assertKeyId(bundle.signedPreKey.keyId, 'signedPreKey.keyId');
+    assertBufferLength(bundle.signedPreKey.publicKey, PUBLIC_KEY_LENGTH, 'signedPreKey.publicKey');
+    assertBufferLength(bundle.signedPreKey.signature, SIGNATURE_LENGTH, 'signedPreKey.signature');
+    if (bundle.preKey) {
+        assertKeyId(bundle.preKey.keyId, 'preKey.keyId');
+        assertBufferLength(bundle.preKey.publicKey, PUBLIC_KEY_LENGTH, 'preKey.publicKey');
+    }
+}

package/lib/protobufs.d.ts

@@ -0,0 +1,5 @@
+import { textsecure } from './whisper-text-protocol.js';
+export declare const WhisperMessage: typeof textsecure.WhisperMessage;
+export declare const PreKeyWhisperMessage: typeof textsecure.PreKeyWhisperMessage;
+export type WhisperMessage = textsecure.WhisperMessage;
+export type PreKeyWhisperMessage = textsecure.PreKeyWhisperMessage;

package/lib/protobufs.js

@@ -0,0 +1,3 @@
+import root, { textsecure } from './whisper-text-protocol.js';
+export const WhisperMessage = root.textsecure.WhisperMessage;
+export const PreKeyWhisperMessage = root.textsecure.PreKeyWhisperMessage;

package/lib/protocol-address.d.ts

@@ -0,0 +1,8 @@
+export declare class ProtocolAddress {
+    id: string;
+    deviceId: number;
+    static from(encodedAddress: string): ProtocolAddress;
+    constructor(id: string, deviceId: number);
+    toString(): string;
+    is(other: unknown): boolean;
+}

package/lib/protocol-address.js

@@ -0,0 +1,31 @@
+export class ProtocolAddress {
+    static from(encodedAddress) {
+        if (typeof encodedAddress !== 'string' || !encodedAddress.match(/.*\.\d+/)) {
+            throw new Error('Invalid address encoding');
+        }
+        const parts = encodedAddress.split('.');
+        return new ProtocolAddress(parts[0], parseInt(parts[1], 10));
+    }
+    constructor(id, deviceId) {
+        if (typeof id !== 'string') {
+            throw new TypeError('id required for addr');
+        }
+        if (id.indexOf('.') !== -1) {
+            throw new TypeError('encoded addr detected');
+        }
+        this.id = id;
+        if (typeof deviceId !== 'number') {
+            throw new TypeError('number required for deviceId');
+        }
+        this.deviceId = deviceId;
+    }
+    toString() {
+        return `${this.id}.${this.deviceId}`;
+    }
+    is(other) {
+        if (!(other instanceof ProtocolAddress)) {
+            return false;
+        }
+        return other.id === this.id && other.deviceId === this.deviceId;
+    }
+}

package/lib/queue-job.d.ts

@@ -0,0 +1,3 @@
+type Awaitable<T> = () => Promise<T>;
+export declare function queueJob<T>(bucket: unknown, awaitable: Awaitable<T>): Promise<T>;
+export {};

package/lib/queue-job.js

@@ -0,0 +1,49 @@
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 500;
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    while (true) {
+        const limit = Math.min(queue.length, _gcLimit);
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            }
+            catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            queue.splice(0, limit);
+            offt = 0;
+        }
+        else {
+            break;
+        }
+    }
+    cleanup();
+}
+export function queueJob(bucket, awaitable) {
+    const namedAwaitable = awaitable;
+    if (!namedAwaitable.name) {
+        Object.defineProperty(namedAwaitable, 'name', { writable: true });
+        if (typeof bucket === 'string') {
+            namedAwaitable.name = bucket;
+        }
+    }
+    let inactive = false;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => queue.push({
+        awaitable: awaitable,
+        resolve: resolve,
+        reject
+    }));
+    if (inactive) {
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+}

package/lib/session-builder.d.ts

@@ -0,0 +1,12 @@
+import type { ProtocolAddress } from './protocol-address.js';
+import { SessionRecord } from './session-record.js';
+import type { DeviceKeyBundle, IncomingPreKeyMessage, SignalStorage } from './types.js';
+export declare class SessionBuilder {
+    private addr;
+    private storage;
+    constructor(storage: SignalStorage, protocolAddress: ProtocolAddress);
+    initOutgoing(device: DeviceKeyBundle): Promise<void>;
+    initIncoming(record: SessionRecord, message: IncomingPreKeyMessage): Promise<number | undefined>;
+    private initSession;
+    private calculateSendingRatchet;
+}

package/lib/session-builder.js

@@ -0,0 +1,153 @@
+import { BaseKeyType } from './base-key-type.js';
+import { ChainType } from './chain-type.js';
+import * as crypto from './crypto.js';
+import * as curve from './curve.js';
+import { Direction } from './direction.js';
+import * as errors from './errors.js';
+import { queueJob } from './queue-job.js';
+import { assertValidDeviceKeyBundle } from './prekey-bundle-validator.js';
+import { SessionRecord } from './session-record.js';
+export class SessionBuilder {
+    constructor(storage, protocolAddress) {
+        this.addr = protocolAddress;
+        this.storage = storage;
+    }
+    async initOutgoing(device) {
+        assertValidDeviceKeyBundle(device);
+        const fqAddr = this.addr.toString();
+        return await queueJob(fqAddr, async () => {
+            if (!(await this.storage.isTrustedIdentity(this.addr.id, device.identityKey, Direction.SENDING))) {
+                throw new errors.UntrustedIdentityKeyError(this.addr.id, device.identityKey);
+            }
+            if (!curve.verifySignature(device.identityKey, device.signedPreKey.publicKey, device.signedPreKey.signature)) {
+                throw new Error('Signature validation failed');
+            }
+            const baseKey = curve.generateKeyPair();
+            const devicePreKey = device.preKey && device.preKey.publicKey;
+            const session = await this.initSession(true, baseKey, undefined, device.identityKey, devicePreKey, device.signedPreKey.publicKey, device.registrationId);
+            session.pendingPreKey = {
+                signedKeyId: device.signedPreKey.keyId,
+                baseKey: baseKey.pubKey
+            };
+            if (device.preKey) {
+                session.pendingPreKey.preKeyId = device.preKey.keyId;
+            }
+            let record = await this.storage.loadSession(fqAddr);
+            if (!record) {
+                record = new SessionRecord();
+            }
+            else {
+                const openSession = record.getOpenSession();
+                if (openSession) {
+                    record.closeSession(openSession);
+                }
+            }
+            record.setSession(session);
+            record.removeOldSessions();
+            await this.storage.storeSession(fqAddr, record);
+        });
+    }
+    async initIncoming(record, message) {
+        if (!(await this.storage.isTrustedIdentity(this.addr.id, message.identityKey, Direction.RECEIVING))) {
+            throw new errors.UntrustedIdentityKeyError(this.addr.id, message.identityKey);
+        }
+        if (record.getSession(message.baseKey)) {
+            return undefined;
+        }
+        let preKeyPair;
+        if (message.preKeyId !== undefined) {
+            preKeyPair = await this.storage.loadPreKey(message.preKeyId);
+            if (!preKeyPair) {
+                throw new errors.PreKeyError('Invalid PreKey ID');
+            }
+        }
+        const signedPreKeyPair = await this.storage.loadSignedPreKey(message.signedPreKeyId);
+        if (!signedPreKeyPair) {
+            throw new errors.PreKeyError('Missing SignedPreKey');
+        }
+        const existingOpenSession = record.getOpenSession();
+        if (existingOpenSession) {
+            record.closeSession(existingOpenSession);
+        }
+        record.setSession(await this.initSession(false, preKeyPair, signedPreKeyPair, message.identityKey, message.baseKey, undefined, message.registrationId));
+        return message.preKeyId;
+    }
+    async initSession(isInitiator, ourEphemeralKey, ourSignedKeyInput, theirIdentityPubKey, theirEphemeralPubKey, theirSignedPubKeyInput, registrationId) {
+        let ourSignedKey = ourSignedKeyInput;
+        let theirSignedPubKey = theirSignedPubKeyInput;
+        if (isInitiator) {
+            if (ourSignedKey) {
+                throw new Error('Invalid call to initSession');
+            }
+            ourSignedKey = ourEphemeralKey;
+        }
+        else {
+            if (theirSignedPubKey) {
+                throw new Error('Invalid call to initSession');
+            }
+            theirSignedPubKey = theirEphemeralPubKey;
+        }
+        let sharedSecret;
+        if (!ourEphemeralKey || !theirEphemeralPubKey) {
+            sharedSecret = new Uint8Array(32 * 4);
+        }
+        else {
+            sharedSecret = new Uint8Array(32 * 5);
+        }
+        for (let i = 0; i < 32; i++) {
+            sharedSecret[i] = 0xff;
+        }
+        const ourIdentityKey = await this.storage.getOurIdentity();
+        const a1 = curve.calculateAgreement(theirSignedPubKey, ourIdentityKey.privKey);
+        const a2 = curve.calculateAgreement(theirIdentityPubKey, ourSignedKey.privKey);
+        const a3 = curve.calculateAgreement(theirSignedPubKey, ourSignedKey.privKey);
+        if (isInitiator) {
+            sharedSecret.set(new Uint8Array(a1), 32);
+            sharedSecret.set(new Uint8Array(a2), 32 * 2);
+        }
+        else {
+            sharedSecret.set(new Uint8Array(a1), 32 * 2);
+            sharedSecret.set(new Uint8Array(a2), 32);
+        }
+        sharedSecret.set(new Uint8Array(a3), 32 * 3);
+        if (ourEphemeralKey && theirEphemeralPubKey) {
+            const a4 = curve.calculateAgreement(theirEphemeralPubKey, ourEphemeralKey.privKey);
+            sharedSecret.set(new Uint8Array(a4), 32 * 4);
+        }
+        const masterKey = crypto.deriveSecrets(Buffer.from(sharedSecret), Buffer.alloc(32), Buffer.from('WhisperText'));
+        const session = SessionRecord.createEntry();
+        session.registrationId = registrationId;
+        session.currentRatchet = {
+            rootKey: masterKey[0],
+            ephemeralKeyPair: isInitiator ? curve.generateKeyPair() : ourSignedKey,
+            lastRemoteEphemeralKey: theirSignedPubKey,
+            previousCounter: 0
+        };
+        session.indexInfo = {
+            created: Date.now(),
+            used: Date.now(),
+            remoteIdentityKey: theirIdentityPubKey,
+            baseKey: isInitiator ? ourEphemeralKey.pubKey : theirEphemeralPubKey,
+            baseKeyType: isInitiator ? BaseKeyType.OURS : BaseKeyType.THEIRS,
+            closed: -1
+        };
+        if (isInitiator) {
+            this.calculateSendingRatchet(session, theirSignedPubKey);
+        }
+        return session;
+    }
+    calculateSendingRatchet(session, remoteKey) {
+        const ratchet = session.currentRatchet;
+        const sharedSecret = curve.calculateAgreement(remoteKey, ratchet.ephemeralKeyPair.privKey);
+        const masterKey = crypto.deriveSecrets(sharedSecret, ratchet.rootKey, Buffer.from('WhisperRatchet'));
+        session.addChain(ratchet.ephemeralKeyPair.pubKey, {
+            messageKeys: {},
+            chainKey: {
+                counter: -1,
+                key: masterKey[1]
+            },
+            chainType: ChainType.SENDING
+        });
+        ratchet.rootKey = masterKey[0];
+    }
+}

package/lib/session-cipher.d.ts

@@ -0,0 +1,29 @@
+import { ProtocolAddress } from './protocol-address.js';
+import type { Chain, SessionEntry } from './session-record.js';
+import { SessionRecord } from './session-record.js';
+import type { EncryptedMessage, SignalStorage } from './types.js';
+export declare class SessionCipher {
+    private addr;
+    private storage;
+    private staleSessionMaxAgeMs?;
+    constructor(storage: SignalStorage, protocolAddress: ProtocolAddress, staleSessionMaxAgeMs?: number | undefined);
+    private _encodeTupleByte;
+    private _decodeTupleByte;
+    toString(): string;
+    getRecord(): Promise<SessionRecord | undefined>;
+    storeRecord(record: SessionRecord): Promise<void>;
+    queueJob<T>(awaitable: () => Promise<T>): Promise<T>;
+    encrypt(data: Uint8Array): Promise<EncryptedMessage>;
+    decryptWithSessions(data: Uint8Array, sessions: SessionEntry[]): Promise<{
+        session: SessionEntry;
+        plaintext: Buffer;
+    }>;
+    decryptWhisperMessage(data: Uint8Array): Promise<Buffer>;
+    decryptPreKeyWhisperMessage(data: Uint8Array): Promise<Buffer>;
+    doDecryptWhisperMessage(messageBuffer: Uint8Array, session: SessionEntry): Promise<Buffer>;
+    fillMessageKeys(chain: Chain, counter: number): void;
+    maybeStepRatchet(session: SessionEntry, remoteKey: Buffer, previousCounter: number): void;
+    calculateRatchet(session: SessionEntry, remoteKey: Buffer, sending: boolean): void;
+    hasOpenSession(): Promise<boolean>;
+    closeOpenSession(): Promise<void>;
+}