@freesignal/protocol 0.5.6 → 0.6.1

package/dist/double-ratchet.d.ts

@@ -16,7 +16,9 @@
  * 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 { IdentityKey, UserId } from "./types";
 export interface ExportedKeySession {
+    identityKey: string;
     secretKey: string;
     rootKey?: string;
     sendingChain?: ExportedKeyChain;
@@ -40,24 +42,21 @@ export declare class KeySession {
     static readonly version = 1;
     static readonly info: string;
     static readonly maxCount = 65536;
-    readonly id: string;
+    readonly identityKey: IdentityKey;
     private keyPair;
     private rootKey?;
     private sendingChain?;
     private receivingChain?;
     private nextHeaderKey?;
     private previousKeys;
-    constructor(opts?: {
-        id?: string;
+    constructor({ identityKey, secretKey, remoteKey, rootKey }: {
+        identityKey: IdentityKey;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
         rootKey?: Uint8Array;
     });
+    get userId(): UserId;
     private getChain;
-    getHeaderKeys(): {
-        readonly sending?: Uint8Array;
-        readonly receiving?: Uint8Array;
-    };
     getSendingKey(): PrivateEncryptionKeys | undefined;
     getReceivingKey(encryptionKeys: EncryptionKeys): Uint8Array | undefined;
     /**
@@ -84,8 +83,6 @@ interface ExportedKeyChain {
     publicKey: string;
     remoteKey: string;
     chainKey: string;
-    nextHeaderKey: string;
-    headerKey?: string;
     count: number;
     previousCount: number;
 }

package/dist/double-ratchet.js

@@ -24,40 +24,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 {
     //headerKey?: Uint8Array, nextHeaderKey?: Uint8Array,
-    constructor(opts = {}) {
-        var _a;
+    constructor({ identityKey, secretKey, remoteKey, rootKey }) {
         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;
+        this.identityKey = identityKey;
+        this.keyPair = crypto_1.default.ECDH.keyPair(secretKey);
+        if (rootKey)
+            this.rootKey = rootKey;
         //if (opts.nextHeaderKey)
         //    this.nextHeaderKey = opts.nextHeaderKey;
-        if (opts.remoteKey) {
-            this.sendingChain = this.getChain(opts.remoteKey); //, opts.headerKey);
+        if (remoteKey) {
+            this.sendingChain = this.getChain(remoteKey); //, opts.headerKey);
         }
     }
-    getChain(remoteKey, headerKey, previousCount) {
+    get userId() {
+        return this.identityKey.userId;
+    }
+    //headerKey?: Uint8Array,
+    getChain(remoteKey, previousCount) {
         const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, remoteKey);
         if (!this.rootKey)
             this.rootKey = crypto_1.default.hash(sharedKey);
         const hashkey = crypto_1.default.hkdf(sharedKey, this.rootKey, KeySession.info, KeySession.keyLength * 3);
         this.rootKey = hashkey.subarray(0, KeySession.keyLength);
-        return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength, KeySession.keyLength * 2), hashkey.subarray(KeySession.keyLength * 2), headerKey, previousCount);
+        //hashkey.subarray(KeySession.keyLength * 2), headerKey,
+        return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength, KeySession.keyLength * 2), previousCount);
     }
-    getHeaderKeys() {
-        var _a, _b, _c, _d, _e;
+    /*public getHeaderKeys(): {
+        readonly sending?: Uint8Array,
+        readonly receiving?: Uint8Array
+    } {
         return {
-            sending: (_a = this.sendingChain) === null || _a === void 0 ? void 0 : _a.headerKey,
-            receiving: (_e = ((_c = (_b = this.receivingChain) === null || _b === void 0 ? void 0 : _b.headerKey) !== null && _c !== void 0 ? _c : (_d = this.receivingChain) === null || _d === void 0 ? void 0 : _d.nextHeaderKey)) !== null && _e !== void 0 ? _e : this.nextHeaderKey
-        };
-    }
+            sending: this.sendingChain?.headerKey,
+            receiving: (this.receivingChain?.headerKey ?? this.receivingChain?.nextHeaderKey) ?? this.nextHeaderKey
+        }
+    }*/
     getSendingKey() {
         if (!this.sendingChain)
             return;
@@ -71,17 +78,19 @@ class KeySession {
         };
     }
     getReceivingKey(encryptionKeys) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d;
         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);
                 }
-                this.receivingChain = this.getChain(encryptionKeys.publicKey, (_c = this.nextHeaderKey) !== null && _c !== void 0 ? _c : (_d = this.receivingChain) === null || _d === void 0 ? void 0 : _d.nextHeaderKey);
+                //this.nextHeaderKey ?? this.receivingChain?.nextHeaderKey
+                this.receivingChain = this.getChain(encryptionKeys.publicKey, (_c = this.receivingChain) === null || _c === void 0 ? void 0 : _c.count);
                 this.nextHeaderKey = undefined;
                 this.keyPair = crypto_1.default.ECDH.keyPair();
-                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_e = this.sendingChain) === null || _e === void 0 ? void 0 : _e.nextHeaderKey, (_f = this.sendingChain) === null || _f === void 0 ? void 0 : _f.count);
+                //this.sendingChain?.nextHeaderKey,
+                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_d = this.sendingChain) === null || _d === void 0 ? void 0 : _d.count);
             }
             if (!this.receivingChain)
                 throw new Error("Error initializing receivingChain");
