@freesignal/protocol 0.7.1 → 0.7.4

package/dist/double-ratchet.d.ts

@@ -45,6 +45,7 @@ export declare class KeySession {
     static readonly info: string;
     static readonly maxCount = 65536;
     readonly identityKey: IdentityKey;
+    readonly sessionTag: string;
     private keyPair;
     private rootKey;
     private sendingChain?;

package/dist/double-ratchet.js

@@ -34,8 +34,9 @@ class KeySession {
         this.headerKeys = new Map();
         this.previousKeys = new KeyMap();
         this.identityKey = identityKey;
-        this.keyPair = crypto_1.default.ECDH.keyPair(secretKey);
         this.rootKey = rootKey;
+        this.sessionTag = (0, utils_1.decodeBase64)(crypto_1.default.hkdf(rootKey, new Uint8Array(32).fill(0), "/freesignal/session-authtag", 32));
+        this.keyPair = crypto_1.default.ECDH.keyPair(secretKey);
         if (headerKey)
             this.headerKey = headerKey;
         if (nextHeaderKey) {

package/dist/index.d.ts

@@ -30,6 +30,7 @@ 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>;

package/dist/node.d.ts

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
-import { Datagram, DatagramHeader, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
+import { Datagram, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
 import { KeyExchange } from "./x3dh";
 import { ExportedKeySession, KeySession } from "./double-ratchet";
 import EventEmitter, { EventCall } from "easyemitter.ts";
@@ -33,18 +33,25 @@ export declare class BootstrapRequest extends EventEmitter<'change', BootstrapRe
     deny(): void;
 }
 type NodeEventData = {
-    header: DatagramHeader;
+    session?: KeySession;
     payload?: Uint8Array;
     datagram?: Datagram;
     request?: BootstrapRequest;
+    userId?: UserId;
+};
+type SendEventData = {
+    session?: KeySession;
+    datagram: Datagram;
+    userId: UserId;
 };
 type MessageEventData = {
-    header: DatagramHeader;
+    session: KeySession;
     payload: Uint8Array;
 };
 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 keyExchange: KeyExchange;
     protected readonly discovers: Set<string>;
@@ -52,6 +59,7 @@ export declare class FreeSignalNode {
     protected readonly emitter: EventEmitter<"message" | "send" | "handshake" | "ping" | "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>;
@@ -68,16 +76,16 @@ export declare class FreeSignalNode {
     waitHandshaked(userId: UserId | string, timeout?: number): Promise<void>;
     get identityKey(): IdentityKey;
     get userId(): UserId;
-    protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
+    protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<SendEventData>;
     sendHandshake(data: KeyExchangeData): Promise<void>;
-    sendHandshake(receiverId: string | UserId): Promise<void>;
+    sendHandshake(session: KeySession): Promise<void>;
     sendData<T>(receiverId: string | UserId, data: T): Promise<void>;
-    sendRelay(receiverId: string | UserId, data: Datagram): Promise<void>;
+    sendRelay(relayId: string | UserId, receiverId: string | UserId, data: Datagram): Promise<void>;
     sendPing(receiverId: string | UserId): Promise<void>;
     sendDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<void>;
     sendBootstrap(receiverId: string | UserId): Promise<void>;
-    protected decrypt(datagram: Datagram): Promise<Uint8Array>;
-    protected open(datagram: Datagram | Uint8Array): Promise<void>;
+    protected decrypt(datagram: EncryptedDatagram | Datagram | Uint8Array): Promise<MessageEventData>;
+    protected open(datagram: Datagram | EncryptedDatagram | Uint8Array): Promise<void>;
 }
 declare class SessionMap implements LocalStorage<string, KeySession> {
     readonly storage: LocalStorage<string, ExportedKeySession>;

package/dist/node.js

@@ -82,9 +82,9 @@ class FreeSignalNode {
     constructor(storage, privateIdentityKey) {
         this.discovers = new Set();
         this.emitter = new easyemitter_ts_1.default();
-        this.messageHandler = (data) => { var _a, _b; return this.onMessage({ header: (_a = data.data) === null || _a === void 0 ? void 0 : _a.header, payload: (_b = data.data) === null || _b === void 0 ? void 0 : _b.payload }); };
+        this.messageHandler = (data) => { var _a, _b; return this.onMessage({ session: (_a = data.data) === null || _a === void 0 ? void 0 : _a.session, payload: (_b = data.data) === null || _b === void 0 ? void 0 : _b.payload }); };
         this.sendHandler = (data) => this.onSend(data.data.datagram.toBytes());
-        this.handshakeHandler = (data) => this.onHandshake(types_1.UserId.from(data.data.header.sender));
+        this.handshakeHandler = (data) => { var _a, _b; return this.onHandshake(types_1.UserId.from((_b = (_a = data.data) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.userId)); };
         this.bootstrapHandler = (data) => { var _a; return this.onRequest((_a = data.data) === null || _a === void 0 ? void 0 : _a.request); };
         this.onMessage = () => { };
         this.onSend = () => { };
@@ -92,6 +92,7 @@ class FreeSignalNode {
         this.onRequest = () => { };
         this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
         this.sessions = new SessionMap(storage.sessions);
+        this.users = storage.users;
         this.keyExchange = new x3dh_1.KeyExchange(storage.keyExchange, this.privateIdentityKey);
         this.bundles = storage.bundles;
         this.bootstraps = storage.bootstraps;
@@ -105,10 +106,10 @@ class FreeSignalNode {
     }
     waitHandshaked(userId, timeout) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             if (timeout)
                 setTimeout(() => { throw new Error(); }, timeout);
-            while (((_a = (yield this.emitter.wait('handshake', timeout))) === null || _a === void 0 ? void 0 : _a.header.sender) !== userId.toString())
+            while (((_b = (_a = (yield this.emitter.wait('handshake', timeout))) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.userId.toString()) !== userId.toString())
                 ;
         });
     }
@@ -120,55 +121,58 @@ class FreeSignalNode {
     }
     encrypt(receiverId, protocol, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (receiverId instanceof types_1.UserId)
-                receiverId = receiverId.toString();
-            const session = yield this.sessions.get(receiverId);
+            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 user: " + receiverId);
+                throw new Error("Session not found for sessionTag: " + sessionTag);
             const encrypted = (0, types_1.encryptData)(session, data);
-            this.sessions.set(receiverId, session);
-            return new types_1.Datagram(this.userId.toString(), receiverId, protocol, encrypted).sign(this.privateIdentityKey.signatureKey);
+            this.sessions.set(receiverId.toString(), session);
+            return { session, userId: types_1.UserId.from(receiverId), datagram: new types_1.EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
         });
     }
     sendHandshake(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (typeof data === 'string' || data instanceof types_1.UserId) {
+            if (data instanceof double_ratchet_1.KeySession) {
                 //console.debug("Sending Handshake Ack");
-                const userId = data.toString();
-                const identityKey = (_a = (yield this.sessions.get(userId))) === null || _a === void 0 ? void 0 : _a.identityKey;
-                if (!identityKey)
-                    throw new Error("Missing user");
-                const datagram = yield this.encrypt(userId, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey));
-                this.emitter.emit('send', { header: datagram.header, datagram });
+                const session = yield this.sessions.get(data.sessionTag);
+                if (!session)
+                    throw new Error("Session not found for user: " + data);
+                this.emitter.emit('send', yield this.encrypt(session.userId, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
                 return;
             }
             //console.debug("Sending 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);
-            const datagram = 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);
-            this.emitter.emit('send', { header: datagram.header, datagram });
+            yield this.sessions.set(session.sessionTag, session);
+            yield this.users.set(session.userId.toString(), session.sessionTag);
+            const datagram = new types_1.Datagram(types_1.Protocols.HANDSHAKE, (0, utils_1.encodeData)(message), session.sessionTag).sign(this.privateIdentityKey.signatureKey);
+            this.emitter.emit('send', { session, datagram, userId: session.userId });
         });
     }
     sendData(receiverId, data) {
         return __awaiter(this, void 0, void 0, function* () {
             //console.debug("Sending Data");
-            const datagram = yield this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
-            this.emitter.emit('send', { header: datagram.header, datagram });
+            this.emitter.emit('send', yield this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data)));
         });
     }
-    sendRelay(receiverId, data) {
+    sendRelay(relayId, receiverId, data) {
         return __awaiter(this, void 0, void 0, function* () {
             //console.debug("Sending Relay");
-            const datagram = yield this.encrypt(receiverId, types_1.Protocols.RELAY, data.toBytes());
-            this.emitter.emit('send', { header: datagram.header, datagram });
+            this.emitter.emit('send', yield this.encrypt(relayId, types_1.Protocols.RELAY, (0, utils_1.concatBytes)(types_1.UserId.from(receiverId).toBytes(), data.toBytes())));
         });
     }
     sendPing(receiverId) {
         return __awaiter(this, void 0, void 0, function* () {
             //console.debug("Sending Ping");
-            const datagram = new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.PING);
-            this.emitter.emit('send', { header: datagram.header, datagram });
+            const sessionTag = yield this.users.get(receiverId.toString());
+            if (!sessionTag)
+                throw new Error("Session not found for user: " + receiverId);
+            const session = yield this.sessions.get(sessionTag);
+            if (!session)
+                throw new Error("Session not found for sessionTag: " + sessionTag);
+            const datagram = new types_1.Datagram(types_1.Protocols.PING, undefined, session.sessionTag);
+            this.emitter.emit('send', { session, datagram, userId: session.userId });
         });
     }
     sendDiscover(receiverId, discoverId) {
@@ -183,8 +187,7 @@ class FreeSignalNode {
                 discoverId
             };
             this.discovers.add(receiverId);
-            const datagram = yield this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(message));
-            this.emitter.emit('send', { header: datagram.header, datagram });
+            this.emitter.emit('send', yield this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(message)));
         });
     }
     sendBootstrap(receiverId) {
@@ -192,69 +195,80 @@ class FreeSignalNode {
             //console.debug("Sending Bootstrap");
             if (yield this.sessions.has(receiverId.toString()))
                 throw new Error("Session exists");
-            const datagram = new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
-            this.emitter.emit('send', { header: datagram.header, datagram });
+            const datagram = new types_1.Datagram(types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
+            this.emitter.emit('send', { datagram, userId: types_1.UserId.from(receiverId) });
         });
     }
     decrypt(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            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, identityKey.signatureKey))
