rixleys 1.0.0

package/lib/Signal/core/src/session_record.js

@@ -0,0 +1,316 @@
+// vim: ts=4:sw=4
+
+const BaseKeyType = require('./base_key_type');
+
+const CLOSED_SESSIONS_MAX = 40;
+const SESSION_RECORD_VERSION = 'v1';
+
+function assertBuffer(value) {
+    if (!Buffer.isBuffer(value)) {
+        throw new TypeError("Buffer required");
+    }
+}
+
+
+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 (this._chains.hasOwnProperty(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 (!this._chains.hasOwnProperty(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: this._serialize_chains(this._chains)
+        };
+        if (this.pendingPreKey) {
+            data.pendingPreKey = Object.assign({}, this.pendingPreKey);
+            data.pendingPreKey.baseKey = this.pendingPreKey.baseKey.toString('base64');
+        }
+        return data;
+    }
+
+    static deserialize(data) {
+        const obj = new this();
+        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 = this._deserialize_chains(data._chains);
+        if (data.pendingPreKey) {
+            obj.pendingPreKey = Object.assign({}, data.pendingPreKey);
+            obj.pendingPreKey.baseKey = Buffer.from(data.pendingPreKey.baseKey, 'base64');
+        }
+        return obj;
+    }
+
+    _serialize_chains(chains) {
+        const r = {};
+        for (const key of Object.keys(chains)) {
+            const c = chains[key];
+            const messageKeys = {};
+            for (const [idx, key] of Object.entries(c.messageKeys)) {
+                messageKeys[idx] = key.toString('base64');
+            }
+            r[key] = {
+                chainKey: {
+                    counter: c.chainKey.counter,
+                    key: c.chainKey.key && c.chainKey.key.toString('base64')
+                },
+                chainType: c.chainType,
+                messageKeys: messageKeys
+            };
+        }
+        return r;
+    }
+
+    static _deserialize_chains(chains_data) {
+        const r = {};
+        for (const key of Object.keys(chains_data)) {
+            const c = chains_data[key];
+            const messageKeys = {};
+            for (const [idx, key] of Object.entries(c.messageKeys)) {
+                messageKeys[idx] = Buffer.from(key, 'base64');
+            }
+            r[key] = {
+                chainKey: {
+                    counter: c.chainKey.counter,
+                    key: c.chainKey.key && Buffer.from(c.chainKey.key, 'base64')
+                },
+                chainType: c.chainType,
+                messageKeys: messageKeys
+            };
+        }
+        return r;
+    }
+
+}
+
+
+const migrations = [{
+    version: 'v1',
+    migrate: function migrateV1(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) {
+                    console.error('V1 session storage migration error: registrationId',
+                                  data.registrationId, 'for open session version',
+                                  data.version);
+                }
+            }
+        }
+    }
+}];
+
+
+class SessionRecord {
+
+    static createEntry() {
+        return new SessionEntry();
+    }
+
+    static migrate(data) {
+        let run = (data.version === undefined);
+        for (let i = 0; i < migrations.length; ++i) {
+            if (run) {
+                console.info("Migrating session to:", migrations[i].version);
+                migrations[i].migrate(data);
+            } else if (migrations[i].version === data.version) {
+                run = true;
+            }
+        }
+        if (!run) {
+            throw new Error("Error migrating SessionRecord");
+        }
+    }
+
+    static deserialize(data) {
+        if (data.version !== SESSION_RECORD_VERSION) {
+            this.migrate(data);
+        }
+        const obj = new this();
+        if (data._sessions) {
+            for (const [key, entry] of Object.entries(data._sessions)) {
+                obj.sessions[key] = SessionEntry.deserialize(entry);
+            }
+        }
+        return obj;
+    }
+
+    constructor() {
+        this.sessions = {};
+        this.version = SESSION_RECORD_VERSION;
+    }
+
+    serialize() {
+        const _sessions = {};
+        for (const [key, entry] of Object.entries(this.sessions)) {
+            _sessions[key] = entry.serialize();
+        }
+        return {
+            _sessions,
+            version: this.version
+        };
+    }
+
+    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;
+            }
+        }
+    }
+
+    setSession(session) {
+        this.sessions[session.indexInfo.baseKey.toString('base64')] = session;
+    }
+
+    getSessions() {
+        // Return sessions ordered with most recently used first.
+        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)) {
+            // console.warn("Session already closed", session);
+            return;
+        }
+        // console.info("Closing session:", session);
+        session.indexInfo.closed = Date.now();
+    }
+
+    openSession(session) {
+        if (!this.isClosed(session)) {
+            // console.warn("Session already open");
+        }
+        // console.info("Opening session:", 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) {
+                // console.info("Removing old closed session:", oldestSession);
+                delete this.sessions[oldestKey];
+            } else {
+                throw new Error('Corrupt sessions object');
+            }
+        }
+    }
+
+    deleteAllSessions() {
+        for (const key of Object.keys(this.sessions)) {
+            delete this.sessions[key];
+        }
+    }
+}
+
+module.exports = SessionRecord;

