@freesignal/protocol 0.3.2 → 0.4.0

package/dist/double-ratchet.d.ts

@@ -16,8 +16,6 @@
  * 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 { LocalStorage } from "@freesignal/interfaces";
-import { EncryptedData } from "./types";
 export interface ExportedKeySession {
     secretKey: string;
     rootKey?: string;
@@ -25,6 +23,14 @@ export interface ExportedKeySession {
     receivingChain?: ExportedKeyChain;
     previousKeys: [string, Uint8Array][];
 }
+export interface EncryptionKeys {
+    readonly count: number;
+    readonly previous: number;
+    readonly publicKey: Uint8Array;
+}
+export interface PrivateEncryptionKeys extends EncryptionKeys {
+    readonly secretKey: Uint8Array;
+}
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
@@ -33,36 +39,22 @@ export declare class KeySession {
     static readonly keyLength = 32;
     static readonly version = 1;
     static readonly info: string;
+    static readonly maxCount = 65536;
     readonly id: string;
-    private readonly mutex;
-    private readonly storage;
     private keyPair;
     private rootKey?;
     private sendingChain?;
     private receivingChain?;
     private previousKeys;
-    constructor(storage: LocalStorage<string, ExportedKeySession>, opts?: {
+    constructor(opts?: {
         id?: string;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
         rootKey?: Uint8Array;
     });
     private getChain;
-    private save;
-    /**
-     * 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: Uint8Array): Promise<EncryptedData>;
-    /**
-     * Decrypts an encrypted message.
-     *
-     * @param payload - The received encrypted message.
-     * @returns The decrypted message as a Uint8Array, or undefined if decryption fails.
-     */
-    decrypt(payload: Uint8Array | EncryptedData): Promise<Uint8Array>;
+    getSendingKey(): PrivateEncryptionKeys | undefined;
+    getReceivingKey(encryptionKeys: EncryptionKeys): Uint8Array | undefined;
     /**
      * Whether both the sending and receiving chains are initialized.
      */
@@ -81,7 +73,7 @@ export declare class KeySession {
      * @param json string returned by `export()` method.
      * @returns session with the state parsed.
      */
-    static from(data: ExportedKeySession, storage: LocalStorage<string, ExportedKeySession>): KeySession;
+    static from(data: ExportedKeySession): KeySession;
 }
 interface ExportedKeyChain {
     publicKey: string;
@@ -90,32 +82,4 @@ interface ExportedKeyChain {
     count: number;
     previousCount: number;
 }
-export declare class EncryptedDataConstructor implements EncryptedData {
-    static readonly secretKeyLength: number;
-    static readonly publicKeyLength: number;
-    static readonly keyLength: number;
-    static readonly nonceLength: number;
-    static readonly maxCount = 65536;
-    static readonly countLength = 2;
-    private raw;
-    constructor(count: number | Uint8Array, previous: number | Uint8Array, publicKey: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array, version?: number | Uint8Array);
-    constructor(encrypted: Uint8Array | EncryptedData);
-    get length(): number;
-    get version(): number;
-    get count(): number;
-    get previous(): number;
-    get publicKey(): Uint8Array;
-    get nonce(): Uint8Array;
-    get ciphertext(): Uint8Array;
-    toBytes(): Uint8Array;
-    toString(): string;
-    toJSON(): {
-        version: number;
-        count: number;
-        previous: number;
-        publicKey: string;
-        nonce: string;
-        ciphertext: string;
-    };
-}
 export {};

package/dist/double-ratchet.js

@@ -17,84 +17,20 @@
  * 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 __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 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;
+exports.KeySession = void 0;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const utils_1 = require("@freesignal/utils");
-const types_1 = require("./types");
-const semaphore_ts_1 = require("semaphore.ts");
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
  */
 class KeySession {
-    constructor(storage, opts = {}) {
+    constructor(opts = {}) {
         var _a;
-        this.mutex = { sending: new semaphore_ts_1.AsyncMutex(), receiving: new semaphore_ts_1.AsyncMutex() };
         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);
@@ -103,8 +39,6 @@ class KeySession {
         if (opts.remoteKey) {
             this.sendingChain = this.getChain(opts.remoteKey);
         }
-        this.storage = storage;
-        this.save();
     }
     getChain(remoteKey, previousCount) {
         const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, remoteKey);
@@ -114,75 +48,38 @@ class KeySession {
         this.rootKey = hashkey.subarray(0, KeySession.keyLength);
         return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength), previousCount);
     }
-    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 env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const lock = __addDisposableResource(env_1, yield this.mutex.sending.acquire(), false);
-                if (!this.sendingChain)
-                    throw new Error("SendingChain not initialized");
-                const key = this.sendingChain.getKey();
-                const nonce = crypto_1.default.randomBytes(EncryptedDataConstructor.nonceLength);
-                const ciphertext = crypto_1.default.box.encrypt(message, nonce, key);
-                this.save();
-                return new EncryptedDataConstructor(this.sendingChain.count, this.sendingChain.previousCount, this.keyPair.publicKey, nonce, ciphertext);
-            }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                __disposeResources(env_1);
-            }
-        });
+    getSendingKey() {
+        if (!this.sendingChain)
+            return;
+        const secretKey = this.sendingChain.getKey();
+        return {
+            //version: KeySession.version,
+            count: this.sendingChain.count,
+            previous: this.sendingChain.previousCount,
+            publicKey: this.sendingChain.publicKey,
+            secretKey
+        };
     }
-    /**
-     * 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* () {
-            var _a, _b, _c;
-            const encrypted = types_1.EncryptedData.from(payload);
-            if (!this.previousKeys.has((0, utils_1.decodeBase64)(encrypted.publicKey) + encrypted.count.toString())) {
-                const lock = yield this.mutex.receiving.acquire();
-                if (!(0, utils_1.compareBytes)(encrypted.publicKey, (_b = (_a = this.receivingChain) === null || _a === void 0 ? void 0 : _a.remoteKey) !== null && _b !== void 0 ? _b : new Uint8Array())) {
-                    while (this.receivingChain && this.receivingChain.count < encrypted.previous) {
-                        const key = this.receivingChain.getKey();
-                        this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
-                    }
-                    this.receivingChain = this.getChain(encrypted.publicKey);
-                    this.keyPair = crypto_1.default.ECDH.keyPair();
-                    this.sendingChain = this.getChain(encrypted.publicKey, (_c = this.sendingChain) === null || _c === void 0 ? void 0 : _c.count);
-                }
-                if (!this.receivingChain)
-                    throw new Error("Error initializing receivingChain");
-                while (this.receivingChain.count < encrypted.count) {
+    getReceivingKey(encryptionKeys) {
+        var _a, _b, _c;
+        if (!this.previousKeys.has((0, utils_1.decodeBase64)(encryptionKeys.publicKey) + encryptionKeys.count.toString())) {
+            if (!(0, utils_1.compareBytes)(encryptionKeys.publicKey, (_b = (_a = this.receivingChain) === null || _a === void 0 ? void 0 : _a.remoteKey) !== null && _b !== void 0 ? _b : new Uint8Array())) {
+                while (this.receivingChain && this.receivingChain.count < encryptionKeys.previous) {
                     const key = this.receivingChain.getKey();
                     this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
                 }
-                lock.release();
+                this.receivingChain = this.getChain(encryptionKeys.publicKey);
+                this.keyPair = crypto_1.default.ECDH.keyPair();
+                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_c = this.sendingChain) === null || _c === void 0 ? void 0 : _c.count);
+            }
+            if (!this.receivingChain)
+                throw new Error("Error initializing receivingChain");
+            while (this.receivingChain.count < encryptionKeys.count) {
+                const key = this.receivingChain.getKey();
+                this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
             }
-            const key = this.previousKeys.get((0, utils_1.decodeBase64)(encrypted.publicKey) + encrypted.count.toString());
-            if (!key)
-                throw new Error("Error calculating key");
-            this.save();
-            const cleartext = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key);
-            if (!cleartext)
-                throw new Error("Error decrypting ciphertext");
-            return cleartext;
-        });
+        }
+        return this.previousKeys.get((0, utils_1.decodeBase64)(encryptionKeys.publicKey) + encryptionKeys.count.toString());
     }
     /**
      * Whether both the sending and receiving chains are initialized.
@@ -211,13 +108,11 @@ class KeySession {
      * @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: data.rootKey ? (0, utils_1.encodeBase64)(data.rootKey) : undefined });
-        //session._remoteKey = data.remoteKey ? encodeBase64(data.remoteKey) : undefined;
+    static from(data) {
+        const session = new KeySession({ secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: data.rootKey ? (0, utils_1.encodeBase64)(data.rootKey) : undefined });
         session.sendingChain = data.sendingChain ? KeyChain.from(data.sendingChain) : undefined;
         session.receivingChain = data.receivingChain ? KeyChain.from(data.receivingChain) : undefined;
         session.previousKeys = new KeyMap(data.previousKeys);
-        session.save();
         return session;
     }
 }
@@ -225,6 +120,7 @@ exports.KeySession = KeySession;
 KeySession.keyLength = 32;
 KeySession.version = 1;
 KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
+KeySession.maxCount = 65536;
 class KeyChain {
     constructor(publicKey, remoteKey, chainKey, previousCount = 0) {
         this.publicKey = publicKey;
@@ -234,7 +130,7 @@ class KeyChain {
         this._count = 0;
     }
     getKey() {
-        if (++this._count >= EncryptedDataConstructor.maxCount)
+        if (++this._count >= KeySession.maxCount)
             throw new Error("SendingChain count too big");
         const hash = crypto_1.default.hkdf(this.chainKey, new Uint8Array(KeySession.keyLength).fill(0), KeySession.info, KeySession.keyLength * 2);
         this.chainKey = hash.subarray(0, KeySession.keyLength);
@@ -261,80 +157,6 @@ class KeyChain {
         return chain;
     }
 }
-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.numberToBytes)(arrays[0], EncryptedDataConstructor.countLength);
-        if (typeof arrays[1] === 'number')
-            arrays[1] = (0, utils_1.numberToBytes)(arrays[1], EncryptedDataConstructor.countLength);
-        if (arrays.length === 6) {
-            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToBytes)(arrays[5], 1) : arrays[5]);
-            arrays.pop();
-        }
-        else if (arrays.length > 1) {
-            arrays.unshift((0, utils_1.numberToBytes)(KeySession.version, 1));
-        }
-        this.raw = (0, utils_1.concatBytes)(...arrays);
-    }
-    get length() { return this.raw.length; }
-    get version() { return (0, utils_1.bytesToNumber)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
-    get count() { return (0, utils_1.bytesToNumber)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
-    get previous() { return (0, utils_1.bytesToNumber)(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);

package/dist/node.d.ts

@@ -1,3 +1,21 @@
+/**
+ * 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 { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
 import { Datagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
 import { KeyExchange } from "./x3dh";

package/dist/node.js

@@ -1,4 +1,22 @@
 "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) {
@@ -58,7 +76,7 @@ class FreeSignalNode {
         this.bootstraps = new Set();
         this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
         this.sessions = new SessionMap(storage.sessions);
-        this.keyExchange = new x3dh_1.KeyExchange({ keys: storage.keyExchange, sessions: storage.sessions }, this.privateIdentityKey);
+        this.keyExchange = new x3dh_1.KeyExchange(storage.keyExchange, this.privateIdentityKey);
         this.users = storage.users;
         this.bundles = storage.bundles;
     }
@@ -78,7 +96,9 @@ class FreeSignalNode {
             const session = yield 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)).sign(this.privateIdentityKey.signatureKey);
+            const encrypted = (0, types_1.encryptData)(session, data);
+            this.sessions.set(receiverId, session);
+            return new types_1.Datagram(this.userId.toString(), receiverId, protocol, encrypted).sign(this.privateIdentityKey.signatureKey);
         });
     }
     packHandshake(data) {
@@ -127,9 +147,8 @@ class FreeSignalNode {
                 throw new Error("Session not found for user: " + datagram.sender);
             if (!datagram.payload)
                 throw new Error("Missing payload");
-            const decrypted = yield session.decrypt(datagram.payload);
-            if (!decrypted)
-                throw new Error("Decryption failed");
+            const decrypted = (0, types_1.decryptData)(session, datagram.payload);
+            this.sessions.set(datagram.sender, session);
             return decrypted;
         });
     }
@@ -220,7 +239,7 @@ class SessionMap {
                 const sessionData = yield this.storage.get(key);
                 if (!sessionData)
                     return undefined;
-                return double_ratchet_1.KeySession.from(sessionData, this.storage);
+                return double_ratchet_1.KeySession.from(sessionData);
             }
             return session;
         });

package/dist/types.d.ts

@@ -17,6 +17,9 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { LocalStorage, Encodable, KeyExchangeData } from "@freesignal/interfaces";
+import { KeySession } from "./double-ratchet";
+export declare function encryptData(session: KeySession, data: Uint8Array): EncryptedData;
+export declare function decryptData(session: KeySession, encryptedData: Uint8Array): Uint8Array;
 export declare class UserId implements Encodable {
     private readonly array;
     private constructor();
@@ -167,14 +170,14 @@ export interface EncryptedData extends Encodable {
         ciphertext: string;
     };
 }
-export declare class EncryptedData {
+export declare namespace EncryptedData {
     /**
      * Static factory method that constructs an `EncryptedPayload` from a raw Uint8Array.
      *
      * @param array - A previously serialized encrypted payload.
      * @returns An instance of `EncryptedPayload`.
      */
-    static from(array: Uint8Array | EncryptedData): EncryptedData;
+    function from(array: Uint8Array | EncryptedData): EncryptedData;
 }
 export declare class AsyncMap<K, V> implements LocalStorage<K, V> {
     private readonly map;

package/dist/types.js

@@ -31,9 +31,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncMap = exports.EncryptedData = exports.Datagram = exports.Protocols = exports.DiscoverType = exports.PrivateIdentityKey = exports.IdentityKey = exports.UserId = void 0;
+exports.encryptData = encryptData;
+exports.decryptData = decryptData;
 const utils_1 = require("@freesignal/utils");
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const double_ratchet_1 = require("./double-ratchet");
+function encryptData(session, data) {
+    const key = session.getSendingKey();
+    if (!key)
+        throw new Error("Error generating key");
+    const nonce = crypto_1.default.randomBytes(EncryptedDataConstructor.nonceLength);
+    const ciphertext = crypto_1.default.box.encrypt(data, nonce, key.secretKey);
+    return new EncryptedDataConstructor(key.count, key.previous, key.publicKey, nonce, ciphertext);
+}
+function decryptData(session, encryptedData) {
+    const encrypted = EncryptedData.from(encryptedData);
+    const key = session.getReceivingKey(encrypted);
+    if (!key)
+        throw new Error("Error calculating key");
+    const decrypted = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key);
+    if (!decrypted)
+        throw new Error("Error decrypting data");
+    return decrypted;
+}
 class UserId {
     constructor(array) {
         this.array = array;
@@ -300,18 +320,91 @@ class Datagram {
 exports.Datagram = Datagram;
 Datagram.version = 1;
 Datagram.headerOffset = 26 + crypto_1.default.EdDSA.publicKeyLength * 2;
-class EncryptedData {
+var EncryptedData;
+(function (EncryptedData) {
     /**
      * Static factory method that constructs an `EncryptedPayload` from a raw Uint8Array.
      *
      * @param array - A previously serialized encrypted payload.
      * @returns An instance of `EncryptedPayload`.
      */
-    static from(array) {
-        return new double_ratchet_1.EncryptedDataConstructor(array);
+    function from(array) {
+        return new EncryptedDataConstructor(array);
+    }
+    EncryptedData.from = from;
+})(EncryptedData || (exports.EncryptedData = EncryptedData = {}));
+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.numberToBytes)(arrays[0], EncryptedDataConstructor.countLength);
+        if (typeof arrays[1] === 'number')
+            arrays[1] = (0, utils_1.numberToBytes)(arrays[1], EncryptedDataConstructor.countLength);
+        if (arrays.length === 6) {
+            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToBytes)(arrays[5], 1) : arrays[5]);
+            arrays.pop();
+        }
+        else if (arrays.length > 1) {
+            arrays.unshift((0, utils_1.numberToBytes)(double_ratchet_1.KeySession.version, 1));
+        }
+        this.raw = (0, utils_1.concatBytes)(...arrays);
+    }
+    get length() { return this.raw.length; }
+    get version() { return (0, utils_1.bytesToNumber)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
+    get count() { return (0, utils_1.bytesToNumber)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
+    get previous() { return (0, utils_1.bytesToNumber)(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)
+        };
+    }
+}
+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.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);
     }
 }