-                throw new Error("Signature not verified");
-            const session = yield this.sessions.get(datagram.sender);
+            datagram = types_1.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 user: " + datagram.sender);
+                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 = (0, types_1.decryptData)(session, datagram.payload);
-            this.sessions.set(datagram.sender, session);
-            return decrypted;
+            this.sessions.set(datagram.sessionTag, session);
+            return { session, payload: decrypted };
         });
     }
     open(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             if (datagram instanceof Uint8Array)
                 datagram = types_1.Datagram.from(datagram);
             switch (datagram.protocol) {
-                case types_1.Protocols.HANDSHAKE:
-                    if (!datagram.payload)
+                case types_1.Protocols.HANDSHAKE: {
+                    const encrypted = types_1.EncryptedDatagram.from(datagram);
+                    if (!encrypted.payload)
                         throw new Error("Missing payload");
-                    if (yield this.sessions.has(datagram.sender)) {
+                    if (yield this.sessions.has(encrypted.sessionTag)) {
                         //console.debug("Opening Handshake Ack");
-                        const payload = yield this.decrypt(datagram);
-                        const identityKey = (_a = (yield this.sessions.get(datagram.sender))) === null || _a === void 0 ? void 0 : _a.identityKey;
-                        if (!identityKey)
-                            throw new Error("Missing user");
-                        if (!(0, utils_1.compareBytes)(payload, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey)))
+                        const session = yield this.sessions.get(encrypted.sessionTag);
+                        const { payload } = yield this.decrypt(encrypted);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                        if (!(0, utils_1.compareBytes)(payload, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
                             throw new Error("Error validating handshake data");
-                        this.emitter.emit('handshake', { header: datagram.header });
+                        this.emitter.emit('handshake', { session });
                         return;
                     }
                     //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))
+                    const data = (0, utils_1.decodeData)(encrypted.payload);
+                    if (!datagram.verify(types_1.IdentityKey.from(data.identityKey).signatureKey))
                         throw new Error("Signature not verified");
                     const { session, associatedData } = yield this.keyExchange.digestMessage(data);
-                    yield this.sessions.set(session.userId.toString(), session);
+                    yield this.sessions.set(session.sessionTag, session);
+                    yield this.users.set(session.userId.toString(), session.sessionTag);
                     yield this.bundles.set(session.userId.toString(), (0, utils_1.decodeData)(associatedData));
-                    yield this.sendHandshake(session.userId);
-                    this.emitter.emit('handshake', { header: datagram.header });
+                    yield this.sendHandshake(session);
+                    this.emitter.emit('handshake', { session });
                     return;
+                }
                 case types_1.Protocols.MESSAGE:
                     //console.debug("Opening Message");
-                    this.emitter.emit('message', { header: datagram.header, payload: yield this.decrypt(datagram) });
+                    this.emitter.emit('message', yield this.decrypt(datagram));
                     return;
-                case types_1.Protocols.RELAY:
+                case types_1.Protocols.RELAY: {
                     //console.debug("Opening Relay");
-                    this.emitter.emit('send', { header: types_1.Datagram.from(yield this.decrypt(datagram)) });
+                    const opened = yield this.decrypt(datagram);
+                    const userId = (0, utils_1.decodeBase64)(opened.payload.subarray(0, types_1.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, payload: opened.payload.slice(types_1.UserId.keyLength), userId: session.userId });
                     return;
-                case types_1.Protocols.DISCOVER:
+                }
+                case types_1.Protocols.DISCOVER: {
                     //console.debug("Opening Discover");
-                    const message = (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                    const { session, payload } = yield this.decrypt(datagram);
+                    const message = (0, utils_1.decodeData)(payload);
                     if (message.type === types_1.DiscoverType.REQUEST && message.discoverId && !(yield this.sessions.has(message.discoverId))) {
                         let data;
                         if (message.discoverId === this.userId.toString()) {
@@ -279,7 +293,7 @@ class FreeSignalNode {
                             };
                         }
                         const response = { type: types_1.DiscoverType.RESPONSE, discoverId: message.discoverId, data };
-                        this.emitter.emit('send', yield this.encrypt(datagram.sender, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response)));
+                        this.emitter.emit('send', yield this.encrypt(session.userId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response)));
                     }
                     else if (message.type === types_1.DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
                         this.discovers.delete(message.discoverId);
@@ -287,24 +301,30 @@ class FreeSignalNode {
                             yield this.sendHandshake(message.data);
                     }
                     return;
-                case types_1.Protocols.BOOTSTRAP:
+                }
+                case types_1.Protocols.BOOTSTRAP: {
                     //console.debug("Opening Bootstrap");
                     if (!datagram.payload)
                         throw new Error("Invalid Bootstrap");
                     const keyExchangeData = (0, utils_1.decodeData)(datagram.payload);
-                    if (!(0, utils_1.compareBytes)(types_1.UserId.fromKey(keyExchangeData.identityKey).toBytes(), (0, utils_1.encodeBase64)(datagram.sender)))
-                        new Error("Malicious bootstrap request");
-                    const request = new BootstrapRequest(datagram.sender, keyExchangeData);
-                    request.onChange = () => {
+                    const userId = types_1.UserId.fromKey(keyExchangeData.identityKey);
+                    const request = new BootstrapRequest(userId, keyExchangeData);
+                    request.onChange = (event) => {
+                        var _a;
                         if (!request.data)
                             throw new Error("Error sending handshake");
-                        this.sendHandshake(request.data);
+                        this.sendHandshake((_a = event.data) === null || _a === void 0 ? void 0 : _a.data);
                     };
-                    yield this.bootstraps.set(datagram.sender, request);
-                    this.emitter.emit('bootstrap', { header: datagram.header, request });
+                    yield this.bootstraps.set(userId.toString(), request);
+                    this.emitter.emit('bootstrap', { request });
                     return;
+                }
                 case types_1.Protocols.PING:
-                    this.emitter.emit('ping', { header: datagram.header });
+                    datagram = types_1.EncryptedDatagram.from(datagram);
+                    const session = yield 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");

package/dist/types.d.ts

@@ -22,6 +22,7 @@ export declare function encryptData(session: KeySession, data: Uint8Array): Encr
 export declare function decryptData(session: KeySession, encryptedData: Uint8Array): Uint8Array;
 export declare class UserId implements Encodable {
     private readonly array;
+    static readonly keyLength = 32;
     private constructor();
     toString(): string;
     toJSON(): string;
@@ -86,56 +87,39 @@ export declare namespace Protocols {
     function decode(array: Uint8Array): Protocols;
 }
 interface DatagramJSON {
-    id: string;
     version: number;
-    sender: string;
-    receiver: string;
+    sessionTag: string | undefined;
     protocol: Protocols;
-    createdAt: number;
     payload: string | undefined;
     signature: string | undefined;
 }
 export interface SignedDatagram extends Datagram {
     signature: string;
 }
-export declare class DatagramHeader implements Encodable {
-    static readonly headerLength: number;
-    readonly id: string;
-    readonly version: number;
-    readonly sender: string;
-    readonly receiver: string;
-    readonly protocol: Protocols;
-    readonly createdAt: number;
-    private constructor();
-    toBytes(): Uint8Array;
-    static from(data: Uint8Array | string): DatagramHeader;
-}
-export declare class Datagram implements Encodable, DatagramHeader {
+export declare class Datagram implements Encodable {
     static version: number;
-    private _id;
+    static readonly headerLength = 34;
     private _version;
-    readonly sender: string;
-    readonly receiver: string;
+    readonly sessionTag?: string;
     readonly protocol: Protocols;
-    private _createdAt;
-    private _payload?;
+    readonly payload?: Uint8Array;
     private _signature?;
-    constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
-    get id(): string;
+    constructor(protocol: Protocols, payload?: Uint8Array | Encodable, sessionTag?: Uint8Array | string);
     get version(): number;
-    get createdAt(): number;
-    set payload(data: Uint8Array);
-    get payload(): Uint8Array | undefined;
     get signature(): string | undefined;
     private get unsigned();
-    get header(): DatagramHeader;
     toBytes(): Uint8Array;
     sign(secretKey: Uint8Array): SignedDatagram;
+    verify(publicKey: Uint8Array): boolean;
     toString(): string;
     toJSON(): DatagramJSON;
-    static verify(datagram: Datagram, publicKey: Uint8Array): boolean;
     static from(data: Uint8Array | Datagram | string): Datagram;
 }
+export declare class EncryptedDatagram extends Datagram {
+    readonly sessionTag: string;
+    constructor(protocol: Protocols, sessionTag: Uint8Array | string, payload?: Uint8Array | Encodable);
+    static from(data: Uint8Array | Datagram | string): EncryptedDatagram;
+}
 export declare class EncryptionHeader implements EncryptionKeys, Encodable {
     readonly nonce: Uint8Array;
     static readonly keyLength: number;

package/dist/types.js

@@ -30,7 +30,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncMap = exports.EncryptedData = exports.EncryptionHeader = exports.Datagram = exports.DatagramHeader = exports.Protocols = exports.DiscoverType = exports.PrivateIdentityKey = exports.IdentityKey = exports.UserId = void 0;
+exports.AsyncMap = exports.EncryptedData = exports.EncryptionHeader = exports.EncryptedDatagram = exports.Datagram = exports.Protocols = exports.DiscoverType = exports.PrivateIdentityKey = exports.IdentityKey = exports.UserId = void 0;
 exports.encryptData = encryptData;
 exports.decryptData = decryptData;
 const utils_1 = require("@freesignal/utils");
@@ -90,7 +90,7 @@ class UserId {
             identityKey = (0, utils_1.encodeBase64)(identityKey);
         else if (identityKey instanceof IdentityKey)
             identityKey = (identityKey).toBytes();
-        return new UserId(crypto_1.default.hkdf(identityKey, new Uint8Array(32).fill(0), "/freesignal/userid"));
+        return new UserId(crypto_1.default.hkdf(identityKey, new Uint8Array(32).fill(0), "/freesignal/userid", UserId.keyLength));
     }
     static from(userId) {
         if (typeof userId === 'string')
@@ -99,6 +99,7 @@ class UserId {
     }
 }
 exports.UserId = UserId;
+UserId.keyLength = 32;
 class IdentityKey {
     constructor(identityKey) {
         if (identityKey instanceof IdentityKey) {
@@ -231,52 +232,16 @@ var Protocols;
     Protocols.decode = decode;
 })(Protocols || (exports.Protocols = Protocols = {}));
 ;
-class DatagramHeader {
-    constructor(data) {
-        this.version = data[0] & 127;
-        this.protocol = Protocols.decode(data.subarray(1, 2));
-        this.id = crypto_1.default.UUID.stringify(data.subarray(2, 18));
-        this.createdAt = (0, utils_1.bytesToNumber)(data.subarray(18, 26));
-        this.sender = (0, utils_1.decodeBase64)(data.subarray(26, 26 + crypto_1.default.EdDSA.publicKeyLength));
-        this.receiver = (0, utils_1.decodeBase64)(data.subarray(26 + crypto_1.default.EdDSA.publicKeyLength, DatagramHeader.headerLength));
-    }
-    toBytes() {
-        return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this.version, 1), Protocols.encode(this.protocol, 1), crypto_1.default.UUID.parse(this.id), (0, utils_1.numberToBytes)(this.createdAt, 8), (0, utils_1.encodeBase64)(this.sender), (0, utils_1.encodeBase64)(this.receiver));
-    }
-    static from(data) {
-        if (typeof data === 'string')
-            data = (0, utils_1.encodeBase64)(data);
-        return new DatagramHeader(data);
-    }
-}
-exports.DatagramHeader = DatagramHeader;
-DatagramHeader.headerLength = 26 + crypto_1.default.EdDSA.publicKeyLength * 2;
 class Datagram {
-    constructor(sender, receiver, protocol, payload) {
-        this._id = crypto_1.default.UUID.generate().toString();
+    constructor(protocol, payload, sessionTag) {
         this._version = Datagram.version;
-        this.sender = typeof sender === 'string' ? sender : (0, utils_1.decodeBase64)(sender);
-        this.receiver = typeof receiver === 'string' ? receiver : (0, utils_1.decodeBase64)(receiver);
+        this.sessionTag = sessionTag instanceof Uint8Array ? (0, utils_1.decodeBase64)(sessionTag) : sessionTag;
         this.protocol = protocol;
-        this._createdAt = Date.now();
-        this._payload = payload instanceof Uint8Array ? payload : payload === null || payload === void 0 ? void 0 : payload.toBytes();
-    }
-    get id() {
-        return this._id;
+        this.payload = payload instanceof Uint8Array ? payload : payload === null || payload === void 0 ? void 0 : payload.toBytes();
     }
     get version() {
         return this._version;
     }
-    get createdAt() {
-        return this._createdAt;
-    }
-    set payload(data) {
-        this._signature = undefined;
-        this._payload = data;
-    }
-    get payload() {
-        return this._payload;
-    }
     get signature() {
         return this._signature ? (0, utils_1.decodeBase64)(this._signature) : undefined;
     }
@@ -285,60 +250,48 @@ class Datagram {
         data[0] &= 127;
         return data.subarray(0, data.length - (this._signature ? crypto_1.default.EdDSA.signatureLength : 0));
     }
-    get header() {
-        return DatagramHeader.from(this.toBytes().slice(0, DatagramHeader.headerLength));
-    }
     toBytes() {
-        var _a, _b, _c;
+        var _a, _b;
         return (0, utils_1.concatBytes)(new Uint8Array(1).fill(this.version | (this.signature ? 128 : 0)), //1
         Protocols.encode(this.protocol), //1
-        (_a = crypto_1.default.UUID.parse(this.id)) !== null && _a !== void 0 ? _a : [], //16
-        new Uint8Array((0, utils_1.numberToBytes)(this._createdAt, 8)), //8
-        (0, utils_1.encodeBase64)(this.sender), //32
-        (0, utils_1.encodeBase64)(this.receiver), //32
-        (_b = this._payload) !== null && _b !== void 0 ? _b : new Uint8Array(), (_c = this._signature) !== null && _c !== void 0 ? _c : new Uint8Array());
+        this.sessionTag ? (0, utils_1.encodeBase64)(this.sessionTag) : new Uint8Array(32).fill(0), //32
+        (_a = this.payload) !== null && _a !== void 0 ? _a : new Uint8Array(), (_b = this._signature) !== null && _b !== void 0 ? _b : new Uint8Array());
     }
     sign(secretKey) {
         this._signature = crypto_1.default.EdDSA.sign(this.unsigned, secretKey);
         return this;
     }
+    verify(publicKey) {
+        if (!this._signature)
+            throw new Error("Datagram not signed");
+        return crypto_1.default.EdDSA.verify(this.unsigned, this._signature, publicKey);
+    }
     toString() {
         return (0, utils_1.decodeBase64)(this.toBytes());
     }
     toJSON() {
         return {
-            id: this.id,
             version: this.version,
-            sender: this.sender,
-            receiver: this.receiver,
+            sessionTag: this.sessionTag,
             protocol: this.protocol,
-            createdAt: this.createdAt,
             payload: this.payload ? (0, utils_1.decodeBase64)(this.payload) : undefined,
             signature: this._signature ? (0, utils_1.decodeBase64)(this._signature) : undefined
         };
     }
-    static verify(datagram, publicKey) {
-        if (!datagram._signature)
-            throw new Error("Datagram not signed");
-        return crypto_1.default.EdDSA.verify(datagram.unsigned, datagram._signature, publicKey);
-    }
     static from(data) {
         if (typeof data === 'string')
             data = (0, utils_1.encodeBase64)(data);
         if (data instanceof Uint8Array) {
-            const datagram = new Datagram((0, utils_1.decodeBase64)(data.subarray(26, 26 + crypto_1.default.EdDSA.publicKeyLength)), (0, utils_1.decodeBase64)(data.subarray(26 + crypto_1.default.EdDSA.publicKeyLength, DatagramHeader.headerLength)), Protocols.decode(data.subarray(1, 2)), data.subarray(DatagramHeader.headerLength, data.length - (data[0] & 128 ? crypto_1.default.EdDSA.signatureLength : 0)));
+            const authTag = data.subarray(2, Datagram.headerLength);
+            const datagram = new Datagram(Protocols.decode(data.subarray(1, 2)), data.subarray(Datagram.headerLength, data.length - (data[0] & 128 ? crypto_1.default.EdDSA.signatureLength : 0)), (0, utils_1.compareBytes)(authTag, new Uint8Array(32).fill(0)) ? undefined : (0, utils_1.decodeBase64)(authTag));
             datagram._version = data[0] & 127;
-            datagram._id = crypto_1.default.UUID.stringify(data.subarray(2, 18));
-            datagram._createdAt = (0, utils_1.bytesToNumber)(data.subarray(18, 26));
             if (data[0] & 128)
                 datagram._signature = data.subarray(data.length - crypto_1.default.EdDSA.signatureLength);
             return datagram;
         }
         else if (data instanceof Datagram) {
-            const datagram = new Datagram(data.sender, data.receiver, data.protocol, data.payload);
-            datagram._id = data.id;
+            const datagram = new Datagram(data.protocol, data.payload, data.sessionTag);
             datagram._version = data.version;
-            datagram._createdAt = data._createdAt;
             datagram._signature = data._signature;
             return datagram;
         }
@@ -348,6 +301,19 @@ class Datagram {
 }
 exports.Datagram = Datagram;
 Datagram.version = 1;
+Datagram.headerLength = 34;
+class EncryptedDatagram extends Datagram {
+    constructor(protocol, sessionTag, payload) {
+        super(protocol, payload, sessionTag);
+    }
+    static from(data) {
+        const datagram = Datagram.from(data);
+        if (!datagram.sessionTag)
+            throw new Error("Datagram not encrypted");
+        return datagram;
+    }
+}
+exports.EncryptedDatagram = EncryptedDatagram;
 class EncryptionHeader {
     constructor(keys, nonce) {
         this.nonce = nonce;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -37,8 +37,7 @@
     "@freesignal/crypto": "^0.3.0",
     "@freesignal/interfaces": "^0.2.0",
     "@freesignal/utils": "^1.4.1",
-    "easyemitter.ts": "^1.0.3",
-    "semaphore.ts": "^0.2.0"
+    "easyemitter.ts": "^1.0.3"
   },
   "devDependencies": {
     "@types/node": "^24.2.1"