@freesignal/protocol 0.2.11 → 0.3.2

package/package.json

@@ -1,21 +1,45 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.2.11",
+  "version": "0.3.2",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
   "type": "commonjs",
-  "main": "index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./double-ratchet": {
+      "import": "./dist/double-ratchet.js",
+      "types": "./dist/double-ratchet.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node.js",
+      "types": "./dist/node.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    },
+    "./x3dh": {
+      "import": "./dist/x3dh.js",
+      "types": "./dist/x3dh.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
   "scripts": {
-    "test": "tsc && node ./build/test.js",
-    "build": "tsc && node ./build/build.js"
+    "pretest": "tsc",
+    "test": "node ./dist/test.js",
+    "prepare": "tsc"
   },
   "dependencies": {
     "@freesignal/crypto": "^0.3.0",
     "@freesignal/interfaces": "^0.2.0",
-    "@freesignal/utils": "^1.3.0"
+    "@freesignal/utils": "^1.4.1",
+    "semaphore.ts": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^24.2.1"
   }
-}
+}

package/double-ratchet.js

@@ -1,294 +0,0 @@
-"use strict";
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncryptedDataConstructor = exports.KeySession = void 0;
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
-const utils_1 = require("@freesignal/utils");
-const types_1 = require("./types");
-/**
- * Represents a secure Double Ratchet session.
- * Used for forward-secure encryption and decryption of messages.
- */
-class KeySession {
-    constructor(storage, opts = {}) {
-        var _a;
-        this.sendingCount = 0;
-        this.previousCount = 0;
-        this.receivingCount = 0;
-        this.previousKeys = new KeyMap();
-        this.id = (_a = opts.id) !== null && _a !== void 0 ? _a : crypto_1.default.UUID.generate().toString();
-        this.keyPair = crypto_1.default.ECDH.keyPair(opts.secretKey);
-        if (opts.rootKey)
-            this.rootKey = opts.rootKey;
-        if (opts.remoteKey) {
-            this._remoteKey = opts.remoteKey;
-            this.sendingChain = this.ratchetKeys();
-        }
-        this.storage = storage;
-        this.storage.set(this.id, this.toJSON());
-    }
-    /**
-     * Whether both the sending and receiving chains are initialized.
-     */
-    get handshaked() { return this.sendingChain && this.receivingChain ? true : false; }
-    /**
-     * The public key of this session.
-     */
-    get publicKey() { return this.keyPair.publicKey; }
-    /**
-     * The last known remote public key.
-     */
-    get remoteKey() { return this._remoteKey; }
-    setRemoteKey(key) {
-        this._remoteKey = key;
-        this.receivingChain = this.ratchetKeys();
-        if (this.receivingCount > (EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
-            this.receivingCount = 0;
-        this.previousCount = this.sendingCount;
-        this.keyPair = crypto_1.default.ECDH.keyPair();
-        this.sendingChain = this.ratchetKeys();
-        if (this.sendingCount > (EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
-            this.sendingCount = 0;
-        return this;
-    }
-    ratchetKeys(info) {
-        if (!this._remoteKey)
-            throw new Error();
-        const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, this._remoteKey);
-        if (!this.rootKey)
-            this.rootKey = crypto_1.default.hash(sharedKey);
-        const hashkey = crypto_1.default.hkdf(sharedKey, this.rootKey, info, KeySession.keyLength * 2);
-        this.rootKey = hashkey.slice(0, KeySession.keyLength);
-        return hashkey.slice(KeySession.keyLength);
-    }
-    getSendingKey() {
-        if (!this.sendingChain)
-            throw new Error;
-        const { chainKey, sharedKey } = KeySession.symmetricRatchet(this.sendingChain);
-        this.sendingChain = chainKey;
-        this.sendingCount++;
-        return sharedKey;
-    }
-    getReceivingKey() {
-        if (!this.receivingChain)
-            throw new Error();
-        const { chainKey, sharedKey } = KeySession.symmetricRatchet(this.receivingChain);
-        this.receivingChain = chainKey;
-        this.receivingCount++;
-        return sharedKey;
-    }
-    save() {
-        return this.storage.set(this.id, this.toJSON());
-    }
-    /**
-     * Encrypts a message payload using the current sending chain.
-     *
-     * @param message - The message as a Uint8Array.
-     * @returns An EncryptedPayload or undefined if encryption fails.
-     */
-    encrypt(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = this.getSendingKey();
-            if (this.sendingCount >= EncryptedDataConstructor.maxCount || this.previousCount >= EncryptedDataConstructor.maxCount)
-                throw new Error();
-            const nonce = crypto_1.default.randomBytes(EncryptedDataConstructor.nonceLength);
-            const ciphertext = crypto_1.default.box.encrypt(message, nonce, key);
-            yield this.save();
-            return new EncryptedDataConstructor(this.sendingCount, this.previousCount, this.keyPair.publicKey, nonce, ciphertext);
-        });
-    }
-    /**
-     * Decrypts an encrypted message.
-     *
-     * @param payload - The received encrypted message.
-     * @returns The decrypted message as a Uint8Array, or undefined if decryption fails.
-     */
-    decrypt(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const encrypted = types_1.EncryptedData.from(payload);
-            const publicKey = encrypted.publicKey;
-            if (this._remoteKey && !(0, utils_1.verifyArrays)(publicKey, this._remoteKey))
-                while (this.receivingCount < encrypted.previous)
-                    this.previousKeys.set(this.receivingCount, this.getReceivingKey());
-            this.setRemoteKey(publicKey);
-            let key;
-            const count = encrypted.count;
-            if (this.receivingCount < count) {
-                let i = 0;
-                while (this.receivingCount < count - 1 && i < KeySession.skipLimit) {
-                    this.previousKeys.set(this.receivingCount, this.getReceivingKey());
-                }
-                key = this.getReceivingKey();
-            }
-            else {
-                key = this.previousKeys.get(count);
-            }
-            if (!key)
-                return undefined;
-            yield this.save();
-            return crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key);
-        });
-    }
-    /**
-     * Export the state of the session;
-     */
-    toJSON() {
-        var _a, _b, _c, _d;
-        return {
-            secretKey: (0, utils_1.decodeBase64)((0, utils_1.concatArrays)(this.keyPair.secretKey)),
-            remoteKey: (0, utils_1.decodeBase64)((_a = this._remoteKey) !== null && _a !== void 0 ? _a : new Uint8Array()),
-            rootKey: (0, utils_1.decodeBase64)((_b = this.rootKey) !== null && _b !== void 0 ? _b : new Uint8Array()),
-            sendingChain: (0, utils_1.decodeBase64)((_c = this.sendingChain) !== null && _c !== void 0 ? _c : new Uint8Array()),
-            receivingChain: (0, utils_1.decodeBase64)((_d = this.receivingChain) !== null && _d !== void 0 ? _d : new Uint8Array()),
-            sendingCount: this.sendingCount,
-            receivingCount: this.receivingCount,
-            previousCount: this.previousCount,
-            previousKeys: Array.from(this.previousKeys.entries())
-        };
-    }
-    /**
-     * Import a state.
-     *
-     * @param json string returned by `export()` method.
-     * @returns session with the state parsed.
-     */
-    static from(data, storage) {
-        const session = new KeySession(storage, { secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: (0, utils_1.encodeBase64)(data.rootKey) });
-        session._remoteKey = (0, utils_1.encodeBase64)(data.remoteKey);
-        session.sendingChain = (0, utils_1.encodeBase64)(data.sendingChain);
-        session.receivingChain = (0, utils_1.encodeBase64)(data.receivingChain);
-        session.sendingCount = data.sendingCount;
-        session.receivingCount = data.receivingCount;
-        session.previousCount = data.previousCount;
-        session.previousKeys = new KeyMap(data.previousKeys);
-        session.save();
-        return session;
-    }
-    static symmetricRatchet(chain, salt, info) {
-        const hash = crypto_1.default.hkdf(chain, salt !== null && salt !== void 0 ? salt : new Uint8Array(), info, KeySession.keyLength * 2);
-        return {
-            chainKey: new Uint8Array(hash.buffer, 0, KeySession.keyLength),
-            sharedKey: new Uint8Array(hash.buffer, KeySession.keyLength)
-        };
-    }
-}
-exports.KeySession = KeySession;
-KeySession.skipLimit = 1000;
-KeySession.version = 1;
-KeySession.rootKeyLength = crypto_1.default.box.keyLength;
-/**
- * The fixed key length (in bytes) used throughout the Double Ratchet session.
- * Typically 32 bytes (256 bits) for symmetric keys.
- */
-KeySession.keyLength = 32;
-class EncryptedDataConstructor {
-    constructor(...arrays) {
-        arrays = arrays.filter(value => value !== undefined);
-        if (arrays[0] instanceof EncryptedDataConstructor) {
-            this.raw = arrays[0].raw;
-            return this;
-        }
-        if (typeof arrays[0] === 'number')
-            arrays[0] = (0, utils_1.numberToArray)(arrays[0], EncryptedDataConstructor.countLength);
-        if (typeof arrays[1] === 'number')
-            arrays[1] = (0, utils_1.numberToArray)(arrays[1], EncryptedDataConstructor.countLength);
-        if (arrays.length === 6) {
-            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToArray)(arrays[5]) : arrays[5]);
-            arrays.pop();
-        }
-        else if (arrays.length > 1) {
-            arrays.unshift((0, utils_1.numberToArray)(KeySession.version));
-        }
-        this.raw = (0, utils_1.concatArrays)(...arrays);
-    }
-    get length() { return this.raw.length; }
-    get version() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
-    get count() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
-    get previous() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.previous.get)); }
-    get publicKey() { return new Uint8Array(this.raw.buffer, ...Offsets.publicKey.get); }
-    get nonce() { return new Uint8Array(this.raw.buffer, ...Offsets.nonce.get); }
-    get ciphertext() { return new Uint8Array(this.raw.buffer, Offsets.ciphertext.start); }
-    toBytes() {
-        return this.raw;
-    }
-    toString() {
-        return (0, utils_1.decodeBase64)(this.raw);
-    }
-    toJSON() {
-        return {
-            version: this.version,
-            count: this.count,
-            previous: this.previous,
-            publicKey: (0, utils_1.decodeBase64)(this.publicKey),
-            nonce: (0, utils_1.decodeBase64)(this.nonce),
-            ciphertext: (0, utils_1.decodeBase64)(this.ciphertext)
-        };
-    }
-}
-exports.EncryptedDataConstructor = EncryptedDataConstructor;
-EncryptedDataConstructor.secretKeyLength = crypto_1.default.ECDH.secretKeyLength;
-EncryptedDataConstructor.publicKeyLength = crypto_1.default.ECDH.publicKeyLength;
-EncryptedDataConstructor.keyLength = crypto_1.default.box.keyLength;
-EncryptedDataConstructor.nonceLength = crypto_1.default.box.nonceLength;
-EncryptedDataConstructor.maxCount = 65536; //32768;
-EncryptedDataConstructor.countLength = 2;
-class Offsets {
-    static set(start, length) {
-        class Offset {
-            constructor(start, length) {
-                this.start = start;
-                this.length = length;
-                if (typeof length === 'number')
-                    this.end = start + length;
-            }
-            get get() {
-                return [this.start, this.length];
-            }
-        }
-        return new Offset(start, length);
-    }
-}
-Offsets.checksum = Offsets.set(0, 0);
-Offsets.version = Offsets.set(Offsets.checksum.end, 1);
-Offsets.count = Offsets.set(Offsets.version.end, EncryptedDataConstructor.countLength);
-Offsets.previous = Offsets.set(Offsets.count.end, EncryptedDataConstructor.countLength);
-Offsets.publicKey = Offsets.set(Offsets.previous.end, EncryptedDataConstructor.publicKeyLength);
-Offsets.nonce = Offsets.set(Offsets.publicKey.end, EncryptedDataConstructor.nonceLength);
-Offsets.ciphertext = Offsets.set(Offsets.nonce.end, undefined);
-class KeyMap extends Map {
-    get(key) {
-        const out = super.get(key);
-        if (out && !super.delete(key))
-            throw new Error();
-        return out;
-    }
-}