-exports.EncryptedData = EncryptedData;
+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 AsyncMap {
     constructor(iterable) {
         this.map = new Map(iterable);

package/dist/x3dh.d.ts

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, LocalStorage, Crypto } from "@freesignal/interfaces";
-import { ExportedKeySession, KeySession } from "./double-ratchet";
+import { KeySession } from "./double-ratchet";
 import { IdentityKey, PrivateIdentityKey } from "./types";
 export interface ExportedKeyExchange {
     privateIdentityKey: PrivateIdentityKey;
@@ -29,11 +29,7 @@ export declare class KeyExchange {
     private static readonly maxOPK;
     private readonly privateIdentityKey;
     private readonly storage;
-    private readonly sessions;
-    constructor(storage: {
-        keys: LocalStorage<string, Crypto.KeyPair>;
-        sessions: LocalStorage<string, ExportedKeySession>;
-    }, privateIdentityKey?: PrivateIdentityKey);
+    constructor(storage: LocalStorage<string, Crypto.KeyPair>, privateIdentityKey?: PrivateIdentityKey);
     get identityKey(): IdentityKey;
     private generateSPK;
     private generateOPK;

package/dist/x3dh.js

@@ -38,8 +38,7 @@ const types_1 = require("./types");
 const _1 = require(".");
 class KeyExchange {
     constructor(storage, privateIdentityKey) {
-        this.storage = storage.keys;
-        this.sessions = storage.sessions;
+        this.storage = storage;
         this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
     }
     get identityKey() {
@@ -99,9 +98,9 @@ class KeyExchange {
                 ...crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, signedPreKey),
                 ...onetimePreKey ? crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, onetimePreKey) : new Uint8Array()
             ]), new Uint8Array(double_ratchet_1.KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.keyLength);
-            const session = new double_ratchet_1.KeySession(this.sessions, { remoteKey: identityKey.exchangeKey, rootKey });
-            const cyphertext = yield session.encrypt((0, utils_1.concatBytes)(crypto_1.default.hash(this.identityKey.toBytes()), crypto_1.default.hash(identityKey.toBytes()), associatedData !== null && associatedData !== void 0 ? associatedData : new Uint8Array()));
-            if (!cyphertext)
+            const session = new double_ratchet_1.KeySession({ remoteKey: identityKey.exchangeKey, rootKey });
+            const encrypted = (0, types_1.encryptData)(session, (0, utils_1.concatBytes)(crypto_1.default.hash(this.identityKey.toBytes()), crypto_1.default.hash(identityKey.toBytes()), associatedData !== null && associatedData !== void 0 ? associatedData : new Uint8Array()));
+            if (!encrypted)
                 throw new Error("Decryption error");
             return {
                 session,
@@ -111,7 +110,7 @@ class KeyExchange {
                     ephemeralKey: (0, utils_1.decodeBase64)(ephemeralKey.publicKey),
                     signedPreKeyHash: (0, utils_1.decodeBase64)(signedPreKeyHash),
                     onetimePreKeyHash: (0, utils_1.decodeBase64)(onetimePreKeyHash),
-                    associatedData: (0, utils_1.decodeBase64)(cyphertext.toBytes())
+                    associatedData: (0, utils_1.decodeBase64)(encrypted.toBytes())
                 },
                 identityKey
             };
@@ -134,16 +133,16 @@ class KeyExchange {
                 ...crypto_1.default.ECDH.scalarMult(signedPreKey.secretKey, ephemeralKey),
                 ...onetimePreKey ? crypto_1.default.ECDH.scalarMult(onetimePreKey.secretKey, ephemeralKey) : new Uint8Array()
             ]), new Uint8Array(double_ratchet_1.KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.keyLength);
-            const session = new double_ratchet_1.KeySession(this.sessions, { secretKey: this.privateIdentityKey.exchangeKey, rootKey });
-            const cleartext = yield session.decrypt((0, utils_1.encodeBase64)(message.associatedData));
-            if (!cleartext)
+            const session = new double_ratchet_1.KeySession({ secretKey: this.privateIdentityKey.exchangeKey, rootKey });
+            const data = (0, types_1.decryptData)(session, (0, utils_1.encodeBase64)(message.associatedData));
+            if (!data)
                 throw new Error("Error decrypting ACK message");
-            if (!(0, utils_1.compareBytes)(cleartext.subarray(0, 64), (0, utils_1.concatBytes)(crypto_1.default.hash(identityKey.toBytes()), crypto_1.default.hash(this.identityKey.toBytes()))))
+            if (!(0, utils_1.compareBytes)(data.subarray(0, 64), (0, utils_1.concatBytes)(crypto_1.default.hash(identityKey.toBytes()), crypto_1.default.hash(this.identityKey.toBytes()))))
                 throw new Error("Error verifing Associated Data");
             return {
                 session,
                 identityKey,
-                associatedData: cleartext.subarray(64)
+                associatedData: data.subarray(64)
             };
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -8,22 +8,22 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
     "./double-ratchet": {
       "import": "./dist/double-ratchet.js",
+      "require": "./dist/double-ratchet.js",
       "types": "./dist/double-ratchet.d.ts"
     },
     "./node": {
       "import": "./dist/node.js",
+      "require": "./dist/node.js",
       "types": "./dist/node.d.ts"
     },
-    "./types": {
-      "import": "./dist/types.js",
-      "types": "./dist/types.d.ts"
-    },
     "./x3dh": {
       "import": "./dist/x3dh.js",
+      "require": "./dist/x3dh.js",
       "types": "./dist/x3dh.d.ts"
     }
   },