@@ -106,6 +115,7 @@ class KeySession {
     toJSON() {
         var _a, _b;
         return {
+            identityKey: this.identityKey.toString(),
             secretKey: (0, utils_1.decodeBase64)(this.keyPair.secretKey),
             rootKey: this.rootKey ? (0, utils_1.decodeBase64)(this.rootKey) : undefined,
             sendingChain: (_a = this.sendingChain) === null || _a === void 0 ? void 0 : _a.toJSON(),
@@ -120,7 +130,7 @@ class KeySession {
      * @returns session with the state parsed.
      */
     static from(data) {
-        const session = new KeySession({ secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: data.rootKey ? (0, utils_1.encodeBase64)(data.rootKey) : undefined });
+        const session = new KeySession({ identityKey: types_1.IdentityKey.from(data.identityKey), 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);
@@ -133,12 +143,11 @@ KeySession.version = 1;
 KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
 KeySession.maxCount = 65536;
 class KeyChain {
-    constructor(publicKey, remoteKey, chainKey, nextHeaderKey, headerKey, previousCount = 0) {
+    //public readonly nextHeaderKey: Uint8Array, public readonly headerKey?: Uint8Array,
+    constructor(publicKey, remoteKey, chainKey, previousCount = 0) {
         this.publicKey = publicKey;
         this.remoteKey = remoteKey;
         this.chainKey = chainKey;
-        this.nextHeaderKey = nextHeaderKey;
-        this.headerKey = headerKey;
         this.previousCount = previousCount;
         this._count = 0;
     }
@@ -160,14 +169,15 @@ class KeyChain {
             publicKey: (0, utils_1.decodeBase64)(this.publicKey),
             remoteKey: (0, utils_1.decodeBase64)(this.remoteKey),
             chainKey: (0, utils_1.decodeBase64)(this.chainKey),
-            nextHeaderKey: (0, utils_1.decodeBase64)(this.nextHeaderKey),
-            headerKey: this.headerKey ? (0, utils_1.decodeBase64)(this.headerKey) : undefined,
+            //nextHeaderKey: decodeBase64(this.nextHeaderKey),
+            //headerKey: this.headerKey ? decodeBase64(this.headerKey) : undefined,
             count: this.count,
             previousCount: this.previousCount
         };
     }
     static from(obj) {
-        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), (0, utils_1.encodeBase64)(obj.nextHeaderKey), obj.headerKey ? (0, utils_1.encodeBase64)(obj.headerKey) : undefined, obj.previousCount);
+        //encodeBase64(obj.nextHeaderKey), obj.headerKey ? encodeBase64(obj.headerKey) : undefined,
+        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), obj.previousCount);
         chain._count = obj.count;
         return chain;
     }

package/dist/node.d.ts

@@ -23,17 +23,16 @@ import { ExportedKeySession, KeySession } from "./double-ratchet";
 export declare class BootstrapRequest {
     #private;
     readonly senderId: UserId | string;
-    private readonly data;
-    constructor(senderId: UserId | string, data: KeyExchangeData);
+    private readonly datagram;
+    constructor(senderId: UserId | string, datagram: Datagram);
     get status(): "pending" | "accepted" | "denied";
-    get(): Promise<KeyExchangeData | undefined>;
-    accept(): Promise<KeyExchangeData | undefined>;
+    get(): Promise<Datagram | undefined>;
+    accept(): Promise<Datagram | undefined>;
     deny(): void;
 }
 export declare class FreeSignalNode {
     protected readonly privateIdentityKey: PrivateIdentityKey;
     protected readonly sessions: SessionMap;
-    protected readonly users: LocalStorage<string, IdentityKey>;
     protected readonly bundles: LocalStorage<string, KeyExchangeDataBundle>;
     protected readonly keyExchange: KeyExchange;
     protected readonly discovers: Set<string>;
@@ -41,20 +40,21 @@ export declare class FreeSignalNode {
     constructor(storage: Database<{
         sessions: LocalStorage<string, ExportedKeySession>;
         keyExchange: LocalStorage<string, Crypto.KeyPair>;
-        users: LocalStorage<string, IdentityKey>;
         bundles: LocalStorage<string, KeyExchangeDataBundle>;
         bootstraps: LocalStorage<string, BootstrapRequest>;
     }>, privateIdentityKey?: PrivateIdentityKey);
     get identityKey(): IdentityKey;
     get userId(): UserId;
     onRequest: (request: BootstrapRequest) => void;
-    getRequest(userId: string): Promise<KeyExchangeData | undefined>;
+    getRequest(userId: string): Promise<Datagram | undefined>;
     protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
     packHandshake(data: KeyExchangeData): Promise<Datagram>;
+    packHandshake(receiverId: string | UserId): Promise<Datagram>;
     packData<T>(receiverId: string | UserId, data: T): Promise<Datagram>;
     packRelay(receiverId: string | UserId, data: Datagram): Promise<Datagram>;
     packDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<Datagram>;
     packBootstrap(receiverId: string | UserId): Promise<Datagram>;
+    packGetBootstrap(receiverId: string | UserId): Promise<Datagram>;
     protected decrypt(datagram: Datagram): Promise<Uint8Array>;
     /**
      * Open the datagram and execute operation of Discover and Handshake.

package/dist/node.js

@@ -37,6 +37,9 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _BootstrapRequest_status;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FreeSignalNode = exports.BootstrapRequest = void 0;
@@ -45,10 +48,11 @@ const x3dh_1 = require("./x3dh");
 const double_ratchet_1 = require("./double-ratchet");
 const _1 = require(".");
 const utils_1 = require("@freesignal/utils");
+const crypto_1 = __importDefault(require("@freesignal/crypto"));
 class BootstrapRequest {
-    constructor(senderId, data) {
+    constructor(senderId, datagram) {
         this.senderId = senderId;
-        this.data = data;
+        this.datagram = datagram;
         _BootstrapRequest_status.set(this, 'pending');
     }
     get status() {
@@ -56,7 +60,7 @@ class BootstrapRequest {
     }
     get() {
         return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted' ? this.data : undefined;
+            return __classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted' ? this.datagram : undefined;
         });
     }
     accept() {
@@ -81,7 +85,6 @@ class FreeSignalNode {
         this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
         this.sessions = new SessionMap(storage.sessions);
         this.keyExchange = new x3dh_1.KeyExchange(storage.keyExchange, this.privateIdentityKey);
-        this.users = storage.users;
         this.bundles = storage.bundles;
         this.bootstraps = storage.bootstraps;
     }
@@ -111,21 +114,33 @@ class FreeSignalNode {
     }
     packHandshake(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { session, message, identityKey } = yield this.keyExchange.digestData(data, (0, utils_1.encodeData)(yield this.keyExchange.generateBundle()));
-            const remoteId = types_1.UserId.fromKey(identityKey);
-            yield this.users.set(remoteId.toString(), identityKey);
-            yield this.sessions.set(remoteId.toString(), session);
+            var _a;
+            if (typeof data === 'string' || data instanceof types_1.UserId) {
+                //console.debug("Packing Handshake Ack");
+                const userId = data.toString();
+                const identityKey = (_a = (yield this.sessions.get(userId))) === null || _a === void 0 ? void 0 : _a.identityKey;
+                if (!identityKey)
+                    throw new Error("Missing user");
+                const res = yield this.encrypt(userId, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey));
+                return res;
+            }
+            //console.debug("Packing Handshake Syn");
+            const { session, message } = yield this.keyExchange.digestData(data, (0, utils_1.encodeData)(yield this.keyExchange.generateBundle()));
+            yield this.sessions.set(session.userId.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)).sign(this.privateIdentityKey.signatureKey);
         });
     }
     packData(receiverId, data) {
+        //console.debug("Packing Data");
         return this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
     }
     packRelay(receiverId, data) {
+        //console.debug("Packing Relay");
         return this.encrypt(receiverId, types_1.Protocols.RELAY, (0, utils_1.encodeData)(data));
     }
     packDiscover(receiverId, discoverId) {
         return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Packing Discover");
             if (receiverId instanceof types_1.UserId)
                 receiverId = receiverId.toString();
             if (discoverId instanceof types_1.UserId)
@@ -140,15 +155,23 @@ class FreeSignalNode {
     }
     packBootstrap(receiverId) {
         return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Packing Bootstrap");
             return new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
         });
     }
+    packGetBootstrap(receiverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Packing GetBootstrap");
+            return new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP);
+        });
+    }
     decrypt(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            const signatureKey = yield this.users.get(datagram.sender);
-            if (!signatureKey)
+            var _a;
+            const identityKey = (_a = (yield this.sessions.get(datagram.sender))) === null || _a === void 0 ? void 0 : _a.identityKey;
+            if (!identityKey)
                 throw new Error("User IdentityKey not found");
-            if (!types_1.Datagram.verify(datagram, signatureKey.signatureKey))
+            if (!types_1.Datagram.verify(datagram, identityKey.signatureKey))
                 throw new Error("Signature not verified");
             const session = yield this.sessions.get(datagram.sender);
             if (!session)
@@ -168,7 +191,7 @@ class FreeSignalNode {
      */
     open(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             if (datagram instanceof Uint8Array)
                 datagram = types_1.Datagram.from(datagram);
             let out = {
@@ -178,24 +201,39 @@ class FreeSignalNode {
                 case types_1.Protocols.HANDSHAKE:
                     if (!datagram.payload)
                         throw new Error("Missing payload");
+                    if (yield this.sessions.has(datagram.sender)) {
+                        //console.debug("Opening Handshake Ack");
+                        const payload = yield this.decrypt(datagram);
+                        const identityKey = (_a = (yield this.sessions.get(datagram.sender))) === null || _a === void 0 ? void 0 : _a.identityKey;
+                        if (!identityKey)
+                            throw new Error("Missing user");
+                        if (!(0, utils_1.compareBytes)(payload, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey)))
+                            throw new Error("Error validating handshake data");
+                        return out;
+                    }
+                    //console.debug("Opening Handshake Syn");
                     const data = (0, utils_1.decodeData)(datagram.payload);
                     if (!types_1.Datagram.verify(datagram, types_1.IdentityKey.from(data.identityKey).signatureKey))
                         throw new Error("Signature not verified");
-                    const { session, identityKey, associatedData } = yield this.keyExchange.digestMessage(data);
-                    const userId = types_1.UserId.fromKey(identityKey);
-                    yield this.users.set(userId.toString(), identityKey);
-                    yield this.sessions.set(userId.toString(), session);
-                    yield this.bundles.set(userId.toString(), (0, utils_1.decodeData)(associatedData));
+                    const { session, associatedData } = yield this.keyExchange.digestMessage(data);
+                    yield this.sessions.set(session.userId.toString(), session);
+                    yield this.bundles.set(session.userId.toString(), (0, utils_1.decodeData)(associatedData));
+                    out.datagram = yield this.packHandshake(session.userId);
+                    if (!out.datagram)
+                        throw new Error("Error during handshake");
                     return out;
                 case types_1.Protocols.MESSAGE:
+                    //console.debug("Opening Message");
                     out.payload = yield this.decrypt(datagram);
                     return out;
                 case types_1.Protocols.RELAY:
+                    //console.debug("Opening Relay");
                     out.payload = yield this.decrypt(datagram);
                     return out;
                 case types_1.Protocols.DISCOVER:
+                    //console.debug("Opening Discover");
                     const message = (0, utils_1.decodeData)(yield this.decrypt(datagram));
-                    if (message.type === types_1.DiscoverType.REQUEST && message.discoverId && !(yield this.users.has(message.discoverId))) {
+                    if (message.type === types_1.DiscoverType.REQUEST && message.discoverId && !(yield this.sessions.has(message.discoverId))) {
                         let data;
                         if (message.discoverId === this.userId.toString()) {
                             data = yield this.keyExchange.generateData();
@@ -228,18 +266,19 @@ class FreeSignalNode {
                     }
                     return out;
                 case types_1.Protocols.BOOTSTRAP:
+                    //console.debug("Opening Bootstrap");
                     if (datagram.payload) {
                         const data = (0, utils_1.decodeData)(datagram.payload);
                         if (!(0, utils_1.compareBytes)(types_1.UserId.fromKey(data.identityKey).toBytes(), (0, utils_1.encodeBase64)(datagram.sender)))
                             new Error("Malicious bootstrap request");
-                        const request = new BootstrapRequest(datagram.sender, data);
+                        const request = new BootstrapRequest(datagram.sender, yield this.packHandshake(data));
                         yield this.bootstraps.set(datagram.sender, request);
                         this.onRequest(request);
                     }
                     ;
-                    const bootstrap = yield ((_a = (yield this.bootstraps.get(datagram.sender))) === null || _a === void 0 ? void 0 : _a.get());
-                    if (bootstrap)
-                        out.datagram = yield this.packHandshake(bootstrap);
+                    const handshakeDatagram = yield ((_b = (yield this.bootstraps.get(datagram.sender))) === null || _b === void 0 ? void 0 : _b.get());
+                    if (handshakeDatagram)
+                        out.datagram = handshakeDatagram;
                     return out;
                 case types_1.Protocols.PING:
                     return out;

package/dist/test.js

@@ -18,15 +18,17 @@ setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
     const bobBootstrap = yield bob.packBootstrap(alice.userId);
     alice.onRequest = (request) => { request.accept(); };
     const test = (yield alice.open(bobBootstrap)).datagram;
-    console.log("Valid bootstrap: ", !!test);
-    const bobRequest = yield alice.getRequest(bob.userId.toString());
-    if (!bobRequest)
+    const aliceHandshake = yield alice.getRequest(bob.userId.toString());
+    if (!aliceHandshake)
         throw new Error("Bootstrap Failed");
-    const aliceHandshake = yield alice.packHandshake(bobRequest);
-    yield bob.open(aliceHandshake);
+    const bobHandshake = (yield bob.open(aliceHandshake)).datagram;
+    if (!bobHandshake)
+        throw new Error("Handshake Failed");
+    console.log(!!(yield alice.open(bobHandshake)).header);
     const first = (yield bob.packData(alice.userId, "Hi Alice!")).toBytes();
     console.log("Bob: ", (0, utils_1.decodeData)((yield alice.open(first)).payload));
     const second = yield alice.packData(bob.userId, "Hi Bob!");
+    console.log("Test");
     console.log("Alice: ", (0, utils_1.decodeData)((yield bob.open(second)).payload));
     const third = yield Promise.all(["How are you?", "How are this days?", "For me it's a good time"].map(msg => bob.packData(alice.userId, msg)));
     third.forEach((data) => __awaiter(void 0, void 0, void 0, function* () {

package/dist/types.d.ts

@@ -29,30 +29,37 @@ export declare class UserId implements Encodable {
     static fromKey(identityKey: string | Uint8Array | IdentityKey): UserId;
     static from(userId: string | Uint8Array | UserId): UserId;
 }
-export interface IdentityKey extends Encodable {
+export declare class IdentityKey implements Encodable {
+    static readonly keyLength: number;
+    static readonly version = 1;
+    private static readonly info;
     readonly info: number;
     readonly signatureKey: Uint8Array;
     readonly exchangeKey: Uint8Array;
+    constructor(identityKey: IdentityKey | Uint8Array | string);
+    get userId(): UserId;
+    toBytes(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+    static from(identityKey: IdentityKey | Uint8Array | string): IdentityKey;
+    static from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): IdentityKey;
 }
-export declare namespace IdentityKey {
-    const keyLength: number;
-    const version = 1;
-    function isIdentityKeys(obj: any): boolean;
-    function from(identityKey: IdentityKey | Uint8Array | string): IdentityKey;
-    function from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): IdentityKey;
-}
-export interface PrivateIdentityKey {
+export declare class PrivateIdentityKey implements Encodable {
+    static readonly keyLength: number;
+    static readonly version = 1;
+    private static readonly info;
     readonly info: number;
     readonly signatureKey: Uint8Array;
     readonly exchangeKey: Uint8Array;
     readonly identityKey: IdentityKey;
-}
-export declare namespace PrivateIdentityKey {
-    const keyLength: number;
-    const version = 1;
-    function isIdentityKeys(obj: any): boolean;
-    function from(identityKey: PrivateIdentityKey | Uint8Array | string): PrivateIdentityKey;
-    function from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): PrivateIdentityKey;
+    constructor(privateIdentityKey: PrivateIdentityKey | Uint8Array | string);
+    get userId(): string;
+    toBytes(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+    static isIdentityKeys(obj: any): boolean;
+    static from(identityKey: PrivateIdentityKey | Uint8Array | string): PrivateIdentityKey;
+    static from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): PrivateIdentityKey;
 }
 export declare enum DiscoverType {
     REQUEST = 0,

package/dist/types.js

@@ -35,32 +35,66 @@ exports.encryptData = encryptData;
 exports.decryptData = decryptData;
 const utils_1 = require("@freesignal/utils");
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
-function encryptData(session, data) {
-    //console.log(session.id, ' Sending: ', decodeBase64(session.getHeaderKeys().sending ?? new Uint8Array()));
+/*export function encryptData(session: KeySession, data: Uint8Array): EncryptedData {
     const key = session.getSendingKey();
     if (!key)
         throw new Error("Error generating key");
-    const nonce = crypto_1.default.randomBytes(EncryptionHeader.nonceLength);
-    const ciphertext = crypto_1.default.box.encrypt(data, nonce, key.secretKey);
+    const nonce = crypto.randomBytes(EncryptionHeader.nonceLength);
+    const ciphertext = crypto.box.encrypt(data, nonce, key.secretKey);
     const headerKey = session.getHeaderKeys().sending;
+    //console.debug(session.userId.toString(), "Sending: ", decodeBase64(headerKey ?? new Uint8Array()))
     let header = new EncryptionHeader(key, nonce).toBytes();
-    const headerNonce = crypto_1.default.randomBytes(EncryptionHeader.nonceLength);
+    const headerNonce = crypto.randomBytes(EncryptionHeader.nonceLength)
     if (headerKey)
-        header = crypto_1.default.box.encrypt(header, headerNonce, headerKey);
+        header = crypto.box.encrypt(header, headerNonce, headerKey);
     const test = new EncryptedData(header, headerNonce, ciphertext);
     return test;
 }
-function decryptData(session, encryptedData) {
-    //console.log(session.id, ' Receiving: ', decodeBase64(session.getHeaderKeys().receiving ?? new Uint8Array()));
+
+export function decryptData(session: KeySession, encryptedData: Uint8Array): Uint8Array {
     const encrypted = EncryptedData.from(encryptedData);
     const headerKey = session.getHeaderKeys().receiving;
-    let headerData = encrypted.header;
-    if (headerKey) {
-        headerData = crypto_1.default.box.decrypt(headerData, encrypted.nonce, headerKey);
+    const nextHeaderKey = session.getHeaderKeys().nextReciving;
+    let headerData: Uint8Array | undefined;
+    try {
+        if (!headerKey)
+            throw new Error("Error generating key");
+        headerData = crypto.box.decrypt(encrypted.header, encrypted.nonce, headerKey);
         if (!headerData)
             throw new Error("Error calculating header");
+        //console.debug(session.userId.toString(), "Receiving: ", decodeBase64(session.getHeaderKeys().receiving ?? new Uint8Array()))
+    } catch {
+        if (!nextHeaderKey)
+            throw new Error("Error generating key");
+        headerData = crypto.box.decrypt(encrypted.header, encrypted.nonce, nextHeaderKey);
+        if (!headerData) {
+            //console.debug(session.toJSON());
+            throw new Error("Error calculating header");
+        }
+        //console.debug(session.userId.toString(), "NextReceiving: ", decodeBase64(session.getHeaderKeys().nextReciving ?? new Uint8Array()))
     }
-    const header = EncryptionHeader.from(headerData);
+    const header = EncryptionHeader.from(headerData!);
+    const key = session.getReceivingKey(header);
+    if (!key)
+        throw new Error("Error calculating key");
+    const decrypted = crypto.box.decrypt(encrypted.payload, header.nonce, key);
+    if (!decrypted)
+        throw new Error("Error decrypting data");
+    return decrypted;
+}*/
+function encryptData(session, data) {
+    const key = session.getSendingKey();
+    if (!key)
+        throw new Error("Error generating key");
+    const nonce = crypto_1.default.randomBytes(EncryptionHeader.nonceLength);
+    const ciphertext = crypto_1.default.box.encrypt(data, nonce, key.secretKey);
+    let header = new EncryptionHeader(key, nonce).toBytes();
+    const test = new EncryptedData(header, crypto_1.default.randomBytes(EncryptionHeader.nonceLength), ciphertext);
+    return test;
+}
+function decryptData(session, encryptedData) {
+    const encrypted = EncryptedData.from(encryptedData);
+    const header = EncryptionHeader.from(encrypted.header);
     const key = session.getReceivingKey(header);
     if (!key)
         throw new Error("Error calculating key");
@@ -86,8 +120,8 @@ class UserId {
     static fromKey(identityKey) {
         if (typeof identityKey === 'string')
             identityKey = (0, utils_1.encodeBase64)(identityKey);
-        else if (IdentityKey.isIdentityKeys(identityKey))
-            identityKey = identityKey.toBytes();
+        else if (identityKey instanceof IdentityKey)
+            identityKey = (identityKey).toBytes();
         return new UserId(crypto_1.default.hkdf(identityKey, new Uint8Array(32).fill(0), "/freesignal/userid"));
     }
     static from(userId) {
@@ -97,112 +131,101 @@ class UserId {
     }
 }
 exports.UserId = UserId;
-var IdentityKey;
-(function (IdentityKey) {
-    IdentityKey.keyLength = crypto_1.default.EdDSA.publicKeyLength + crypto_1.default.ECDH.publicKeyLength + 1;
-    const info = 0x70;
-    IdentityKey.version = 1;
-    class IdentityKeyConstructor {
-        constructor(identityKey) {
-            if (identityKey instanceof IdentityKeyConstructor) {
-                this.info = identityKey.info;
-                this.signatureKey = identityKey.signatureKey;
-                this.exchangeKey = identityKey.exchangeKey;
-            }
-            else {
-                if (typeof identityKey === 'string')
-                    identityKey = (0, utils_1.encodeBase64)(identityKey);
-                if (!isIdentityKeys(identityKey))
-                    throw new Error("Invalid key length");
-                this.info = identityKey[0];
-                this.signatureKey = identityKey.subarray(1, crypto_1.default.EdDSA.publicKeyLength + 1);
-                this.exchangeKey = identityKey.subarray(crypto_1.default.EdDSA.publicKeyLength + 1, IdentityKey.keyLength);
-            }
-        }
-        get userId() {
-            return UserId.fromKey(this.toBytes()).toString();
-        }
-        toBytes() {
-            return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this.info, 1), this.signatureKey, this.exchangeKey);
+class IdentityKey {
+    constructor(identityKey) {
+        if (identityKey instanceof IdentityKey) {
+            this.info = identityKey.info;
+            this.signatureKey = identityKey.signatureKey;
+            this.exchangeKey = identityKey.exchangeKey;
         }
-        toString() {
-            return (0, utils_1.decodeBase64)(this.toBytes());
-        }
-        toJSON() {
-            return this.toString();
+        else {
+            if (typeof identityKey === 'string')
+                identityKey = (0, utils_1.encodeBase64)(identityKey);
+            if (identityKey.length !== IdentityKey.keyLength)
+                throw new Error("Invalid key length");
+            this.info = identityKey[0];
+            this.signatureKey = identityKey.subarray(1, crypto_1.default.EdDSA.publicKeyLength + 1);
+            this.exchangeKey = identityKey.subarray(crypto_1.default.EdDSA.publicKeyLength + 1, IdentityKey.keyLength);
         }
     }
-    function isIdentityKeys(obj) {
-        return (obj instanceof Uint8Array && obj.length === IdentityKey.keyLength) || obj instanceof IdentityKeyConstructor;
+    get userId() {
+        return UserId.fromKey(this.toBytes());
+    }
+    toBytes() {
+        return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this.info, 1), this.signatureKey, this.exchangeKey);
+    }
+    toString() {
+        return (0, utils_1.decodeBase64)(this.toBytes());
+    }
+    toJSON() {
+        return this.toString();
     }
-    IdentityKey.isIdentityKeys = isIdentityKeys;
-    function from(...keys) {
+    static from(...keys) {
         keys = keys.map(key => {
-            if (key instanceof IdentityKeyConstructor)
+            if (key instanceof IdentityKey)
                 return key.toBytes();
             else if (typeof key === 'string')
                 return (0, utils_1.encodeBase64)(key);
             else
                 return key;
         });
-        return new IdentityKeyConstructor(keys.length === 2 ? (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(info + IdentityKey.version, 1), ...keys) : keys[0]);
-    }
-    IdentityKey.from = from;
-})(IdentityKey || (exports.IdentityKey = IdentityKey = {}));
-var PrivateIdentityKey;
-(function (PrivateIdentityKey) {
-    PrivateIdentityKey.keyLength = crypto_1.default.EdDSA.secretKeyLength + crypto_1.default.ECDH.secretKeyLength + 1;
-    const info = 0x4E;
-    PrivateIdentityKey.version = 1;
-    class PrivateIdentityKeyConstructor {
-        constructor(privateIdentityKey) {
-            if (privateIdentityKey instanceof PrivateIdentityKeyConstructor) {
-                this.info = privateIdentityKey.info;
-                this.signatureKey = privateIdentityKey.signatureKey;
-                this.exchangeKey = privateIdentityKey.exchangeKey;
-                this.identityKey = privateIdentityKey.identityKey;
-            }
-            else {
-                if (typeof privateIdentityKey === 'string')
-                    privateIdentityKey = (0, utils_1.encodeBase64)(privateIdentityKey);
-                if (!isIdentityKeys(privateIdentityKey))
-                    throw new Error("Invalid key length");
-                this.info = privateIdentityKey[0];
-                this.signatureKey = privateIdentityKey.subarray(1, crypto_1.default.EdDSA.secretKeyLength + 1);
-                this.exchangeKey = privateIdentityKey.subarray(crypto_1.default.EdDSA.secretKeyLength + 1, PrivateIdentityKey.keyLength);
-                this.identityKey = IdentityKey.from(crypto_1.default.EdDSA.keyPair(this.signatureKey).publicKey, crypto_1.default.ECDH.keyPair(this.exchangeKey).publicKey);
-            }
-        }
-        get userId() {
-            return UserId.fromKey(this.identityKey.toBytes()).toString();
-        }
-        toBytes() {
-            return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this.info, 1), this.signatureKey, this.exchangeKey);
-        }
-        toString() {
-            return (0, utils_1.decodeBase64)(this.toBytes());
+        return new IdentityKey(keys.length === 2 ? (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(IdentityKey.info + IdentityKey.version, 1), ...keys) : keys[0]);
+    }
+}
+exports.IdentityKey = IdentityKey;
+IdentityKey.keyLength = crypto_1.default.EdDSA.publicKeyLength + crypto_1.default.ECDH.publicKeyLength + 1;
+IdentityKey.version = 1;
+IdentityKey.info = 0x70;
+class PrivateIdentityKey {
+    constructor(privateIdentityKey) {
+        if (privateIdentityKey instanceof PrivateIdentityKey) {
+            this.info = privateIdentityKey.info;
+            this.signatureKey = privateIdentityKey.signatureKey;
+            this.exchangeKey = privateIdentityKey.exchangeKey;
+            this.identityKey = privateIdentityKey.identityKey;
         }
-        toJSON() {
-            return this.toString();
+        else {
+            if (typeof privateIdentityKey === 'string')
+                privateIdentityKey = (0, utils_1.encodeBase64)(privateIdentityKey);
+            if (!PrivateIdentityKey.isIdentityKeys(privateIdentityKey))
+                throw new Error("Invalid key length");
+            this.info = privateIdentityKey[0];
+            this.signatureKey = privateIdentityKey.subarray(1, crypto_1.default.EdDSA.secretKeyLength + 1);
+            this.exchangeKey = privateIdentityKey.subarray(crypto_1.default.EdDSA.secretKeyLength + 1, PrivateIdentityKey.keyLength);
+            this.identityKey = IdentityKey.from(crypto_1.default.EdDSA.keyPair(this.signatureKey).publicKey, crypto_1.default.ECDH.keyPair(this.exchangeKey).publicKey);
         }
     }
-    function isIdentityKeys(obj) {
-        return (obj instanceof Uint8Array && obj.length === PrivateIdentityKey.keyLength) || obj instanceof PrivateIdentityKeyConstructor;
+    get userId() {
+        return UserId.fromKey(this.identityKey.toBytes()).toString();
+    }
+    toBytes() {
+        return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this.info, 1), this.signatureKey, this.exchangeKey);
+    }
+    toString() {
+        return (0, utils_1.decodeBase64)(this.toBytes());
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static isIdentityKeys(obj) {
+        return (obj instanceof Uint8Array && obj.length === PrivateIdentityKey.keyLength) || obj instanceof PrivateIdentityKey;
     }
-    PrivateIdentityKey.isIdentityKeys = isIdentityKeys;
-    function from(...keys) {
+    static from(...keys) {
         keys = keys.map(key => {
-            if (key instanceof PrivateIdentityKeyConstructor)
+            if (key instanceof PrivateIdentityKey)
                 return key.toBytes();
             else if (typeof key === 'string')
                 return (0, utils_1.encodeBase64)(key);
             else
                 return key;
         });
-        return new PrivateIdentityKeyConstructor(keys.length === 2 ? (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(info + PrivateIdentityKey.version, 1), ...keys) : keys[0]);
+        return new PrivateIdentityKey(keys.length === 2 ? (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(PrivateIdentityKey.info + PrivateIdentityKey.version, 1), ...keys) : keys[0]);
     }
-    PrivateIdentityKey.from = from;
-})(PrivateIdentityKey || (exports.PrivateIdentityKey = PrivateIdentityKey = {}));
+}
+exports.PrivateIdentityKey = PrivateIdentityKey;
+PrivateIdentityKey.keyLength = crypto_1.default.EdDSA.secretKeyLength + crypto_1.default.ECDH.secretKeyLength + 1;
+PrivateIdentityKey.version = 1;
+PrivateIdentityKey.info = 0x4E;
 var DiscoverType;
 (function (DiscoverType) {
     DiscoverType[DiscoverType["REQUEST"] = 0] = "REQUEST";

package/dist/x3dh.d.ts

@@ -38,11 +38,9 @@ export declare class KeyExchange {
     digestData(message: KeyExchangeData, associatedData?: Uint8Array): Promise<{
         session: KeySession;
         message: KeyExchangeSynMessage;
-        identityKey: IdentityKey;
     }>;
     digestMessage(message: KeyExchangeSynMessage): Promise<{
         session: KeySession;
-        identityKey: IdentityKey;
         associatedData: Uint8Array;
     }>;
 }

package/dist/x3dh.js

@@ -84,6 +84,7 @@ class KeyExchange {
     }
     digestData(message, associatedData) {
         return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Digest Data")
             const ephemeralKey = crypto_1.default.ECDH.keyPair();
             const signedPreKey = (0, utils_1.encodeBase64)(message.signedPreKey);
             const identityKey = types_1.IdentityKey.from(message.identityKey);
@@ -97,9 +98,9 @@ class KeyExchange {
                 ...crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, identityKey.exchangeKey),
                 ...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 * 2);
-            //, headerKey: derivedKey.subarray(KeySession.keyLength)
-            const session = new double_ratchet_1.KeySession({ remoteKey: identityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength) });
+            ]), new Uint8Array(double_ratchet_1.KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.keyLength * 3);
+            //, headerKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), nextHeaderKey: derivedKey.subarray(KeySession.keyLength * 2)
+            const session = new double_ratchet_1.KeySession({ identityKey, remoteKey: identityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength) });
             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");
@@ -112,13 +113,13 @@ class KeyExchange {
                     signedPreKeyHash: (0, utils_1.decodeBase64)(signedPreKeyHash),
                     onetimePreKeyHash: (0, utils_1.decodeBase64)(onetimePreKeyHash),
                     associatedData: (0, utils_1.decodeBase64)(encrypted.toBytes())
-                },
-                identityKey
+                }
             };
         });
     }
     digestMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Digest Message")
             const signedPreKey = yield this.storage.get(message.signedPreKeyHash);
             const hash = message.signedPreKeyHash.concat(message.onetimePreKeyHash);
             const onetimePreKey = yield this.storage.get(hash);
@@ -133,9 +134,9 @@ class KeyExchange {
                 ...crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, ephemeralKey),
                 ...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 * 2);
-            //, nextHeaderKey: derivedKey.subarray(KeySession.keyLength)
-            const session = new double_ratchet_1.KeySession({ secretKey: this.privateIdentityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength) });
+            ]), new Uint8Array(double_ratchet_1.KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.keyLength * 3);
+            //nextHeaderKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), headerKey: derivedKey.subarray(KeySession.keyLength * 2)
+            const session = new double_ratchet_1.KeySession({ identityKey, secretKey: this.privateIdentityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength) });
             const data = (0, types_1.decryptData)(session, (0, utils_1.encodeBase64)(message.associatedData));
             if (!data)
                 throw new Error("Error decrypting ACK message");
@@ -143,7 +144,6 @@ class KeyExchange {
                 throw new Error("Error verifing Associated Data");
             return {
                 session,
-                identityKey,
                 associatedData: data.subarray(64)
             };
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.5.6",
+  "version": "0.6.1",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",