@neykoor/libsignal-node 1.0.3 → 1.0.4

package/lib/session-record.js

@@ -1,286 +0,0 @@
-import { BaseKeyType } from './base-key-type.js';
-import { getLogger } from './logger.js';
-const CLOSED_SESSIONS_MAX = 40;
-const SESSION_RECORD_VERSION = 'v1';
-function assertBuffer(value) {
-    if (!Buffer.isBuffer(value)) {
-        throw new TypeError('Buffer required');
-    }
-}
-export class SessionEntry {
-    constructor() {
-        this._chains = {};
-    }
-    toString() {
-        const baseKey = this.indexInfo && this.indexInfo.baseKey && this.indexInfo.baseKey.toString('base64');
-        return `<SessionEntry [baseKey=${baseKey}]>`;
-    }
-    inspect() {
-        return this.toString();
-    }
-    addChain(key, value) {
-        assertBuffer(key);
-        const id = key.toString('base64');
-        if (Object.prototype.hasOwnProperty.call(this._chains, id)) {
-            throw new Error('Overwrite attempt');
-        }
-        this._chains[id] = value;
-    }
-    getChain(key) {
-        assertBuffer(key);
-        return this._chains[key.toString('base64')];
-    }
-    deleteChain(key) {
-        assertBuffer(key);
-        const id = key.toString('base64');
-        if (!Object.prototype.hasOwnProperty.call(this._chains, id)) {
-            throw new ReferenceError('Not Found');
-        }
-        delete this._chains[id];
-    }
-    *chains() {
-        for (const [k, v] of Object.entries(this._chains)) {
-            yield [Buffer.from(k, 'base64'), v];
-        }
-    }
-    serialize() {
-        const data = {
-            registrationId: this.registrationId,
-            currentRatchet: {
-                ephemeralKeyPair: {
-                    pubKey: this.currentRatchet.ephemeralKeyPair.pubKey.toString('base64'),
-                    privKey: this.currentRatchet.ephemeralKeyPair.privKey.toString('base64')
-                },
-                lastRemoteEphemeralKey: this.currentRatchet.lastRemoteEphemeralKey.toString('base64'),
-                previousCounter: this.currentRatchet.previousCounter,
-                rootKey: this.currentRatchet.rootKey.toString('base64')
-            },
-            indexInfo: {
-                baseKey: this.indexInfo.baseKey.toString('base64'),
-                baseKeyType: this.indexInfo.baseKeyType,
-                closed: this.indexInfo.closed,
-                used: this.indexInfo.used,
-                created: this.indexInfo.created,
-                remoteIdentityKey: this.indexInfo.remoteIdentityKey.toString('base64')
-            },
-            _chains: SessionEntry._serializeChains(this._chains)
-        };
-        if (this.pendingPreKey) {
-            data.pendingPreKey = {
-                ...this.pendingPreKey,
-                baseKey: this.pendingPreKey.baseKey.toString('base64')
-            };
-        }
-        return data;
-    }
-    static deserialize(data) {
-        const obj = new SessionEntry();
-        obj.registrationId = data.registrationId;
-        obj.currentRatchet = {
-            ephemeralKeyPair: {
-                pubKey: Buffer.from(data.currentRatchet.ephemeralKeyPair.pubKey, 'base64'),
-                privKey: Buffer.from(data.currentRatchet.ephemeralKeyPair.privKey, 'base64')
-            },
-            lastRemoteEphemeralKey: Buffer.from(data.currentRatchet.lastRemoteEphemeralKey, 'base64'),
-            previousCounter: data.currentRatchet.previousCounter,
-            rootKey: Buffer.from(data.currentRatchet.rootKey, 'base64')
-        };
-        obj.indexInfo = {
-            baseKey: Buffer.from(data.indexInfo.baseKey, 'base64'),
-            baseKeyType: data.indexInfo.baseKeyType,
-            closed: data.indexInfo.closed,
-            used: data.indexInfo.used,
-            created: data.indexInfo.created,
-            remoteIdentityKey: Buffer.from(data.indexInfo.remoteIdentityKey, 'base64')
-        };
-        obj._chains = SessionEntry._deserializeChains(data._chains);
-        if (data.pendingPreKey) {
-            obj.pendingPreKey = {
-                ...data.pendingPreKey,
-                baseKey: Buffer.from(data.pendingPreKey.baseKey, 'base64')
-            };
-        }
-        return obj;
-    }
-    static _serializeChains(chains) {
-        const r = {};
-        for (const key of Object.keys(chains)) {
-            const c = chains[key];
-            const messageKeys = {};
-            for (const [idx, mk] of Object.entries(c.messageKeys)) {
-                messageKeys[Number(idx)] = mk.toString('base64');
-            }
-            r[key] = {
-                chainKey: {
-                    counter: c.chainKey.counter,
-                    key: c.chainKey.key && c.chainKey.key.toString('base64')
-                },
-                chainType: c.chainType,
-                messageKeys
-            };
-        }
-        return r;
-    }
-    static _deserializeChains(chainsData) {
-        const r = {};
-        for (const key of Object.keys(chainsData)) {
-            const c = chainsData[key];
-            const messageKeys = {};
-            for (const [idx, mk] of Object.entries(c.messageKeys)) {
-                messageKeys[Number(idx)] = Buffer.from(mk, 'base64');
-            }
-            r[key] = {
-                chainKey: {
-                    counter: c.chainKey.counter,
-                    key: c.chainKey.key ? Buffer.from(c.chainKey.key, 'base64') : undefined
-                },
-                chainType: c.chainType,
-                messageKeys
-            };
-        }
-        return r;
-    }
-}
-const migrations = [
-    {
-        version: 'v1',
-        migrate(data) {
-            const sessions = data._sessions;
-            if (data.registrationId) {
-                for (const key in sessions) {
-                    if (!sessions[key].registrationId) {
-                        sessions[key].registrationId = data.registrationId;
-                    }
-                }
-            }
-            else {
-                for (const key in sessions) {
-                    if (sessions[key].indexInfo.closed === -1) {
-                        getLogger().warn('V1 session storage migration error: missing registrationId for open session', {
-                            registrationId: data.registrationId,
-                            version: data.version
-                        });
-                    }
-                }
-            }
-        }
-    }
-];
-export class SessionRecord {
-    constructor() {
-        this.sessions = {};
-        this.version = SESSION_RECORD_VERSION;
-    }
-    static createEntry() {
-        return new SessionEntry();
-    }
-    static migrate(data) {
-        let run = data.version === undefined;
-        for (const migration of migrations) {
-            if (run) {
-                migration.migrate(data);
-            }
-            else if (migration.version === data.version) {
-                run = true;
-            }
-        }
-        if (!run) {
-            throw new Error('Error migrating SessionRecord');
-        }
-    }
-    static deserialize(data) {
-        const parsed = JSON.parse(Buffer.from(data).toString('utf-8'));
-        if (parsed.version !== SESSION_RECORD_VERSION) {
-            SessionRecord.migrate(parsed);
-        }
-        const obj = new SessionRecord();
-        if (parsed._sessions) {
-            for (const [key, entry] of Object.entries(parsed._sessions)) {
-                obj.sessions[key] = SessionEntry.deserialize(entry);
-            }
-        }
-        return obj;
-    }
-    serialize() {
-        const _sessions = {};
-        for (const [key, entry] of Object.entries(this.sessions)) {
-            _sessions[key] = entry.serialize();
-        }
-        return Buffer.from(JSON.stringify({ _sessions, version: this.version }), 'utf-8');
-    }
-    haveOpenSession() {
-        const openSession = this.getOpenSession();
-        return !!openSession && typeof openSession.registrationId === 'number';
-    }
-    getSession(key) {
-        assertBuffer(key);
-        const session = this.sessions[key.toString('base64')];
-        if (session && session.indexInfo.baseKeyType === BaseKeyType.OURS) {
-            throw new Error('Tried to lookup a session using our basekey');
-        }
-        return session;
-    }
-    getOpenSession() {
-        for (const session of Object.values(this.sessions)) {
-            if (!this.isClosed(session)) {
-                return session;
-            }
-        }
-        return undefined;
-    }
-    setSession(session) {
-        this.sessions[session.indexInfo.baseKey.toString('base64')] = session;
-    }
-    getSessions() {
-        return Array.from(Object.values(this.sessions)).sort((a, b) => {
-            const aUsed = a.indexInfo.used || 0;
-            const bUsed = b.indexInfo.used || 0;
-            return aUsed === bUsed ? 0 : aUsed < bUsed ? 1 : -1;
-        });
-    }
-    closeSession(session) {
-        if (this.isClosed(session)) {
-            return;
-        }
-        session.indexInfo.closed = Date.now();
-    }
-    openSession(session) {
-        session.indexInfo.closed = -1;
-    }
-    isClosed(session) {
-        return session.indexInfo.closed !== -1;
-    }
-    removeOldSessions() {
-        while (Object.keys(this.sessions).length > CLOSED_SESSIONS_MAX) {
-            let oldestKey;
-            let oldestSession;
-            for (const [key, session] of Object.entries(this.sessions)) {
-                if (session.indexInfo.closed !== -1 &&
-                    (!oldestSession || session.indexInfo.closed < oldestSession.indexInfo.closed)) {
-                    oldestKey = key;
-                    oldestSession = session;
-                }
-            }
-            if (oldestKey) {
-                delete this.sessions[oldestKey];
-            }
-            else {
-                throw new Error('Corrupt sessions object');
-            }
-        }
-    }
-    removeStaleSessions(maxAgeMs) {
-        const cutoff = Date.now() - maxAgeMs;
-        for (const [key, session] of Object.entries(this.sessions)) {
-            const lastUsed = session.indexInfo.used || session.indexInfo.created || 0;
-            if (session.indexInfo.closed !== -1 && lastUsed < cutoff) {
-                delete this.sessions[key];
-            }
-        }
-    }
-    deleteAllSessions() {
-        for (const key of Object.keys(this.sessions)) {
-            delete this.sessions[key];
-        }
-    }
-}

