@freesignal/protocol 0.5.6 → 0.6.0

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;
@@ -41,18 +43,20 @@ export declare class KeySession {
     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?: {
+    constructor(identityKey: IdentityKey, opts?: {
         id?: string;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
         rootKey?: Uint8Array;
     });
+    get userId(): UserId;
     private getChain;
     getHeaderKeys(): {
         readonly sending?: Uint8Array;

package/dist/double-ratchet.js

@@ -24,15 +24,17 @@ 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 = {}) {
+    constructor(identityKey, opts = {}) {
         var _a;
         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)
@@ -43,6 +45,9 @@ class KeySession {
             this.sendingChain = this.getChain(opts.remoteKey); //, opts.headerKey);
         }
     }
+    get userId() {
+        return this.identityKey.userId;
+    }
     getChain(remoteKey, headerKey, previousCount) {
         const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, remoteKey);
         if (!this.rootKey)
@@ -106,6 +111,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 +126,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(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);

package/dist/node.d.ts

@@ -33,7 +33,6 @@ export declare class BootstrapRequest {
 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,7 +40,6 @@ 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);
@@ -51,6 +49,7 @@ export declare class FreeSignalNode {
     getRequest(userId: string): Promise<KeyExchangeData | 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>;

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,6 +48,7 @@ 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) {
         this.senderId = senderId;
@@ -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,10 +114,16 @@ 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) {
+                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 { 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);
         });
     }
@@ -145,10 +154,11 @@ class FreeSignalNode {
     }
     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 +178,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,14 +188,24 @@ class FreeSignalNode {
                 case types_1.Protocols.HANDSHAKE:
                     if (!datagram.payload)
                         throw new Error("Missing payload");
+                    if (yield this.sessions.has(datagram.sender)) {
+                        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)))
+                            throw new Error("Error validating handshake data");
+                        return out;
+                    }
                     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:
                     out.payload = yield this.decrypt(datagram);
@@ -195,7 +215,7 @@ class FreeSignalNode {
                     return out;
                 case types_1.Protocols.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();
@@ -237,7 +257,7 @@ class FreeSignalNode {
                         this.onRequest(request);
                     }
                     ;
-                    const bootstrap = yield ((_a = (yield this.bootstraps.get(datagram.sender))) === null || _a === void 0 ? void 0 : _a.get());
+                    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);
                     return out;

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

@@ -86,8 +86,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 +97,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);
-            }
+class IdentityKey {
+    constructor(identityKey) {
+        if (identityKey instanceof IdentityKey) {
+            this.info = identityKey.info;
+            this.signatureKey = identityKey.signatureKey;
+            this.exchangeKey = identityKey.exchangeKey;
         }
-        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);
-        }
-        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());
     }
-    IdentityKey.isIdentityKeys = isIdentityKeys;
-    function from(...keys) {
+    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 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();
     }
-    PrivateIdentityKey.isIdentityKeys = isIdentityKeys;
-    function from(...keys) {
+    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;
+    }
+    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

@@ -99,7 +99,7 @@ class KeyExchange {
                 ...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) });
+            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,8 +112,7 @@ class KeyExchange {
                     signedPreKeyHash: (0, utils_1.decodeBase64)(signedPreKeyHash),
                     onetimePreKeyHash: (0, utils_1.decodeBase64)(onetimePreKeyHash),
                     associatedData: (0, utils_1.decodeBase64)(encrypted.toBytes())
-                },
-                identityKey
+                }
             };
         });
     }
@@ -135,7 +134,7 @@ class KeyExchange {
                 ...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) });
+            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 +142,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.0",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",