@freesignal/protocol 0.1.0 → 0.1.5

package/double-ratchet.js

@@ -21,37 +21,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncryptedPayload = exports.Session = void 0;
-exports.createSession = createSession;
+exports.EncryptedData = exports.KeySession = void 0;
 const crypto_1 = __importDefault(require("./crypto"));
 const utils_1 = require("./utils");
-/**
- * Creates a new Double Ratchet session.
- *
- * @param opts.remoteKey The public key of the remote party.
- * @param opts.preSharedKey An optional pre-shared key to initialize the session.
- *
- * @returns A new Double Ratchet session.
- */
-function createSession(opts) {
-    return new Session(opts);
-}
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
  */
-class Session {
+class KeySession {
     constructor(opts = {}) {
-        this.keyPair = crypto_1.default.ECDH.keyPair();
         this.sendingCount = 0;
         this.previousCount = 0;
         this.receivingCount = 0;
         this.previousKeys = new KeyMap();
-        if (opts.preSharedKey)
-            this.rootKey = opts.preSharedKey;
+        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.dhRatchet();
+            this.sendingChain = this.ratchetKeys();
         }
     }
     /**
@@ -66,46 +54,43 @@ class Session {
      * The last known remote public key.
      */
     get remoteKey() { return this._remoteKey; }
-    /**
-     * Set remote public key.
-     */
     setRemoteKey(key) {
         this._remoteKey = key;
-        this.receivingChain = this.dhRatchet();
-        if (this.receivingCount > (EncryptedPayloadConstructor.maxCount - Session.skipLimit * 2))
+        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.dhRatchet();
-        if (this.sendingCount > (EncryptedPayloadConstructor.maxCount - Session.skipLimit * 2))
+        this.sendingChain = this.ratchetKeys();
+        if (this.sendingCount > (EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
             this.sendingCount = 0;
         return this;
     }
-    dhRatchet(info) {
+    ratchetKeys(info) {
         if (!this._remoteKey)
             throw new Error();
         const sharedKey = crypto_1.default.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, Session.keyLength * 2);
-        this.rootKey = hashkey.slice(0, Session.keyLength);
-        return hashkey.slice(Session.keyLength);
+        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 out = Session.symmetricRatchet(this.sendingChain);
-        this.sendingChain = out[0];
+        const { chainKey, sharedKey } = KeySession.symmetricRatchet(this.sendingChain);
+        this.sendingChain = chainKey;
         this.sendingCount++;
-        return out[1];
+        return sharedKey;
     }
     getReceivingKey() {
         if (!this.receivingChain)
             throw new Error();
-        const out = Session.symmetricRatchet(this.receivingChain);
-        this.receivingChain = out[0];
+        const { chainKey, sharedKey } = KeySession.symmetricRatchet(this.receivingChain);
+        this.receivingChain = chainKey;
         this.receivingCount++;
-        return out[1];
+        return sharedKey;
     }
     /**
      * Encrypts a message payload using the current sending chain.
@@ -114,17 +99,12 @@ class Session {
      * @returns An EncryptedPayload or undefined if encryption fails.
      */
     encrypt(message) {
-        try {
-            const key = this.getSendingKey();
-            if (this.sendingCount >= EncryptedPayloadConstructor.maxCount || this.previousCount >= EncryptedPayloadConstructor.maxCount)
-                throw new Error();
-            const nonce = crypto_1.default.randomBytes(EncryptedPayloadConstructor.nonceLength);
-            const ciphertext = crypto_1.default.box.encrypt(message, nonce, key);
-            return new EncryptedPayloadConstructor(this.sendingCount, this.previousCount, this.keyPair.publicKey, nonce, ciphertext);
-        }
-        catch (error) {
-            return undefined;
-        }
+        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);
+        return new EncryptedDataConstructor(this.sendingCount, this.previousCount, this.keyPair.publicKey, nonce, ciphertext);
     }
     /**
      * Decrypts an encrypted message.
@@ -134,47 +114,44 @@ class Session {
      */
     decrypt(payload) {
         var _a;
-        try {
-            const encrypted = EncryptedPayload.from(payload);
-            const publicKey = encrypted.publicKey;
-            if (!(0, utils_1.verifyUint8Array)(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 < Session.skipLimit) {
-                    this.previousKeys.set(this.receivingCount, this.getReceivingKey());
-                }
-                key = this.getReceivingKey();
-            }
-            else {
-                key = this.previousKeys.get(count);
+        const encrypted = EncryptedData.from(payload);
+        const publicKey = encrypted.publicKey;
+        if (!(0, utils_1.verifyUint8Array)(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());
             }
-            if (!key)
-                return undefined;
-            return (_a = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key)) !== null && _a !== void 0 ? _a : undefined;
+            key = this.getReceivingKey();
         }
-        catch (error) {
-            return undefined;
+        else {
+            key = this.previousKeys.get(count);
         }
+        if (!key)
+            return undefined;
+        return (_a = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key)) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Export the state of the session;
      */
     export() {
-        return JSON.stringify({
+        return {
+            secretKey: (0, utils_1.encodeBase64)((0, utils_1.concatUint8Array)(this.keyPair.secretKey)),
             remoteKey: (0, utils_1.encodeBase64)(this._remoteKey),
             rootKey: (0, utils_1.encodeBase64)(this.rootKey),
             sendingChain: (0, utils_1.encodeBase64)(this.sendingChain),
             receivingChain: (0, utils_1.encodeBase64)(this.receivingChain),
             sendingCount: this.sendingCount,
             receivingCount: this.receivingCount,
-            //previousCount: this.previousCount
-        });
+            previousCount: this.previousCount,
+            previousKeys: Array.from(this.previousKeys.entries())
+        };
     }
     /**
      * Import a state.
@@ -184,28 +161,34 @@ class Session {
      */
     static import(json) {
         const data = JSON.parse(json);
-        const session = new Session({ remoteKey: (0, utils_1.decodeBase64)(data.remoteKey), preSharedKey: (0, utils_1.decodeBase64)(data.rootKey) });
+        const session = new KeySession({ secretKey: (0, utils_1.decodeBase64)(data.secretKey), rootKey: (0, utils_1.decodeBase64)(data.rootKey) });
+        session._remoteKey = (0, utils_1.decodeBase64)(data.remoteKey);
         session.sendingChain = (0, utils_1.decodeBase64)(data.sendingChain);
         session.receivingChain = (0, utils_1.decodeBase64)(data.receivingChain);
         session.sendingCount = data.sendingCount;
         session.receivingCount = data.receivingCount;
+        session.previousCount = data.previousCount;
+        session.previousKeys = new KeyMap(data.previousKeys);
         return session;
     }
     static symmetricRatchet(chain, salt, info) {
-        const hash = crypto_1.default.hkdf(chain, salt !== null && salt !== void 0 ? salt : new Uint8Array(), info, Session.keyLength * 2);
-        return [new Uint8Array(hash.buffer, 0, Session.keyLength), new Uint8Array(hash.buffer, Session.keyLength)];
+        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.Session = Session;
-Session.skipLimit = 1000;
-Session.version = 1;
-Session.rootKeyLength = crypto_1.default.box.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.
  */
-Session.keyLength = 32;
-class EncryptedPayload {
+KeySession.keyLength = 32;
+class EncryptedData {
     /**
      * Static factory method that constructs an `EncryptedPayload` from a raw Uint8Array.
      *
@@ -213,24 +196,27 @@ class EncryptedPayload {
      * @returns An instance of `EncryptedPayload`.
      */
     static from(array) {
-        return new EncryptedPayloadConstructor(array);
+        return new EncryptedDataConstructor(array);
     }
 }
-exports.EncryptedPayload = EncryptedPayload;
-class EncryptedPayloadConstructor {
+exports.EncryptedData = EncryptedData;
+class EncryptedDataConstructor {
     constructor(...arrays) {
-        var _a;
         arrays = arrays.filter(value => value !== undefined);
-        if (arrays[0] instanceof EncryptedPayloadConstructor) {
+        if (arrays[0] instanceof EncryptedDataConstructor) {
             this.raw = arrays[0].raw;
             return this;
         }
         if (typeof arrays[0] === 'number')
-            arrays[0] = (0, utils_1.numberToUint8Array)(arrays[0], EncryptedPayloadConstructor.countLength);
+            arrays[0] = (0, utils_1.numberToUint8Array)(arrays[0], EncryptedDataConstructor.countLength);
         if (typeof arrays[1] === 'number')
-            arrays[1] = (0, utils_1.numberToUint8Array)(arrays[1], EncryptedPayloadConstructor.countLength);
-        if (arrays.length > 1) {
-            arrays.unshift((_a = (typeof arrays[5] === 'number' ? (0, utils_1.numberToUint8Array)(arrays[5]) : arrays[5])) !== null && _a !== void 0 ? _a : (0, utils_1.numberToUint8Array)(Session.version));
+            arrays[1] = (0, utils_1.numberToUint8Array)(arrays[1], EncryptedDataConstructor.countLength);
+        if (arrays.length === 6) {
+            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToUint8Array)(arrays[5]) : arrays[5]);
+            arrays.pop();
+        }
+        else if (arrays.length > 1) {
+            arrays.unshift((0, utils_1.numberToUint8Array)(KeySession.version));
         }
         this.raw = (0, utils_1.concatUint8Array)(...arrays);
     }
@@ -241,32 +227,6 @@ class EncryptedPayloadConstructor {
     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); }
-    /*public get signature() { return this.signed ? new Uint8Array(this.raw.buffer, this.raw.length - EncryptedPayloadConstructor.signatureLength) : undefined }
-
-    public setSignature(signature: Uint8Array): this {
-        this.raw = concatUint8Array(this.raw, signature);
-        this.signed = true;
-        return this;
-    }
-
-    public encodeUnsigned(): Uint8Array {
-        return !this.signed ? this.raw : new Uint8Array(this.raw.buffer, 0, this.raw.length - EncryptedPayloadConstructor.signatureLength);
-    }
-
-    public encode(fixedLength?: number): Uint8Array {
-        if (fixedLength) {
-            var padStart = Math.floor(Math.random() * fixedLength - 2 - this.raw.length);
-            var padEnd = Math.floor(padStart + 2 + this.raw.length);
-        } else {
-            padStart = Math.floor(Math.random() * (EncryptedPayloadConstructor.maxPadLength - EncryptedPayloadConstructor.minPadLength) + 1) + EncryptedPayloadConstructor.minPadLength;
-            padEnd = Math.floor(Math.random() * (EncryptedPayloadConstructor.maxPadLength - EncryptedPayloadConstructor.minPadLength) + 1) + EncryptedPayloadConstructor.minPadLength;
-        }
-        return concatUint8Array(
-            randomBytes(padStart - 1).map((value) => value !== 255 ? value : (value - 1)),
-            new Uint8Array(1).fill(255), this.raw, new Uint8Array(1).fill(255),
-            randomBytes(padEnd).map((value) => value !== 255 ? value : (value - 1)),
-        );
-    }*/
     encode() {
         return this.raw;
     }
@@ -277,26 +237,22 @@ class EncryptedPayloadConstructor {
             previous: this.previous,
             publicKey: (0, utils_1.encodeBase64)(this.publicKey),
             nonce: (0, utils_1.encodeBase64)(this.nonce),
-            ciphertext: (0, utils_1.encodeUTF8)(this.ciphertext),
-            //signature: encodeBase64(this.signature)
+            ciphertext: (0, utils_1.encodeBase64)(this.ciphertext)
         };
     }
     toString() {
-        return (0, utils_1.encodeUTF8)(this.raw);
+        return (0, utils_1.encodeBase64)(this.raw);
     }
     toJSON() {
         return JSON.stringify(this.decode());
     }
 }
-//public static readonly signatureLength = crypto.EdDSA.signatureLength;
-EncryptedPayloadConstructor.secretKeyLength = crypto_1.default.ECDH.secretKeyLength;
-EncryptedPayloadConstructor.publicKeyLength = crypto_1.default.ECDH.publicKeyLength;
-EncryptedPayloadConstructor.keyLength = crypto_1.default.box.keyLength;
-EncryptedPayloadConstructor.nonceLength = crypto_1.default.box.nonceLength;
-//public static readonly minPadLength = 6;
-//public static readonly maxPadLength = 14;
-EncryptedPayloadConstructor.maxCount = 65536; //32768;
-EncryptedPayloadConstructor.countLength = 2;
+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 {
@@ -315,20 +271,12 @@ class Offsets {
 }
 Offsets.checksum = Offsets.set(0, 0);
 Offsets.version = Offsets.set(Offsets.checksum.end, 1);
-Offsets.count = Offsets.set(Offsets.version.end, EncryptedPayloadConstructor.countLength);
-Offsets.previous = Offsets.set(Offsets.count.end, EncryptedPayloadConstructor.countLength);
-Offsets.publicKey = Offsets.set(Offsets.previous.end, EncryptedPayloadConstructor.publicKeyLength);
-Offsets.nonce = Offsets.set(Offsets.publicKey.end, EncryptedPayloadConstructor.nonceLength);
+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 {
-    constructor(iterable) {
-        return new KeyMapConstructor(iterable);
-    }
-}
-class KeyMapConstructor extends Map {
-    constructor(iterable) {
-        super(iterable);
-    }
+class KeyMap extends Map {
     get(key) {
         const out = super.get(key);
         if (out && !super.delete(key))

package/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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/>
+ */
+import crypto from "./crypto";
+import { LocalStorage } from "./types";
+import { KeySession } from "./double-ratchet";
+import { KeyExchange } from "./x3dh";
+/**
+ * Creates a new Double Ratchet session.
+ *
+ * @param opts.remoteKey The public key of the remote party.
+ * @param opts.preSharedKey An optional pre-shared key to initialize the session.
+ *
+ * @returns A new Double Ratchet session.
+ */
+export declare function createKeySession(opts?: {
+    secretKey?: Uint8Array;
+    remoteKey?: Uint8Array;
+    rootKey?: Uint8Array;
+}): KeySession;
+/**
+ * Creates a new X3DH session.
+ *
+ * @param signKeyPair
+ * @param bundleStore
+ * @returns A new X3DH session.
+ */
+export declare function createKeyExchange(signSecretKey: Uint8Array, boxSecretKey: Uint8Array, bundleStore?: LocalStorage<string, crypto.KeyPair>): KeyExchange;
+export * from "./types";
+export { Protocols, Datagram } from "./data";
+export { EncryptedData } from "./double-ratchet";

package/index.js

@@ -0,0 +1,66 @@
+"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 __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 });
+exports.EncryptedData = exports.Datagram = exports.Protocols = void 0;
+exports.createKeySession = createKeySession;
+exports.createKeyExchange = createKeyExchange;
+const double_ratchet_1 = require("./double-ratchet");
+const x3dh_1 = require("./x3dh");
+/**
+ * Creates a new Double Ratchet session.
+ *
+ * @param opts.remoteKey The public key of the remote party.
+ * @param opts.preSharedKey An optional pre-shared key to initialize the session.
+ *
+ * @returns A new Double Ratchet session.
+ */
+function createKeySession(opts) {
+    return new double_ratchet_1.KeySession(opts);
+}
+/**
+ * Creates a new X3DH session.
+ *
+ * @param signKeyPair
+ * @param bundleStore
+ * @returns A new X3DH session.
+ */
+function createKeyExchange(signSecretKey, boxSecretKey, bundleStore) {
+    return new x3dh_1.KeyExchange(signSecretKey, boxSecretKey, bundleStore);
+}
+__exportStar(require("./types"), exports);
+var data_1 = require("./data");
+Object.defineProperty(exports, "Protocols", { enumerable: true, get: function () { return data_1.Protocols; } });
+Object.defineProperty(exports, "Datagram", { enumerable: true, get: function () { return data_1.Datagram; } });
+var double_ratchet_2 = require("./double-ratchet");
+Object.defineProperty(exports, "EncryptedData", { enumerable: true, get: function () { return double_ratchet_2.EncryptedData; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -12,6 +12,7 @@
   },
   "dependencies": {
     "base64-js": "^1.5.1",
+    "fflate": "^0.8.2",
     "js-sha3": "^0.9.3",
     "tweetnacl": "^1.0.3",
     "uuid": "^11.1.0"

package/test.js

@@ -2,16 +2,30 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-const x3dh_1 = require("./x3dh");
+const _1 = require(".");
 const crypto_1 = __importDefault(require("./crypto"));
+const data_1 = require("./data");
 const utils_1 = require("./utils");
-const bob = new x3dh_1.X3DH(crypto_1.default.EdDSA.keyPair());
-const alice = new x3dh_1.X3DH(crypto_1.default.EdDSA.keyPair());
-const bobmessage = bob.generateSyn();
-const { rootKey, ackMessage: aliceack } = alice.digestSyn(bobmessage);
-if ((0, utils_1.verifyUint8Array)(rootKey, bob.digestAck(aliceack))) {
+const bob = (0, _1.createKeyExchange)(crypto_1.default.EdDSA.keyPair().secretKey, crypto_1.default.ECDH.keyPair().secretKey);
+const alice = (0, _1.createKeyExchange)(crypto_1.default.EdDSA.keyPair().secretKey, crypto_1.default.ECDH.keyPair().secretKey);
+const bobmessage = bob.generateData();
+const { session: alicesession, message: aliceack } = alice.digestData(bobmessage);
+const { session: bobsession, cleartext } = (_a = bob.digestMessage(aliceack)) !== null && _a !== void 0 ? _a : {};
+if (bobsession && cleartext) {
     console.log("Session established successfully between Alice and Bob.");
+    const datagram = data_1.Datagram.create(bob.signatureKey, alice.signatureKey, data_1.Protocols.MESSAGE, (_b = bobsession.encrypt((0, utils_1.decodeUTF8)("Hi Alice!"))) === null || _b === void 0 ? void 0 : _b.encode());
+    //console.log(datagram.payload);
+    const msg = datagram.encode();
+    console.log((0, utils_1.encodeUTF8)(alicesession.decrypt(data_1.Datagram.from(msg).payload)));
+    if (alicesession.handshaked && bobsession.handshaked)
+        console.log("Successfully handshaked");
+    else
+        console.log("Error during handshake");
+    const longmsg = data_1.Datagram.create(alice.signatureKey, bob.signatureKey, data_1.Protocols.MESSAGE, alicesession.encrypt(new Uint8Array(1000000).fill(33).map(val => val + Math.floor(Math.random() * 93))));
+    console.log(longmsg.encode().length);
+    console.log(longmsg.encode(false).length);
 }
 else
     console.log("Error");

package/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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/>
+ */
+/** */
+export interface Encodable {
+    encode(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+}
+export declare namespace Encodable {
+    function isEncodable(obj: any): boolean;
+}
+type LocalStorageIterator<T> = Iterable<T>;
+export interface LocalStorage<K, T> {
+    set(key: K, value: T): this;
+    get(key: K): T | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    entries(): LocalStorageIterator<[K, T]>;
+}
+export interface KeyExchangeData {
+    readonly version: number;
+    readonly publicKey: string;
+    readonly identityKey: string;
+    readonly signedPreKey: string;
+    readonly signature: string;
+    readonly onetimePreKey: string;
+}
+export interface KeyExchangeSynMessage {
+    readonly version: number;
+    readonly publicKey: string;
+    readonly identityKey: string;
+    readonly ephemeralKey: string;
+    readonly signedPreKeyHash: string;
+    readonly onetimePreKeyHash: string;
+    readonly associatedData: string;
+}
+export interface KeyExchangeDataBundle {
+    readonly version: number;
+    readonly publicKey: string;
+    readonly identityKey: string;
+    readonly signedPreKey: string;
+    readonly signature: string;
+    readonly onetimePreKey: string[];
+}
+export {};

package/types.js

@@ -0,0 +1,29 @@
+"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/>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encodable = void 0;
+var Encodable;
+(function (Encodable) {
+    const properties = ['encode', 'toString', 'toJSON'];
+    function isEncodable(obj) {
+        return !properties.some(prop => !obj[prop]);
+    }
+    Encodable.isEncodable = isEncodable;
+})(Encodable || (exports.Encodable = Encodable = {}));

package/utils.js

@@ -135,6 +135,7 @@ function verifyUint8Array(a, ...b) {
  * @returns A Uint8Array
  */
 function concatUint8Array(...arrays) {
+    //arrays = arrays.filter(array => array != undefined);
     const out = new Uint8Array(arrays.map(value => value.length).reduce((prev, curr) => prev + curr));
     let offset = 0;
     arrays.forEach(array => {