package/lib/types.d.ts

@@ -1,42 +0,0 @@
-import type { KeyPair } from './curve.js';
-import type { Direction } from './direction.js';
-import type { SessionRecord } from './session-record.js';
-export type { KeyPair };
-export interface SignalStorage {
-    loadSession(id: string): Promise<SessionRecord | undefined>;
-    storeSession(id: string, session: SessionRecord): Promise<void>;
-    isTrustedIdentity(identifier: string, identityKey: Buffer, direction: Direction): Promise<boolean> | boolean;
-    saveIdentity?(identifier: string, identityKey: Buffer): Promise<boolean> | boolean;
-    removeIdentity?(identifier: string): Promise<void> | void;
-    loadPreKey(id?: number | string): Promise<KeyPair | undefined>;
-    removePreKey(id: number): Promise<void> | void;
-    loadSignedPreKey(id?: number | string): Promise<KeyPair | undefined> | KeyPair | undefined;
-    getOurRegistrationId(): Promise<number> | number;
-    getOurIdentity(): Promise<KeyPair> | KeyPair;
-}
-export interface DeviceKeyBundle {
-    registrationId: number;
-    identityKey: Buffer;
-    signedPreKey: {
-        keyId: number;
-        publicKey: Buffer;
-        signature: Buffer;
-    };
-    preKey?: {
-        keyId: number;
-        publicKey: Buffer;
-    };
-}
-export interface IncomingPreKeyMessage {
-    registrationId?: number;
-    identityKey: Buffer;
-    baseKey: Buffer;
-    preKeyId?: number;
-    signedPreKeyId?: number;
-    message: Buffer;
-}
-export interface EncryptedMessage {
-    type: number;
-    body: Buffer;
-    registrationId?: number;
-}

package/lib/types.js

@@ -1 +0,0 @@
-export {};

package/lib/util.d.ts

@@ -1,2 +0,0 @@
-export declare function wipeBuffer(buffer: Buffer | undefined | null): void;
-export declare function wipeBuffers(...buffers: Array<Buffer | undefined | null>): void;

package/lib/util.js

@@ -1,10 +0,0 @@
-export function wipeBuffer(buffer) {
-    if (buffer && buffer.byteLength > 0) {
-        buffer.fill(0);
-    }
-}
-export function wipeBuffers(...buffers) {
-    for (const buffer of buffers) {
-        wipeBuffer(buffer);
-    }
-}

package/lib/whisper-text-protocol.d.ts

@@ -1,3 +0,0 @@
-export default $root;
-export const textsecure: any;
-declare var $root: {};