npm - @freesignal/protocol - Versions diffs - 0.8.3 → 0.9.1 - Mend

@freesignal/protocol 0.8.3 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/double-ratchet.d.ts CHANGED Viewed

@@ -21,8 +21,8 @@ export interface ExportedKeySession {
     identityKey: string;
     secretKey: string;
     rootKey: string;
-    sendingChain?: ExportedKeyChain;
-    receivingChain?: ExportedKeyChain;
+    sendingChain?: KeyChainState;
+    receivingChain?: KeyChainState;
     headerKey?: string;
     headerKeys: [string, Uint8Array][];
     previousKeys: [string, Uint8Array][];
@@ -87,7 +87,7 @@ export declare class KeySession {
      */
     static from(data: ExportedKeySession): KeySession;
 }
-interface ExportedKeyChain {
+interface KeyChainState {
     publicKey: string;
     remoteKey: string;
     chainKey: string;

package/dist/index.d.ts CHANGED Viewed

@@ -16,10 +16,8 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-import { LocalStorage, Crypto, Database, KeyExchangeDataBundle } from "@freesignal/interfaces";
-import { ExportedKeySession } from "./double-ratchet.js";
 import { PrivateIdentityKey } from "./types.js";
-import { BootstrapRequest, FreeSignalNode } from "./node.js";
+import { FreeSignalNode, FreeSignalNodeState } from "./node.js";
 /**
  * Generates identity key
  *
@@ -28,11 +26,5 @@ import { BootstrapRequest, FreeSignalNode } from "./node.js";
  */
 export declare function createIdentity(seed?: Uint8Array): PrivateIdentityKey;
 /** */
-export declare function createNode(storage: Database<{
-    sessions: LocalStorage<string, ExportedKeySession>;
-    users: LocalStorage<string, string>;
-    keyExchange: LocalStorage<string, Crypto.KeyPair>;
-    bundles: LocalStorage<string, KeyExchangeDataBundle>;
-    bootstraps: LocalStorage<string, BootstrapRequest>;
-}>, privateIdentityKey?: PrivateIdentityKey): FreeSignalNode;
+export declare function createNode(args?: Partial<FreeSignalNodeState>): FreeSignalNode;
 export * from "./types.js";

package/dist/index.js CHANGED Viewed

@@ -35,7 +35,7 @@ export function createIdentity(seed) {
     return PrivateIdentityKey.from(signatureKeyPair.secretKey, exchangeKeyPair.secretKey);
 }
 /** */
-export function createNode(storage, privateIdentityKey) {
-    return new FreeSignalNode(storage, privateIdentityKey);
+export function createNode(args) {
+    return new FreeSignalNode(args);
 }
 export * from "./types.js";

package/dist/node.d.ts CHANGED Viewed

@@ -16,10 +16,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
+import { KeyExchangeDataBundle, KeyExchangeData, Crypto } from "@freesignal/interfaces";
 import { Datagram, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types.js";
 import { KeyExchange } from "./x3dh.js";
-import { ExportedKeySession, KeySession } from "./double-ratchet.js";
+import { ExportedKeySession as KeySessionState, KeySession } from "./double-ratchet.js";
 import { EventEmitter, EventCallback } from "easyemitter.ts";
 export declare class BootstrapRequest extends EventEmitter<'change', BootstrapRequest> {
     #private;
@@ -50,22 +50,22 @@ export type MessageEventData = {
     session: KeySession;
     payload: Uint8Array;
 };
+export type FreeSignalNodeState = {
+    privateIdentityKey: string;
+    sessions: Array<[string, KeySessionState]>;
+    users: Array<[string, string]>;
+    bundles: Array<[string, KeyExchangeDataBundle]>;
+    keyExchange: Array<[string, Crypto.KeyPair]>;
+};
 export declare class FreeSignalNode {
     protected readonly privateIdentityKey: PrivateIdentityKey;
-    protected readonly sessions: SessionMap;
-    protected readonly users: LocalStorage<string, string>;
-    protected readonly bundles: LocalStorage<string, KeyExchangeDataBundle>;
+    protected readonly sessions: Map<string, KeySession>;
+    protected readonly users: Map<string, string>;
+    protected readonly bundles: Map<string, KeyExchangeDataBundle>;
     protected readonly keyExchange: KeyExchange;
-    protected readonly discovers: Set<string>;
-    protected readonly bootstraps: LocalStorage<string, BootstrapRequest>;
-    protected readonly emitter: EventEmitter<"message" | "send" | "handshake" | "bootstrap", NodeEventData>;
-    constructor(storage: Database<{
-        sessions: LocalStorage<string, ExportedKeySession>;
-        users: LocalStorage<string, string>;
-        keyExchange: LocalStorage<string, Crypto.KeyPair>;
-        bundles: LocalStorage<string, KeyExchangeDataBundle>;
-        bootstraps: LocalStorage<string, BootstrapRequest>;
-    }>, privateIdentityKey?: PrivateIdentityKey);
+    protected readonly bootstraps: Map<string, BootstrapRequest>;
+    protected readonly emitter: EventEmitter<"error" | "debug" | "send" | "handshake" | "message" | "bootstrap", NodeEventData>;
+    constructor({ privateIdentityKey, sessions, users, bundles, keyExchange }?: Partial<FreeSignalNodeState>);
     protected messageHandler: EventCallback<NodeEventData, typeof this.emitter>;
     protected sendHandler: EventCallback<NodeEventData, typeof this.emitter>;
     protected handshakeHandler: EventCallback<NodeEventData, typeof this.emitter>;
@@ -74,7 +74,11 @@ export declare class FreeSignalNode {
     onSend: (data: Uint8Array) => void;
     onHandshake: (userId: UserId) => void;
     onRequest: (request: BootstrapRequest) => void;
-    getRequest(userId: string): Promise<BootstrapRequest | undefined>;
+    onError: (error: any) => void;
+    onDebug: (...args: any[]) => void;
+    private error;
+    private debug;
+    getRequest(userId: string): BootstrapRequest | undefined;
     waitHandshaked(userId: UserId | string, timeout?: number): Promise<void>;
     get identityKey(): IdentityKey;
     get userId(): UserId;
@@ -84,23 +88,10 @@ export declare class FreeSignalNode {
     sendHandshake(userId: UserId | string): Promise<void>;
     sendData<T>(receiverId: string | UserId, data: T): Promise<void>;
     sendRelay(relayId: string | UserId, receiverId: string | UserId, data: Datagram): Promise<void>;
-    sendDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<void>;
-    packBootstrap(): Promise<Datagram>;
+    packBootstrap(): Datagram;
     sendBootstrap(receiverId: string | UserId): Promise<void>;
     protected decrypt(datagram: EncryptedDatagram | Datagram | Uint8Array): Promise<MessageEventData>;
-    protected openHandshake(datagram: Datagram | EncryptedDatagram | Uint8Array): Promise<'syn' | 'ack'>;
+    protected openHandshake(datagram: Datagram | EncryptedDatagram | Uint8Array): Promise<"syn" | "ack">;
     protected open(datagram: Datagram | EncryptedDatagram | Uint8Array): Promise<void>;
+    toJSON(): FreeSignalNodeState;
 }
-declare class SessionMap implements LocalStorage<string, KeySession> {
-    readonly storage: LocalStorage<string, ExportedKeySession>;
-    readonly maxSize: number;
-    private readonly cache;
-    constructor(storage: LocalStorage<string, ExportedKeySession>, maxSize?: number);
-    set(key: string, value: KeySession): Promise<void>;
-    get(key: string): Promise<KeySession | undefined>;
-    has(key: string): Promise<boolean>;
-    delete(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    entries(): Promise<Iterable<[string, KeySession]>>;
-}
-export {};

package/dist/node.js CHANGED Viewed

@@ -37,7 +37,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _BootstrapRequest_status;
-import { Datagram, decryptData, DiscoverType, encryptData, EncryptedDatagram, IdentityKey, Protocols, UserId } from "./types.js";
+import { Datagram, decryptData, encryptData, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types.js";
 import { KeyExchange } from "./x3dh.js";
 import { KeySession } from "./double-ratchet.js";
 import { createIdentity } from "./index.js";
@@ -71,8 +71,9 @@ export class BootstrapRequest extends EventEmitter {
 }
 _BootstrapRequest_status = new WeakMap();
 export class FreeSignalNode {
-    constructor(storage, privateIdentityKey) {
-        this.discovers = new Set();
+    constructor({ privateIdentityKey, sessions, users, bundles, keyExchange } = {}) {
+        var _a;
+        this.bootstraps = new Map();
         this.emitter = new EventEmitter();
         this.messageHandler = (data) => this.onMessage({ session: data.session, payload: data.payload });
         this.sendHandler = (data) => this.onSend(data.datagram.toBytes());
@@ -82,16 +83,25 @@ export class FreeSignalNode {
         this.onSend = () => { };
         this.onHandshake = () => { };
         this.onRequest = () => { };
-        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : createIdentity();
-        this.sessions = new SessionMap(storage.sessions);
-        this.users = storage.users;
-        this.keyExchange = new KeyExchange(storage.keyExchange, this.privateIdentityKey);
-        this.bundles = storage.bundles;
-        this.bootstraps = storage.bootstraps;
+        this.onError = () => { };
+        this.onDebug = () => { };
+        this.privateIdentityKey = privateIdentityKey ? PrivateIdentityKey.from(privateIdentityKey) : createIdentity();
+        this.sessions = new Map((_a = sessions === null || sessions === void 0 ? void 0 : sessions.map(([key, value]) => [key, KeySession.from(value)])) !== null && _a !== void 0 ? _a : []);
+        this.users = new Map(users);
+        this.bundles = new Map(bundles);
+        this.keyExchange = new KeyExchange({ privateIdentityKey: this.privateIdentityKey, storage: keyExchange });
         this.emitter.on('message', this.messageHandler);
         this.emitter.on('send', this.sendHandler);
         this.emitter.on('handshake', this.handshakeHandler);
         this.emitter.on('bootstrap', this.bootstrapHandler);
+        this.emitter.on('error', (e) => this.onError(e.error));
+        this.emitter.on('debug', (e) => this.onDebug(e.debug));
+    }
+    error(error) {
+        this.emitter.emit('error', { error });
+    }
+    debug(...args) {
+        this.emitter.emit('debug', { debug: args });
     }
     getRequest(userId) {
         return this.bootstraps.get(userId);
@@ -114,37 +124,49 @@ export class FreeSignalNode {
     }
     encrypt(receiverId, protocol, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sessionTag = yield this.users.get(receiverId.toString());
-            if (!sessionTag)
-                throw new Error("User not found: " + receiverId);
-            const session = yield this.sessions.get(sessionTag);
-            if (!session)
-                throw new Error("Session not found for sessionTag: " + sessionTag);
-            const encrypted = encryptData(session, data);
-            this.sessions.set(receiverId.toString(), session);
-            return { session, userId: UserId.from(receiverId), datagram: new EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
+            try {
+                const sessionTag = this.users.get(receiverId.toString());
+                if (!sessionTag)
+                    throw new Error("User not found: " + receiverId);
+                const session = this.sessions.get(sessionTag);
+                if (!session)
+                    throw new Error("Session not found for sessionTag: " + sessionTag);
+                const encrypted = encryptData(session, data);
+                this.sessions.set(receiverId.toString(), session);
+                return { session, userId: UserId.from(receiverId), datagram: new EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
         });
     }
     sendHandshake(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (data instanceof UserId || typeof data === 'string') {
-                const session = yield this.sessions.get(data.toString());
-                if (!session)
-                    throw new Error("Session not found for userId: " + data.toString());
-                data = session;
+            try {
+                if (data instanceof UserId || typeof data === 'string') {
+                    const session = this.sessions.get(data.toString());
+                    if (!session)
+                        throw new Error("Session not found for userId: " + data.toString());
+                    data = session;
+                }
+                if (data instanceof KeySession) {
+                    //console.debug("Sending Handshake Ack");
+                    const session = this.sessions.get(data.sessionTag);
+                    if (!session)
+                        throw new Error("Session not found for sessionTag: " + data.sessionTag);
+                    this.emitter.emit('send', yield this.encrypt(session.userId, Protocols.HANDSHAKE, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
+                    return;
+                }
             }
-            if (data instanceof KeySession) {
-                //console.debug("Sending Handshake Ack");
-                const session = yield this.sessions.get(data.sessionTag);
-                if (!session)
-                    throw new Error("Session not found for sessionTag: " + data.sessionTag);
-                this.emitter.emit('send', yield this.encrypt(session.userId, Protocols.HANDSHAKE, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
-                return;
+            catch (error) {
+                this.error(error);
+                throw error;
             }
             //console.debug("Sending Handshake Syn");
-            const { session, message } = yield this.keyExchange.digestData(data, encodeData(yield this.keyExchange.generateBundle()));
-            yield this.sessions.set(session.sessionTag, session);
-            yield this.users.set(session.userId.toString(), session.sessionTag);
+            const { session, message } = this.keyExchange.digestData(data, encodeData(this.keyExchange.generateBundle()));
+            this.sessions.set(session.sessionTag, session);
+            this.users.set(session.userId.toString(), session.sessionTag);
             const datagram = new Datagram(Protocols.HANDSHAKE, encodeData(message), session.sessionTag).sign(this.privateIdentityKey.signatureKey);
             this.emitter.emit('send', { session, datagram, userId: session.userId });
         });
@@ -171,219 +193,246 @@ export class FreeSignalNode {
             throw new Error("Session not found for sessionTag: " + sessionTag);
         const datagram = new Datagram(Protocols.PING, undefined, session.sessionTag);
         this.emitter.emit('send', { session, datagram, userId: session.userId });
-    }*/
-    sendDiscover(receiverId, discoverId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //console.debug("Sending Discover");
-            if (receiverId instanceof UserId)
-                receiverId = receiverId.toString();
-            if (discoverId instanceof UserId)
-                discoverId = discoverId.toString();
-            const message = {
-                type: DiscoverType.REQUEST,
-                discoverId
-            };
-            this.discovers.add(receiverId);
-            this.emitter.emit('send', yield this.encrypt(receiverId, Protocols.DISCOVER, encodeData(message)));
-        });
     }
+    public async sendDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<void> {
+        //console.debug("Sending Discover");
+        if (receiverId instanceof UserId)
+            receiverId = receiverId.toString();
+        if (discoverId instanceof UserId)
+            discoverId = discoverId.toString();
+        const message: DiscoverMessage = {
+            type: DiscoverType.REQUEST,
+            discoverId
+        };
+        this.discovers.add(receiverId);
+        this.emitter.emit('send', await this.encrypt(receiverId, Protocols.DISCOVER, encodeData(message)));
+    }*/
     packBootstrap() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Datagram(Protocols.BOOTSTRAP, encodeData(yield this.keyExchange.generateData()));
-        });
+        return new Datagram(Protocols.BOOTSTRAP, encodeData(this.keyExchange.generateData()));
     }
     sendBootstrap(receiverId) {
         return __awaiter(this, void 0, void 0, function* () {
-            //console.debug("Sending Bootstrap");
-            if (yield this.sessions.has(receiverId.toString()))
-                throw new Error("Session exists");
-            const datagram = yield this.packBootstrap();
-            this.emitter.emit('send', { datagram, userId: UserId.from(receiverId) });
+            try {
+                //console.debug("Sending Bootstrap");
+                if (this.sessions.has(receiverId.toString()))
+                    throw new Error("Session exists");
+                const datagram = this.packBootstrap();
+                this.emitter.emit('send', { datagram, userId: UserId.from(receiverId) });
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
         });
     }
     decrypt(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            datagram = EncryptedDatagram.from(datagram);
-            if (!datagram.sessionTag)
-                throw new Error("Datagram not encrypted");
-            const session = yield this.sessions.get(datagram.sessionTag);
-            if (!session)
-                throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-            if (!datagram.verify(session.identityKey.signatureKey))
-                throw new Error("Signature not verified");
-            if (!datagram.payload)
-                throw new Error("Missing payload");
-            const decrypted = decryptData(session, datagram.payload);
-            this.sessions.set(datagram.sessionTag, session);
-            return { session, payload: decrypted };
+            try {
+                datagram = EncryptedDatagram.from(datagram);
+                if (!datagram.sessionTag)
+                    throw new Error("Datagram not encrypted");
+                const session = this.sessions.get(datagram.sessionTag);
+                if (!session)
+                    throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                if (!datagram.verify(session.identityKey.signatureKey))
+                    throw new Error("Signature not verified");
+                if (!datagram.payload)
+                    throw new Error("Missing payload");
+                const decrypted = decryptData(session, datagram.payload);
+                this.sessions.set(datagram.sessionTag, session);
+                return { session, payload: decrypted };
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
         });
     }
     openHandshake(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            const encrypted = EncryptedDatagram.from(datagram);
-            if (!encrypted.payload)
-                throw new Error("Missing payload");
-            if (yield this.sessions.has(encrypted.sessionTag)) {
-                //console.debug("Opening Handshake Ack");
-                const session = yield this.sessions.get(encrypted.sessionTag);
-                const { payload } = yield this.decrypt(encrypted);
-                if (!session)
-                    throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
-                if (!compareBytes(payload, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
-                    throw new Error("Error validating handshake data");
-                return 'ack';
+            try {
+                const encrypted = EncryptedDatagram.from(datagram);
+                if (!encrypted.payload)
+                    throw new Error("Missing payload");
+                if (this.sessions.has(encrypted.sessionTag)) {
+                    //console.debug("Opening Handshake Ack");
+                    const session = this.sessions.get(encrypted.sessionTag);
+                    const { payload } = yield this.decrypt(encrypted);
+                    if (!session)
+                        throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
+                    if (!compareBytes(payload, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
+                        throw new Error("Error validating handshake data");
+                    return 'ack';
+                }
+                //console.debug("Opening Handshake Syn");
+                const data = decodeData(encrypted.payload);
+                if (!encrypted.verify(IdentityKey.from(data.identityKey).signatureKey))
+                    throw new Error("Signature not verified");
+                const { session, associatedData } = this.keyExchange.digestMessage(data);
+                this.sessions.set(session.sessionTag, session);
+                this.users.set(session.userId.toString(), session.sessionTag);
+                this.bundles.set(session.userId.toString(), decodeData(associatedData));
+                return 'syn';
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
             }
-            //console.debug("Opening Handshake Syn");
-            const data = decodeData(encrypted.payload);
-            if (!encrypted.verify(IdentityKey.from(data.identityKey).signatureKey))
-                throw new Error("Signature not verified");
-            const { session, associatedData } = yield this.keyExchange.digestMessage(data);
-            yield this.sessions.set(session.sessionTag, session);
-            yield this.users.set(session.userId.toString(), session.sessionTag);
-            yield this.bundles.set(session.userId.toString(), decodeData(associatedData));
-            return 'syn';
         });
     }
     open(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (datagram instanceof Uint8Array)
-                datagram = Datagram.from(datagram);
-            switch (datagram.protocol) {
-                case Protocols.HANDSHAKE: {
-                    const encrypted = EncryptedDatagram.from(datagram);
-                    if (!encrypted.payload)
-                        throw new Error("Missing payload");
-                    const handshakeState = yield this.openHandshake(datagram);
-                    const session = yield this.sessions.get(encrypted.sessionTag);
-                    if (!session)
-                        throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
-                    if (handshakeState === 'syn')
-                        yield this.sendHandshake(session);
-                    this.emitter.emit('handshake', { session });
-                    return;
-                }
-                case Protocols.MESSAGE:
-                    //console.debug("Opening Message");
-                    this.emitter.emit('message', yield this.decrypt(datagram));
-                    return;
-                case Protocols.RELAY: {
-                    //console.debug("Opening Relay");
-                    const opened = yield this.decrypt(datagram);
-                    const userId = decodeBase64(opened.payload.subarray(0, UserId.keyLength));
-                    const sessionTag = yield this.users.get(userId);
-                    if (!sessionTag)
-                        throw new Error("Session not found for user: " + userId);
-                    const session = yield this.sessions.get(sessionTag);
-                    if (!session)
-                        throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-                    this.emitter.emit('send', { session, datagram: Datagram.from(opened.payload.slice(UserId.keyLength)), userId: session.userId });
-                    return;
-                }
-                case Protocols.DISCOVER: {
-                    //console.debug("Opening Discover");
-                    const { session, payload } = yield this.decrypt(datagram);
-                    const message = decodeData(payload);
-                    if (message.type === DiscoverType.REQUEST && message.discoverId && !(yield this.sessions.has(message.discoverId))) {
-                        let data;
-                        if (message.discoverId === this.userId.toString()) {
-                            data = yield this.keyExchange.generateData();
-                        }
-                        else {
-                            const bundle = yield this.bundles.get(message.discoverId);
-                            if (!bundle)
-                                return;
-                            const { version, identityKey, signedPreKey, signature } = bundle;
-                            const onetimePreKey = bundle.onetimePreKeys.shift();
-                            if (!onetimePreKey) {
-                                yield this.bundles.delete(message.discoverId);
-                                return;
-                            }
-                            data = {
-                                version,
-                                identityKey,
-                                signedPreKey,
-                                signature,
-                                onetimePreKey
-                            };
-                        }
-                        const response = { type: DiscoverType.RESPONSE, discoverId: message.discoverId, data };
-                        this.emitter.emit('send', yield this.encrypt(session.userId, Protocols.DISCOVER, encodeData(response)));
+            try {
+                if (datagram instanceof Uint8Array)
+                    datagram = Datagram.from(datagram);
+                switch (datagram.protocol) {
+                    case Protocols.HANDSHAKE: {
+                        const encrypted = EncryptedDatagram.from(datagram);
+                        if (!encrypted.payload)
+                            throw new Error("Missing payload");
+                        const handshakeState = yield this.openHandshake(datagram);
+                        const session = this.sessions.get(encrypted.sessionTag);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
+                        if (handshakeState === 'syn')
+                            this.sendHandshake(session);
+                        this.emitter.emit('handshake', { session });
+                        return;
                     }
-                    else if (message.type === DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
-                        this.discovers.delete(message.discoverId);
-                        if (message.data)
-                            yield this.sendHandshake(message.data);
+                    case Protocols.MESSAGE:
+                        //console.debug("Opening Message");
+                        this.emitter.emit('message', yield this.decrypt(datagram));
+                        return;
+                    case Protocols.RELAY: {
+                        //console.debug("Opening Relay");
+                        const opened = yield this.decrypt(datagram);
+                        const userId = decodeBase64(opened.payload.subarray(0, UserId.keyLength));
+                        const sessionTag = this.users.get(userId);
+                        if (!sessionTag)
+                            throw new Error("Session not found for user: " + userId);
+                        const session = this.sessions.get(sessionTag);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                        this.emitter.emit('send', { session, datagram: Datagram.from(opened.payload.slice(UserId.keyLength)), userId: session.userId });
+                        return;
                     }
-                    return;
-                }
-                case Protocols.BOOTSTRAP: {
-                    //console.debug("Opening Bootstrap");
-                    if (!datagram.payload)
-                        throw new Error("Invalid Bootstrap");
-                    const keyExchangeData = decodeData(datagram.payload);
-                    const userId = UserId.fromKey(keyExchangeData.identityKey);
-                    const request = new BootstrapRequest(userId, keyExchangeData);
-                    let sended = false;
-                    request.onChange = (request) => {
-                        if (request.status === 'accepted' && !sended) {
-                            sended = true;
-                            this.sendHandshake(request.data);
+                    case Protocols.BOOTSTRAP: {
+                        //console.debug("Opening Bootstrap");
+                        if (!datagram.payload)
+                            throw new Error("Invalid Bootstrap");
+                        const keyExchangeData = decodeData(datagram.payload);
+                        const userId = UserId.fromKey(keyExchangeData.identityKey);
+                        const request = new BootstrapRequest(userId, keyExchangeData);
+                        let sended = false;
+                        request.onChange = (request) => {
+                            if (request.status === 'accepted' && !sended) {
+                                sended = true;
+                                this.sendHandshake(request.data);
+                            }
+                        };
+                        this.bootstraps.set(userId.toString(), request);
+                        this.emitter.emit('bootstrap', { request });
+                        return;
+                    }
+                    /*case Protocols.DISCOVER: {
+                        //console.debug("Opening Discover");
+                        const { session, payload } = await this.decrypt(datagram);
+                        const message = decodeData<DiscoverMessage>(payload);
+                        if (message.type === DiscoverType.REQUEST && message.discoverId && !(await this.sessions.has(message.discoverId))) {
+                            let data: KeyExchangeData;
+                            if (message.discoverId === this.userId.toString()) {
+                                data = await this.keyExchange.generateData();
+                            } else {
+                                const bundle = await this.bundles.get(message.discoverId);
+                                if (!bundle)
+                                    return;
+                                const { version, identityKey, signedPreKey, signature } = bundle;
+                                const onetimePreKey = bundle.onetimePreKeys.shift();
+                                if (!onetimePreKey) {
+                                    await this.bundles.delete(message.discoverId);
+                                    return;
+                                }
+                                data = {
+                                    version,
+                                    identityKey,
+                                    signedPreKey,
+                                    signature,
+                                    onetimePreKey
+                                };
+                            }
+                            const response: DiscoverMessage = { type: DiscoverType.RESPONSE, discoverId: message.discoverId, data };
+                            this.emitter.emit('send', await this.encrypt(session.userId, Protocols.DISCOVER, encodeData(response)));
+                        } else if (message.type === DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
+                            this.discovers.delete(message.discoverId);
+                            if (message.data)
+                                await this.sendHandshake(message.data);
                         }
-                    };
-                    yield this.bootstraps.set(userId.toString(), request);
-                    this.emitter.emit('bootstrap', { request });
-                    return;
+                        return;
+                    }
+                    case Protocols.PING:
+                        datagram = EncryptedDatagram.from(datagram);
+                        const session = await this.sessions.get(datagram.sessionTag!);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                        this.emitter.emit('ping', { session });
+                        return;*/
+                    default:
+                        throw new Error("Invalid protocol");
                 }
-                /*case Protocols.PING:
-                    datagram = EncryptedDatagram.from(datagram);
-                    const session = await this.sessions.get(datagram.sessionTag!);
-                    if (!session)
-                        throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-                    this.emitter.emit('ping', { session });
-                    return;*/
-                default:
-                    throw new Error("Invalid protocol");
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
             }
         });
     }
-}
-class SessionMap {
-    constructor(storage, maxSize = 50) {
-        this.storage = storage;
-        this.maxSize = maxSize;
-        this.cache = new Map();
+    toJSON() {
+        return {
+            privateIdentityKey: this.privateIdentityKey.toString(),
+            sessions: Array.from(this.sessions.entries()).map(([key, session]) => [key, session.toJSON()]),
+            users: Array.from(this.users.entries()),
+            bundles: Array.from(this.bundles),
+            keyExchange: this.keyExchange.toJSON().storage,
+        };
     }
-    set(key, value) {
+}
+/*class SessionMap implements LocalStorage<string, KeySession> {
+    private readonly cache = new Map<string, KeySession>()
+    public constructor(public readonly storage: LocalStorage<string, KeySessionState>, public readonly maxSize = 50) { }
+    public set(key: string, value: KeySession): Promise<void> {
         this.cache.set(key, value);
         return this.storage.set(key, value.toJSON());
     }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.cache.get(key);
-            if (!session) {
-                const sessionData = yield this.storage.get(key);
-                if (!sessionData)
-                    return undefined;
-                return KeySession.from(sessionData);
-            }
-            return session;
-        });
+    public async get(key: string): Promise<KeySession | undefined> {
+        const session = this.cache.get(key);
+        if (!session) {
+            const sessionData = await this.storage.get(key);
+            if (!sessionData)
+                return undefined;
+            return KeySession.from(sessionData);
+        }
+        return session;
     }
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.has(key) || (yield this.storage.has(key));
-        });
+    public async has(key: string): Promise<boolean> {
+        return this.cache.has(key) || await this.storage.has(key);
     }
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.delete(key) || (yield this.storage.delete(key));
-        });
+    public async delete(key: string): Promise<boolean> {
+        return this.cache.delete(key) || await this.storage.delete(key);
     }
-    clear() {
+    public clear(): Promise<void> {
         this.cache.clear();
         return this.storage.clear();
     }
-    entries() {
+    public entries(): Promise<Iterable<[string, KeySession]>> {
         throw new Error("Method not implemented.");
     }
-}
+}*/

package/dist/types.d.ts CHANGED Viewed

@@ -16,7 +16,7 @@
  * 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 type { LocalStorage, Encodable, KeyExchangeData } from "@freesignal/interfaces";
+import type { Encodable, KeyExchangeData } from "@freesignal/interfaces";
 import { EncryptionKeys, KeySession } from "./double-ratchet.js";
 export declare function encryptData(session: KeySession, data: Uint8Array): EncryptedData;
 export declare function decryptData(session: KeySession, encryptedData: Uint8Array): Uint8Array;
@@ -77,7 +77,6 @@ export declare enum Protocols {
     MESSAGE = "/freesignal/message",
     RELAY = "/freesignal/relay",
     HANDSHAKE = "/freesignal/handshake",
-    DISCOVER = "/freesignal/discover",
     BOOTSTRAP = "/freesignal/bootstrap"
 }
 export declare namespace Protocols {
@@ -168,14 +167,4 @@ export declare class EncryptedData implements Encodable {
     };
     static from(data: Uint8Array | EncryptedData): EncryptedData;
 }
-export declare class AsyncMap<K, V> implements LocalStorage<K, V> {
-    private readonly map;
-    constructor(iterable?: Iterable<readonly [K, V]>);
-    set(key: K, value: V): Promise<void>;
-    get(key: K): Promise<V | undefined>;
-    has(key: K): Promise<boolean>;
-    delete(key: K): Promise<boolean>;
-    clear(): Promise<void>;
-    entries(): Promise<Iterable<[K, V]>>;
-}
 export {};

package/dist/types.js CHANGED Viewed

@@ -16,15 +16,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { concatBytes, decodeBase64, encodeBase64, bytesToNumber, numberToBytes, compareBytes, decodeBase64URL } from "@freesignal/utils";
 import crypto from "@freesignal/crypto";
 export function encryptData(session, data) {
@@ -196,10 +187,10 @@ export var Protocols;
 (function (Protocols) {
     Protocols["NULL"] = "";
     //PING = '/freesignal/ping',
+    //DISCOVER = '/freesignal/discover',
     Protocols["MESSAGE"] = "/freesignal/message";
     Protocols["RELAY"] = "/freesignal/relay";
     Protocols["HANDSHAKE"] = "/freesignal/handshake";
-    Protocols["DISCOVER"] = "/freesignal/discover";
     Protocols["BOOTSTRAP"] = "/freesignal/bootstrap";
 })(Protocols || (Protocols = {}));
 (function (Protocols) {
@@ -386,39 +377,35 @@ export class EncryptedData {
 }
 EncryptedData.version = 1;
 EncryptedData.nonceLength = crypto.box.nonceLength;
-export class AsyncMap {
-    constructor(iterable) {
-        this.map = new Map(iterable);
-    }
-    set(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.map.set(key, value);
-            return;
-        });
-    }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.get(key);
-        });
-    }
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.has(key);
-        });
-    }
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.delete(key);
-        });
-    }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.clear();
-        });
-    }
-    entries() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.entries();
-        });
-    }
-}
+/*class AsyncMap<K, V> implements LocalStorage<K, V> {
+    private readonly map: Map<K, V>;
+    constructor(iterable?: Iterable<readonly [K, V]>) {
+        this.map = new Map<K, V>(iterable);
+    }
+    async set(key: K, value: V): Promise<void> {
+        this.map.set(key, value);
+        return;
+    }
+    async get(key: K): Promise<V | undefined> {
+        return this.map.get(key);
+    }
+    async has(key: K): Promise<boolean> {
+        return this.map.has(key);
+    }
+    async delete(key: K): Promise<boolean> {
+        return this.map.delete(key);
+    }
+    async clear(): Promise<void> {
+        return this.map.clear();
+    }
+    async entries(): Promise<Iterable<[K, V]>> {
+        return this.map.entries();
+    }
+}*/

package/dist/x3dh.d.ts CHANGED Viewed

@@ -16,10 +16,10 @@
  * 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 { KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, LocalStorage, Crypto } from "@freesignal/interfaces";
+import { KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, Crypto } from "@freesignal/interfaces";
 import { KeySession } from "./double-ratchet.js";
 import { IdentityKey, PrivateIdentityKey } from "./types.js";
-export interface ExportedKeyExchange {
+export interface KeyExchangeState {
     privateIdentityKey: PrivateIdentityKey;
     storage: Array<[string, Crypto.KeyPair]>;
 }
@@ -29,18 +29,19 @@ export declare class KeyExchange {
     private static readonly maxOPK;
     private readonly privateIdentityKey;
     private readonly storage;
-    constructor(storage: LocalStorage<string, Crypto.KeyPair>, privateIdentityKey?: PrivateIdentityKey);
+    constructor({ storage, privateIdentityKey }?: Partial<KeyExchangeState>);
     get identityKey(): IdentityKey;
     private generateSPK;
     private generateOPK;
-    generateBundle(length?: number): Promise<KeyExchangeDataBundle>;
-    generateData(): Promise<KeyExchangeData>;
-    digestData(message: KeyExchangeData, associatedData?: Uint8Array): Promise<{
+    generateBundle(length?: number): KeyExchangeDataBundle;
+    generateData(): KeyExchangeData;
+    digestData(message: KeyExchangeData, associatedData?: Uint8Array): {
         session: KeySession;
         message: KeyExchangeSynMessage;
-    }>;
-    digestMessage(message: KeyExchangeSynMessage): Promise<{
+    };
+    digestMessage(message: KeyExchangeSynMessage): {
         session: KeySession;
         associatedData: Uint8Array;
-    }>;
+    };
+    toJSON(): KeyExchangeState;
 }

package/dist/x3dh.js CHANGED Viewed

@@ -16,23 +16,14 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import crypto from "@freesignal/crypto";
 import { KeySession } from "./double-ratchet.js";
 import { concatBytes, decodeBase64, encodeBase64, compareBytes } from "@freesignal/utils";
 import { decryptData, encryptData, IdentityKey } from "./types.js";
 import { createIdentity } from "./index.js";
 export class KeyExchange {
-    constructor(storage, privateIdentityKey) {
-        this.storage = storage;
+    constructor({ storage, privateIdentityKey } = {}) {
+        this.storage = new Map(storage);
         this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : createIdentity();
     }
     get identityKey() {
@@ -51,94 +42,92 @@ export class KeyExchange {
         return { onetimePreKey, onetimePreKeyHash };
     }
     generateBundle(length) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { signedPreKey, signedPreKeyHash } = this.generateSPK();
-            const onetimePreKey = new Array(length !== null && length !== void 0 ? length : KeyExchange.maxOPK).fill(0).map(() => this.generateOPK(signedPreKeyHash).onetimePreKey);
-            return {
-                version: KeyExchange.version,
-                identityKey: this.identityKey.toString(),
-                signedPreKey: decodeBase64(signedPreKey.publicKey),
-                signature: decodeBase64(crypto.EdDSA.sign(signedPreKeyHash, this.privateIdentityKey.signatureKey)),
-                onetimePreKeys: onetimePreKey.map(opk => decodeBase64(opk.publicKey))
-            };
-        });
+        const { signedPreKey, signedPreKeyHash } = this.generateSPK();
+        const onetimePreKey = new Array(length !== null && length !== void 0 ? length : KeyExchange.maxOPK).fill(0).map(() => this.generateOPK(signedPreKeyHash).onetimePreKey);
+        return {
+            version: KeyExchange.version,
+            identityKey: this.identityKey.toString(),
+            signedPreKey: decodeBase64(signedPreKey.publicKey),
+            signature: decodeBase64(crypto.EdDSA.sign(signedPreKeyHash, this.privateIdentityKey.signatureKey)),
+            onetimePreKeys: onetimePreKey.map(opk => decodeBase64(opk.publicKey))
+        };
     }
     generateData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { signedPreKey, signedPreKeyHash } = this.generateSPK();
-            const { onetimePreKey } = this.generateOPK(signedPreKeyHash);
-            return {
-                version: KeyExchange.version,
-                identityKey: this.identityKey.toString(),
-                signedPreKey: decodeBase64(signedPreKey.publicKey),
-                signature: decodeBase64(crypto.EdDSA.sign(signedPreKeyHash, this.privateIdentityKey.signatureKey)),
-                onetimePreKey: decodeBase64(onetimePreKey.publicKey)
-            };
-        });
+        const { signedPreKey, signedPreKeyHash } = this.generateSPK();
+        const { onetimePreKey } = this.generateOPK(signedPreKeyHash);
+        return {
+            version: KeyExchange.version,
+            identityKey: this.identityKey.toString(),
+            signedPreKey: decodeBase64(signedPreKey.publicKey),
+            signature: decodeBase64(crypto.EdDSA.sign(signedPreKeyHash, this.privateIdentityKey.signatureKey)),
+            onetimePreKey: decodeBase64(onetimePreKey.publicKey)
+        };
     }
     digestData(message, associatedData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //console.debug("Digest Data")
-            const ephemeralKey = crypto.ECDH.keyPair();
-            const signedPreKey = encodeBase64(message.signedPreKey);
-            const identityKey = IdentityKey.from(message.identityKey);
-            if (!crypto.EdDSA.verify(encodeBase64(message.signature), crypto.hash(signedPreKey), identityKey.signatureKey))
-                throw new Error("Signature verification failed");
-            const onetimePreKey = message.onetimePreKey ? encodeBase64(message.onetimePreKey) : undefined;
-            const signedPreKeyHash = crypto.hash(signedPreKey);
-            const onetimePreKeyHash = onetimePreKey ? crypto.hash(onetimePreKey) : new Uint8Array();
-            const derivedKey = crypto.hkdf(new Uint8Array([
-                ...crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, signedPreKey),
-                ...crypto.ECDH.scalarMult(ephemeralKey.secretKey, identityKey.exchangeKey),
-                ...crypto.ECDH.scalarMult(ephemeralKey.secretKey, signedPreKey),
-                ...onetimePreKey ? crypto.ECDH.scalarMult(ephemeralKey.secretKey, onetimePreKey) : new Uint8Array()
-            ]), new Uint8Array(KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, KeySession.keyLength * 3);
-            const session = new KeySession({ identityKey, remoteKey: identityKey.exchangeKey, rootKey: derivedKey.subarray(0, KeySession.keyLength), headerKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), nextHeaderKey: derivedKey.subarray(KeySession.keyLength * 2) });
-            const encrypted = encryptData(session, concatBytes(crypto.hash(this.identityKey.toBytes()), crypto.hash(identityKey.toBytes()), associatedData !== null && associatedData !== void 0 ? associatedData : new Uint8Array()));
-            if (!encrypted)
-                throw new Error("Decryption error");
-            return {
-                session,
-                message: {
-                    version: KeyExchange.version,
-                    identityKey: this.identityKey.toString(),
-                    ephemeralKey: decodeBase64(ephemeralKey.publicKey),
-                    signedPreKeyHash: decodeBase64(signedPreKeyHash),
-                    onetimePreKeyHash: decodeBase64(onetimePreKeyHash),
-                    associatedData: decodeBase64(encrypted.toBytes())
-                }
-            };
-        });
+        //console.debug("Digest Data")
+        const ephemeralKey = crypto.ECDH.keyPair();
+        const signedPreKey = encodeBase64(message.signedPreKey);
+        const identityKey = IdentityKey.from(message.identityKey);
+        if (!crypto.EdDSA.verify(encodeBase64(message.signature), crypto.hash(signedPreKey), identityKey.signatureKey))
+            throw new Error("Signature verification failed");
+        const onetimePreKey = message.onetimePreKey ? encodeBase64(message.onetimePreKey) : undefined;
+        const signedPreKeyHash = crypto.hash(signedPreKey);
+        const onetimePreKeyHash = onetimePreKey ? crypto.hash(onetimePreKey) : new Uint8Array();
+        const derivedKey = crypto.hkdf(new Uint8Array([
+            ...crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, signedPreKey),
+            ...crypto.ECDH.scalarMult(ephemeralKey.secretKey, identityKey.exchangeKey),
+            ...crypto.ECDH.scalarMult(ephemeralKey.secretKey, signedPreKey),
+            ...onetimePreKey ? crypto.ECDH.scalarMult(ephemeralKey.secretKey, onetimePreKey) : new Uint8Array()
+        ]), new Uint8Array(KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, KeySession.keyLength * 3);
+        const session = new KeySession({ identityKey, remoteKey: identityKey.exchangeKey, rootKey: derivedKey.subarray(0, KeySession.keyLength), headerKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), nextHeaderKey: derivedKey.subarray(KeySession.keyLength * 2) });
+        const encrypted = encryptData(session, concatBytes(crypto.hash(this.identityKey.toBytes()), crypto.hash(identityKey.toBytes()), associatedData !== null && associatedData !== void 0 ? associatedData : new Uint8Array()));
+        if (!encrypted)
+            throw new Error("Decryption error");
+        return {
+            session,
+            message: {
+                version: KeyExchange.version,
+                identityKey: this.identityKey.toString(),
+                ephemeralKey: decodeBase64(ephemeralKey.publicKey),
+                signedPreKeyHash: decodeBase64(signedPreKeyHash),
+                onetimePreKeyHash: decodeBase64(onetimePreKeyHash),
+                associatedData: decodeBase64(encrypted.toBytes())
+            }
+        };
     }
     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);
-            const identityKey = IdentityKey.from(message.identityKey);
-            if (!signedPreKey || !onetimePreKey || !message.identityKey || !message.ephemeralKey)
-                throw new Error("ACK message malformed");
-            if (!this.storage.delete(hash))
-                throw new Error("Bundle store deleting error");
-            const ephemeralKey = encodeBase64(message.ephemeralKey);
-            const derivedKey = crypto.hkdf(new Uint8Array([
-                ...crypto.ECDH.scalarMult(signedPreKey.secretKey, identityKey.exchangeKey),
-                ...crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, ephemeralKey),
-                ...crypto.ECDH.scalarMult(signedPreKey.secretKey, ephemeralKey),
-                ...onetimePreKey ? crypto.ECDH.scalarMult(onetimePreKey.secretKey, ephemeralKey) : new Uint8Array()
-            ]), new Uint8Array(KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, KeySession.keyLength * 3);
-            const session = new KeySession({ identityKey, secretKey: this.privateIdentityKey.exchangeKey, rootKey: derivedKey.subarray(0, KeySession.keyLength), nextHeaderKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), headerKey: derivedKey.subarray(KeySession.keyLength * 2) });
-            const data = decryptData(session, encodeBase64(message.associatedData));
-            if (!data)
-                throw new Error("Error decrypting ACK message");
-            if (!compareBytes(data.subarray(0, 64), concatBytes(crypto.hash(identityKey.toBytes()), crypto.hash(this.identityKey.toBytes()))))
-                throw new Error("Error verifing Associated Data");
-            return {
-                session,
-                associatedData: data.subarray(64)
-            };
-        });
+        //console.debug("Digest Message")
+        const signedPreKey = this.storage.get(message.signedPreKeyHash);
+        const hash = message.signedPreKeyHash.concat(message.onetimePreKeyHash);
+        const onetimePreKey = this.storage.get(hash);
+        const identityKey = IdentityKey.from(message.identityKey);
+        if (!signedPreKey || !onetimePreKey || !message.identityKey || !message.ephemeralKey)
+            throw new Error("ACK message malformed");
+        if (!this.storage.delete(hash))
+            throw new Error("Bundle store deleting error");
+        const ephemeralKey = encodeBase64(message.ephemeralKey);
+        const derivedKey = crypto.hkdf(new Uint8Array([
+            ...crypto.ECDH.scalarMult(signedPreKey.secretKey, identityKey.exchangeKey),
+            ...crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, ephemeralKey),
+            ...crypto.ECDH.scalarMult(signedPreKey.secretKey, ephemeralKey),
+            ...onetimePreKey ? crypto.ECDH.scalarMult(onetimePreKey.secretKey, ephemeralKey) : new Uint8Array()
+        ]), new Uint8Array(KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, KeySession.keyLength * 3);
+        const session = new KeySession({ identityKey, secretKey: this.privateIdentityKey.exchangeKey, rootKey: derivedKey.subarray(0, KeySession.keyLength), nextHeaderKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), headerKey: derivedKey.subarray(KeySession.keyLength * 2) });
+        const data = decryptData(session, encodeBase64(message.associatedData));
+        if (!data)
+            throw new Error("Error decrypting ACK message");
+        if (!compareBytes(data.subarray(0, 64), concatBytes(crypto.hash(identityKey.toBytes()), crypto.hash(this.identityKey.toBytes()))))
+            throw new Error("Error verifing Associated Data");
+        return {
+            session,
+            associatedData: data.subarray(64)
+        };
+    }
+    toJSON() {
+        return {
+            privateIdentityKey: this.privateIdentityKey,
+            storage: Array.from(this.storage.entries())
+        };
     }
 }
 KeyExchange.version = 1;

