@freesignal/protocol 0.6.0 → 0.6.1

package/dist/double-ratchet.d.ts

@@ -42,7 +42,6 @@ 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?;
@@ -50,18 +49,14 @@ export declare class KeySession {
     private receivingChain?;
     private nextHeaderKey?;
     private previousKeys;
-    constructor(identityKey: IdentityKey, 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;
     /**
@@ -88,8 +83,6 @@ interface ExportedKeyChain {
     publicKey: string;
     remoteKey: string;
     chainKey: string;
-    nextHeaderKey: string;
-    headerKey?: string;
     count: number;
     previousCount: number;
 }

package/dist/double-ratchet.js

@@ -31,38 +31,40 @@ const types_1 = require("./types");
  */
 class KeySession {
     //headerKey?: Uint8Array, nextHeaderKey?: Uint8Array,
-    constructor(identityKey, opts = {}) {
-        var _a;
+    constructor({ identityKey, secretKey, remoteKey, rootKey }) {
         this.previousKeys = new KeyMap();
         this.identityKey = identityKey;
-        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.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);
         }
     }
     get userId() {
         return this.identityKey.userId;
     }
-    getChain(remoteKey, headerKey, previousCount) {
+    //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;
@@ -76,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");
@@ -126,7 +130,7 @@ class KeySession {
      * @returns session with the state parsed.
      */
     static from(data) {
-        const session = new KeySession(types_1.IdentityKey.from(data.identityKey), { 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);
@@ -139,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;
     }
@@ -166,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,11 +23,11 @@ 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 {
@@ -46,7 +46,7 @@ export declare class FreeSignalNode {
     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>;
@@ -54,6 +54,7 @@ export declare class FreeSignalNode {
     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

@@ -50,9 +50,9 @@ 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() {
@@ -60,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() {
@@ -116,25 +116,31 @@ class FreeSignalNode {
         return __awaiter(this, void 0, void 0, function* () {
             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");
-                return yield this.encrypt(userId, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(identityKey.exchangeKey, this.privateIdentityKey.exchangeKey));
+                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)
@@ -149,9 +155,16 @@ 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* () {
             var _a;
@@ -189,14 +202,16 @@ class FreeSignalNode {
                     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(identityKey.exchangeKey, this.privateIdentityKey.exchangeKey)))
+                        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");
@@ -208,12 +223,15 @@ class FreeSignalNode {
                         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.sessions.has(message.discoverId))) {
                         let data;
@@ -248,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 ((_b = (yield this.bootstraps.get(datagram.sender))) === null || _b === void 0 ? void 0 : _b.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.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");

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(identityKey, { 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");
@@ -118,6 +119,7 @@ class KeyExchange {
     }
     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);
@@ -132,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(identityKey, { 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");

package/package.json

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