package/lib/Signal/libsignal.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLibSignalRepository = makeLibSignalRepository;
+const libsignal = __importStar(require("./core"));
+
+if (typeof console !== 'undefined' && console.error) {
+    const originalConsoleError = console.error;
+    console.error = function (...args) {
+        if (typeof args[0] === 'string' && args[0].startsWith('Session error:')) {
+            return;
+        }
+        return originalConsoleError.apply(console, args);
+    };
+}
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const sender_key_name_1 = require("./Group/sender-key-name");
+const sender_key_record_1 = require("./Group/sender-key-record");
+const Group_1 = require("./Group");
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth);
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new Group_1.GroupCipher(storage, senderName);
+            return cipher.decrypt(msg);
+        },
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
+            }
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            await builder.process(senderName, senderMsg);
+        },
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new libsignal.SessionCipher(storage, addr);
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+                default:
+                    throw new Error(`Unknown message type: ${type}`);
+            }
+            return result;
+        },
+        async encryptMessage({ jid, data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new libsignal.SessionCipher(storage, addr);
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
+        },
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+            };
+        },
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            await cipher.initOutgoing(session);
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
+        }
+    };
+}
+const jidToSignalProtocolAddress = (jid) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
+};
+const jidToSignalSenderKeyName = (group, user) => {
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
+};
+function signalStorage({ creds, keys }) {
+    return {
+        loadSession: async (id) => {
+            const { [id]: sess } = await keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
+            }
+        },
+        storeSession: async (id, session) => {
+            await keys.set({ session: { [id]: session.serialize() } });
+        },
+        isTrustedIdentity: () => {
+            return true;
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString();
+            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                };
+            }
+        },
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey;
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            };
+        },
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString();
+            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            if (key) {
+                return sender_key_record_1.SenderKeyRecord.deserialize(key);
+            }
+            return new sender_key_record_1.SenderKeyRecord();
+        },
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString();
+            const serialized = JSON.stringify(key.serialize());
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
+        },
+        getOurRegistrationId: () => creds.registrationId,
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+            };
+        }
+    };
+}

package/lib/Socket/Client/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./websocket"), exports);

package/lib/Socket/Client/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/websocket.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const Defaults_1 = require("../../Defaults");
+const types_1 = require("./types");
+class WebSocketClient extends types_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN;
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSED;
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CONNECTING;
+    }
+    async connect() {
+        var _a, _b;
+        if (this.socket) {
+            return;
+        }
+        this.socket = new ws_1.default(this.url, {
+            origin: Defaults_1.DEFAULT_ORIGIN,
+            headers: (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers,
+            handshakeTimeout: this.config.connectTimeoutMs,
+            timeout: this.config.connectTimeoutMs,
+            agent: this.config.agent,
+        });
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
+        for (const event of events) {
+            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on(event, (...args) => this.emit(event, ...args));
+        }
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        this.socket.close();
+        this.socket = null;
+    }
+    async restart() {
+        if (this.socket) {
+            await new Promise(resolve => {
+                this.socket.once('close', resolve);
+                this.socket.terminate();
+            });
+            this.socket = null;
+        }
+        await this.connect();
+    }
+    send(str, cb) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(str, cb);
+        return true;
+    }
+}
+exports.WebSocketClient = WebSocketClient;