package/package.json CHANGED Viewed

@@ -1,45 +1,45 @@
-{
-  "name": "@freesignal/protocol",
-  "version": "0.8.3",
-  "description": "Signal Protocol implementation in javascript",
-  "license": "GPL-3.0-or-later",
-  "author": "Christian Braghette",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./double-ratchet": {
-      "import": "./dist/double-ratchet.js",
-      "require": "./dist/double-ratchet.js",
-      "types": "./dist/double-ratchet.d.ts"
-    },
-    "./node": {
-      "import": "./dist/node.js",
-      "require": "./dist/node.js",
-      "types": "./dist/node.d.ts"
-    },
-    "./x3dh": {
-      "import": "./dist/x3dh.js",
-      "require": "./dist/x3dh.js",
-      "types": "./dist/x3dh.d.ts"
-    }
-  },
-  "main": "./dist/index.js",
-  "scripts": {
-    "pretest": "tsc",
-    "test": "node ./dist/test.js",
-    "prepare": "tsc"
-  },
-  "dependencies": {
-    "@freesignal/crypto": "^0.4.2",
-    "@freesignal/interfaces": "^0.3.0",
-    "@freesignal/utils": "^1.5.1",
-    "easyemitter.ts": "^1.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^24.2.1"
-  }
-}
+{
+  "name": "@freesignal/protocol",
+  "version": "0.9.1",
+  "description": "Signal Protocol implementation in TypeScript",
+  "license": "GPL-3.0-or-later",
+  "author": "Christian Braghette",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./double-ratchet": {
+      "import": "./dist/double-ratchet.js",
+      "require": "./dist/double-ratchet.js",
+      "types": "./dist/double-ratchet.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node.js",
+      "require": "./dist/node.js",
+      "types": "./dist/node.d.ts"
+    },
+    "./x3dh": {
+      "import": "./dist/x3dh.js",
+      "require": "./dist/x3dh.js",
+      "types": "./dist/x3dh.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "pretest": "tsc",
+    "test": "node ./dist/test.js",
+    "prepare": "tsc"
+  },
+  "dependencies": {
+    "@freesignal/crypto": "^0.4.2",
+    "@freesignal/interfaces": "^0.3.0",
+    "@freesignal/utils": "^1.5.1",
+    "easyemitter.ts": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.1"
+  }
+}