package/node.d.ts

@@ -1,27 +0,0 @@
-import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
-import { Datagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
-import { KeyExchange } from "./x3dh";
-import { ExportedKeySession, KeySession } from "./double-ratchet";
-export declare class FreeSignalNode {
-    protected readonly privateIdentityKey: PrivateIdentityKey;
-    protected readonly sessions: Map<string, KeySession>;
-    protected readonly sessionsData: LocalStorage<string, ExportedKeySession>;
-    protected readonly users: LocalStorage<string, IdentityKey>;
-    protected readonly keyExchange: KeyExchange;
-    constructor(storage: Database<{
-        sessions: LocalStorage<string, ExportedKeySession>;
-        keyExchange: LocalStorage<string, Crypto.KeyPair>;
-        users: LocalStorage<string, IdentityKey>;
-    }>, privateIdentityKey?: PrivateIdentityKey);
-    get userId(): UserId;
-    get identityKey(): IdentityKey;
-    generateKeyData(): Promise<KeyExchangeData>;
-    generateKeyBundle(length?: number): Promise<KeyExchangeDataBundle>;
-    encrypt(receiverId: string, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
-    sendHandshake(data: KeyExchangeData): Promise<Datagram>;
-    sendData<T>(receiverId: string, data: T): Promise<Datagram>;
-    sendRelay(receiverId: string, data: Datagram): Promise<Datagram>;
-    sendDiscover(receiverId: string, discoverId: string): Promise<Datagram>;
-    decrypt(datagram: Datagram): Promise<Uint8Array>;
-    receive<T extends Uint8Array | UserId | Datagram | UserId | void>(datagram: Datagram | Uint8Array): Promise<T>;
-}

package/node.js

@@ -1,105 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreeSignalNode = void 0;
-const types_1 = require("./types");
-const x3dh_1 = require("./x3dh");
-const _1 = require(".");
-const utils_1 = require("@freesignal/utils");
-class FreeSignalNode {
-    constructor(storage, privateIdentityKey) {
-        this.sessions = new Map();
-        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
-        this.sessionsData = storage.sessions;
-        this.keyExchange = new x3dh_1.KeyExchange({ keys: storage.keyExchange, sessions: storage.sessions }, this.privateIdentityKey);
-        this.users = storage.users;
-        /*Array.from(this.sessionsData.entries()).forEach(([userId, sessionData]) => {
-            this.sessions.set(userId, KeySession.from(sessionData, this.sessionsData));
-        });*/
-    }
-    get userId() {
-        return types_1.UserId.fromKey(this.privateIdentityKey.identityKey);
-    }
-    get identityKey() {
-        return this.privateIdentityKey.identityKey;
-    }
-    generateKeyData() {
-        return this.keyExchange.generateData();
-    }
-    ;
-    generateKeyBundle(length) {
-        return this.keyExchange.generateBundle(length);
-    }
-    ;
-    encrypt(receiverId, protocol, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.sessions.get(receiverId);
-            if (!session)
-                throw new Error("Session not found for user: " + receiverId);
-            return new types_1.Datagram(this.userId.toString(), receiverId, protocol, yield session.encrypt(data));
-        });
-    }
-    sendHandshake(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { session, message, identityKey } = yield this.keyExchange.digestData(data);
-            const remoteId = types_1.UserId.fromKey(identityKey);
-            this.sessions.set(remoteId.toString(), session);
-            return new types_1.Datagram(this.userId.toString(), types_1.UserId.fromKey(data.identityKey).toString(), types_1.Protocols.HANDSHAKE, (0, utils_1.encodeData)(message));
-        });
-    }
-    sendData(receiverId, data) {
-        return this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
-    }
-    sendRelay(receiverId, data) {
-        return this.encrypt(receiverId, types_1.Protocols.RELAY, (0, utils_1.encodeData)(data));
-    }
-    sendDiscover(receiverId, discoverId) {
-        return this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(discoverId));
-    }
-    decrypt(datagram) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userId = datagram.sender;
-            const session = this.sessions.get(userId);
-            if (!session)
-                throw new Error("Session not found for user: " + userId);
-            if (!datagram.payload)
-                throw new Error("Missing payload");
-            const decrypted = yield session.decrypt(datagram.payload);
-            if (!decrypted)
-                throw new Error("Decryption failed");
-            return decrypted;
-        });
-    }
-    receive(datagram) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (datagram instanceof Uint8Array)
-                datagram = types_1.Datagram.from(datagram);
-            switch (datagram.protocol) {
-                case types_1.Protocols.HANDSHAKE:
-                    if (!datagram.payload)
-                        throw new Error("Missing payload");
-                    const data = (0, utils_1.decodeData)(datagram.payload);
-                    const { session, identityKey } = yield this.keyExchange.digestMessage(data);
-                    this.sessions.set(types_1.UserId.fromKey(identityKey).toString(), session);
-                    return;
-                case types_1.Protocols.MESSAGE:
-                    return yield this.decrypt(datagram);
-                case types_1.Protocols.RELAY:
-                    return (0, utils_1.decodeData)(yield this.decrypt(datagram));
-                case types_1.Protocols.DISCOVER:
-                    return types_1.UserId.from((0, utils_1.decodeData)(yield this.decrypt(datagram)));
-                default:
-                    throw new Error("Invalid protocol");
-            }
-        });
-    }
-}
-exports.FreeSignalNode = FreeSignalNode;

package/test.js

@@ -1,25 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@freesignal/utils");
-const _1 = require(".");
-const node_1 = require("./node");
-const bob = new node_1.FreeSignalNode({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap() });
-const alice = new node_1.FreeSignalNode({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap() });
-setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
-    const aliceHandshake = yield alice.sendHandshake(yield bob.generateKeyData());
-    yield bob.receive(aliceHandshake);
-    console.log("Session established successfully between Alice and Bob.");
-    const data = (yield bob.encrypt(alice.userId.toString(), _1.Protocols.MESSAGE, (0, utils_1.encodeData)("Hi Alice!"))).toBytes();
-    console.log((0, utils_1.decodeData)(yield alice.receive(data)));
-    const longmsg = yield alice.sendData(bob.userId.toString(), new Uint8Array(1000000).fill(33).map(val => val + Math.floor(Math.random() * 93)));
-    console.log(longmsg.toBytes().length);
-}));