@freesignal/protocol 0.1.0

package/crypto.d.ts

@@ -0,0 +1,69 @@
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>
+ */
+export type HashAlgorithms = 'sha224' | 'sha256' | 'sha384' | 'sha512';
+export type HmacAlgorithms = 'kmac128' | 'kmac256';
+export interface Crypto {
+    hash(message: Uint8Array, algorithm?: HashAlgorithms): Uint8Array;
+    hmac(key: Uint8Array, message: Uint8Array, length?: number, algorithm?: HmacAlgorithms): Uint8Array;
+    hkdf(key: Uint8Array, salt: Uint8Array, info?: Uint8Array | string, length?: number): Uint8Array;
+    readonly box: Crypto.box;
+    readonly ECDH: Crypto.ECDH;
+    readonly EdDSA: Crypto.EdDSA;
+    randomBytes(n: number): Uint8Array;
+    scalarMult(n: Uint8Array, p: Uint8Array): Uint8Array;
+    generateId(): Crypto.UUID;
+}
+export declare namespace Crypto {
+    type KeyPair = {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    interface box {
+        readonly keyLength: number;
+        readonly nonceLength: number;
+        encrypt(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array;
+        decrypt(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array | undefined;
+    }
+    interface ECDH {
+        readonly publicKeyLength: number;
+        readonly secretKeyLength: number;
+        keyPair(secretKey?: Uint8Array): KeyPair;
+        sharedKey(publicKey: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    }
+    interface EdDSA {
+        readonly publicKeyLength: number;
+        readonly secretKeyLength: number;
+        readonly signatureLength: number;
+        readonly seedLength: number;
+        keyPair(secretKey?: Uint8Array): KeyPair;
+        keyPairFromSeed(seed: Uint8Array): KeyPair;
+        sign(msg: Uint8Array, secretKey: Uint8Array): Uint8Array;
+        verify(msg: Uint8Array, sig: Uint8Array, publicKey: Uint8Array): boolean;
+    }
+    interface UUID {
+        toString(): string;
+        toJSON(): string;
+        toBuffer(): Uint8Array;
+    }
+}
+declare const crypto: Crypto;
+declare namespace crypto {
+    type KeyPair = Crypto.KeyPair;
+}
+export default crypto;

package/crypto.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_sha3_1 = require("js-sha3");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const uuid_1 = require("uuid");
+const utils_1 = require("./utils");
+class CryptoConstructor {
+    constructor() {
+        this.box = new CryptoConstructor.box();
+        this.ECDH = new CryptoConstructor.ECDH();
+        this.EdDSA = new CryptoConstructor.EdDSA();
+        this.randomBytes = tweetnacl_1.default.randomBytes;
+    }
+    hash(message, algorithm = 'sha256') {
+        switch (algorithm) {
+            case 'sha224':
+                return new Uint8Array(js_sha3_1.sha3_224.digest(message));
+            case 'sha256':
+                return new Uint8Array(js_sha3_1.sha3_256.digest(message));
+            case 'sha384':
+                return new Uint8Array(js_sha3_1.sha3_384.digest(message));
+            case 'sha512':
+                return new Uint8Array(js_sha3_1.sha3_512.digest(message));
+            default:
+                throw new Error("Error hashing");
+        }
+    }
+    hmac(key, message, length = 32, algorithm = 'kmac256') {
+        length *= 8;
+        switch (algorithm) {
+            case 'kmac128':
+                return new Uint8Array(js_sha3_1.kmac128.digest(key, message, length, new Uint8Array()));
+            case 'kmac256':
+                return new Uint8Array(js_sha3_1.kmac256.digest(key, message, length, new Uint8Array()));
+            default:
+                throw new Error("Error hashing");
+        }
+    }
+    hkdf(key, salt, info, length = 32) {
+        return new Uint8Array(js_sha3_1.kmac256.digest(key, salt, length * 8, info !== null && info !== void 0 ? info : new Uint8Array()));
+    }
+    scalarMult(n, p) {
+        return tweetnacl_1.default.scalarMult(n, p);
+    }
+    generateId() {
+        return new CryptoConstructor.UUID();
+    }
+}
+(function (CryptoConstructor) {
+    class box {
+        constructor() {
+            this.keyLength = tweetnacl_1.default.secretbox.keyLength;
+            this.nonceLength = tweetnacl_1.default.secretbox.nonceLength;
+        }
+        encrypt(msg, nonce, key) {
+            return tweetnacl_1.default.secretbox(msg, nonce, key);
+        }
+        decrypt(msg, nonce, key) {
+            var _a;
+            return (_a = tweetnacl_1.default.secretbox.open(msg, nonce, key)) !== null && _a !== void 0 ? _a : undefined;
+        }
+    }
+    CryptoConstructor.box = box;
+    class ECDH {
+        constructor() {
+            this.publicKeyLength = tweetnacl_1.default.box.publicKeyLength;
+            this.secretKeyLength = tweetnacl_1.default.box.secretKeyLength;
+        }
+        keyPair(secretKey) {
+            if (secretKey)
+                return tweetnacl_1.default.box.keyPair.fromSecretKey(secretKey);
+            return tweetnacl_1.default.box.keyPair();
+        }
+        sharedKey(publicKey, secretKey) {
+            return tweetnacl_1.default.scalarMult(publicKey, secretKey);
+        }
+    }
+    CryptoConstructor.ECDH = ECDH;
+    class EdDSA {
+        constructor() {
+            this.publicKeyLength = tweetnacl_1.default.sign.publicKeyLength;
+            this.secretKeyLength = tweetnacl_1.default.sign.secretKeyLength;
+            this.signatureLength = tweetnacl_1.default.sign.signatureLength;
+            this.seedLength = tweetnacl_1.default.sign.seedLength;
+        }
+        keyPair(secretKey) {
+            if (secretKey)
+                return tweetnacl_1.default.sign.keyPair.fromSecretKey(secretKey);
+            return tweetnacl_1.default.sign.keyPair();
+        }
+        keyPairFromSeed(seed) {
+            return tweetnacl_1.default.sign.keyPair.fromSeed(seed);
+        }
+        sign(msg, secretKey) {
+            return tweetnacl_1.default.sign.detached(msg, secretKey);
+        }
+        verify(msg, sig, publicKey) {
+            return tweetnacl_1.default.sign.detached.verify(msg, sig, publicKey);
+        }
+    }
+    CryptoConstructor.EdDSA = EdDSA;
+    class UUID {
+        constructor() {
+            this.value = (0, uuid_1.v4)();
+        }
+        toString() {
+            return this.value;
+        }
+        toJSON() {
+            return this.value;
+        }
+        toBuffer() {
+            return (0, utils_1.decodeUTF8)(this.value);
+        }
+    }
+    CryptoConstructor.UUID = UUID;
+})(CryptoConstructor || (CryptoConstructor = {}));
+const crypto = new CryptoConstructor();
+exports.default = crypto;

package/data.d.ts

@@ -0,0 +1,107 @@
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>
+ */
+export interface Encodable {
+    readonly length: number;
+    encode(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+}
+export declare namespace Encodable {
+    function isEncodable(obj: any): boolean;
+}
+export declare enum Protocols {
+    NULL = "",
+    MESSAGE = "/freesignal/message/1.0.0",
+    RELAY = "/freesignal/relay/1.0.0"
+}
+export declare namespace Protocols {
+    function isProtocol(protocol: any): boolean;
+    function fromCode(code: number): Protocols;
+    function toCode(protocol: Protocols): number;
+    function encode(protocol: Protocols, length?: number): Uint8Array;
+    function decode(array: Uint8Array): Protocols;
+}
+export interface Datagram {
+    readonly id: string;
+    readonly version: number;
+    readonly sender: string;
+    readonly receiver: string;
+    readonly protocol: Protocols;
+    payload?: Uint8Array;
+    readonly createdAt: number;
+}
+export declare namespace Datagram {
+    const version = 1;
+    function create(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable): DatagramConstructor;
+    function isDatagram(obj: any): boolean;
+    function from(data: Uint8Array): DatagramConstructor;
+}
+declare class DatagramConstructor implements Encodable, Datagram {
+    readonly createdAt: number;
+    readonly id: string;
+    readonly version: number;
+    readonly sender: string;
+    readonly receiver: string;
+    readonly protocol: Protocols;
+    payload?: Uint8Array;
+    constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
+    constructor(data: Uint8Array | Datagram);
+    get length(): number;
+    encode(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+}
+type Attachment = any;
+export interface Message {
+    readonly version: number;
+    text: string;
+    group?: string;
+    attachments?: Attachment[];
+}
+export declare namespace Message {
+    function isMessage(obj: any): boolean;
+    function create(opts?: {
+        text?: string;
+        group?: string;
+        attachments?: Attachment[];
+    }): MessageConstructor;
+    function from(data: Uint8Array | Message): MessageConstructor;
+}
+declare class MessageConstructor implements Encodable, Message {
+    static readonly version = 1;
+    readonly version: number;
+    text: string;
+    group?: string;
+    attachments?: Attachment[];
+    constructor(opts?: {
+        text?: string;
+        group?: string;
+        attachments?: Attachment[];
+    });
+    constructor(data: Uint8Array | Message);
+    get length(): number;
+    setText(str: string): this;
+    setGroup(str: string): this;
+    addAttachment(obj: Attachment): this;
+    delAttachment(obj: Attachment): this | undefined;
+    encode(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+}
+export {};

package/data.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.Datagram = exports.Protocols = exports.Encodable = void 0;
+const utils_1 = require("./utils");
+const crypto_1 = __importDefault(require("./crypto"));
+var Encodable;
+(function (Encodable) {
+    const properties = ['length', 'encode', 'toString', 'toJSON'];
+    function isEncodable(obj) {
+        return !properties.some(prop => !obj[prop]);
+    }
+    Encodable.isEncodable = isEncodable;
+})(Encodable || (exports.Encodable = Encodable = {}));
+var Protocols;
+(function (Protocols) {
+    Protocols["NULL"] = "";
+    Protocols["MESSAGE"] = "/freesignal/message/1.0.0";
+    Protocols["RELAY"] = "/freesignal/relay/1.0.0";
+})(Protocols || (exports.Protocols = Protocols = {}));
+(function (Protocols) {
+    function isProtocol(protocol) {
+        return Object.values(Protocols).includes(protocol);
+    }
+    Protocols.isProtocol = isProtocol;
+    function fromCode(code) {
+        return Object.values(Protocols)[code];
+    }
+    Protocols.fromCode = fromCode;
+    function toCode(protocol) {
+        return Object.values(Protocols).indexOf(protocol);
+    }
+    Protocols.toCode = toCode;
+    function encode(protocol, length) {
+        const raw = (0, utils_1.numberToUint8Array)(Protocols.toCode(protocol), length).reverse();
+        raw[0] |= (raw.length - 1) << 6;
+        return raw;
+    }
+    Protocols.encode = encode;
+    function decode(array) {
+        array[0] &= 63;
+        array = array.reverse();
+        return Protocols.fromCode((0, utils_1.numberFromUint8Array)(array));
+    }
+    Protocols.decode = decode;
+})(Protocols || (exports.Protocols = Protocols = {}));
+var Datagram;
+(function (Datagram) {
+    Datagram.version = 1;
+    function create(sender, receiver, protocol, payload) {
+        return new DatagramConstructor(sender, receiver, protocol, payload);
+    }
+    Datagram.create = create;
+    function isDatagram(obj) {
+        return obj instanceof DatagramConstructor || (obj && typeof obj === 'object' && 'id' in obj && 'version' in obj && 'sender' in obj && 'receiver' in obj && 'protocol' in obj && 'createdAt' in obj);
+    }
+    Datagram.isDatagram = isDatagram;
+    function from(data) {
+        return new DatagramConstructor(data);
+    }
+    Datagram.from = from;
+})(Datagram || (exports.Datagram = Datagram = {}));
+class DatagramConstructor {
+    constructor(data, receiver, protocol, payload) {
+        if (!receiver && !protocol && !payload) {
+            if (data instanceof Uint8Array) {
+                const obj = (0, utils_1.encodeUTF8)(data).split(',');
+                this.id = obj[0];
+                this.version = parseInt(obj[1]);
+                this.sender = obj[2];
+                this.receiver = obj[3];
+                this.protocol = Protocols.fromCode(parseInt(obj[4]));
+                this.payload = obj[5] ? (0, utils_1.decodeUTF8)(obj[5]) : undefined;
+                this.createdAt = parseInt(obj[6]);
+            }
+            else {
+                const datagram = data;
+                this.id = datagram.id;
+                this.version = datagram.version;
+                this.sender = datagram.sender;
+                this.receiver = datagram.receiver;
+                this.protocol = datagram.protocol;
+                this.payload = datagram.payload;
+                this.createdAt = datagram.createdAt;
+            }
+        }
+        else if (typeof data === 'string' || data instanceof Uint8Array) {
+            this.id = crypto_1.default.generateId().toString();
+            this.version = Datagram.version;
+            this.sender = typeof data === 'string' ? data : (0, utils_1.encodeBase64)(data);
+            this.receiver = typeof receiver === 'string' ? receiver : (0, utils_1.encodeBase64)(receiver);
+            this.protocol = protocol;
+            this.payload = payload instanceof Uint8Array ? payload : payload === null || payload === void 0 ? void 0 : payload.encode();
+            this.createdAt = Date.now();
+        }
+        else
+            throw new Error('Invalid constructor arguments for Datagram');
+    }
+    get length() { return this.encode().length; }
+    encode() {
+        return (0, utils_1.decodeUTF8)([
+            this.id,
+            this.version,
+            this.sender,
+            this.receiver,
+            Protocols.toCode(this.protocol).toString(),
+            this.payload ? this.payload : undefined, this.createdAt
+        ].filter(x => x !== undefined).join(','));
+    }
+    toString() {
+        return this.toJSON();
+    }
+    toJSON() {
+        return JSON.stringify({
+            id: this.id,
+            version: this.version,
+            sender: this.sender,
+            receiver: this.receiver,
+            protocol: this.protocol,
+            payload: this.payload ? (0, utils_1.encodeUTF8)(this.payload) : undefined,
+            createdAt: this.createdAt
+        });
+    }
+}
+var Message;
+(function (Message) {
+    function isMessage(obj) {
+        return obj instanceof MessageConstructor || (obj && typeof obj === 'object' && 'version' in obj && 'text' in obj && 'group' in obj && 'attachments' in obj);
+    }
+    Message.isMessage = isMessage;
+    function create(opts) {
+        return new MessageConstructor(opts);
+    }
+    Message.create = create;
+    ;
+    function from(data) {
+        return new MessageConstructor(data);
+    }
+    Message.from = from;
+})(Message || (exports.Message = Message = {}));
+class MessageConstructor {
+    constructor(opts) {
+        var _a;
+        this.version = MessageConstructor.version;
+        this.text = "";
+        if (Message.isMessage(opts)) {
+            const json = opts;
+            this.version = json.version;
+            this.text = json.text;
+            this.group = json.group;
+            this.attachments = json.attachments;
+        }
+        else if (!opts) {
+            this.text = "";
+        }
+        else if (opts instanceof Uint8Array) {
+            const arr = (0, utils_1.encodeUTF8)(opts).split(',');
+            this.version = arr[0];
+            this.text = (_a = arr[1]) !== null && _a !== void 0 ? _a : "";
+            this.group = arr[2];
+            this.attachments = arr[3] ? JSON.parse(arr[3]) : undefined;
+        }
+        else if (typeof opts === 'object') {
+            const { text, group, attachments } = opts;
+            this.text = text || "";
+            this.group = group;
+            this.attachments = attachments || [];
+        }
+        else {
+            throw new Error('Invalid constructor arguments for Message');
+        }
+    }
+    get length() { return this.encode().length; }
+    setText(str) {
+        this.text = str;
+        return this;
+    }
+    setGroup(str) {
+        this.group = str;
+        return this;
+    }
+    addAttachment(obj) {
+        if (this.attachments)
+            this.attachments.push(obj);
+        else
+            this.attachments = [obj];
+        return this;
+    }
+    delAttachment(obj) {
+        var _a;
+        const index = (_a = this.attachments) === null || _a === void 0 ? void 0 : _a.indexOf(obj);
+        if (!index || !this.attachments)
+            return undefined;
+        this.attachments = this.attachments.filter((v, i) => index !== i);
+        return this;
+    }
+    encode() {
+        return (0, utils_1.decodeUTF8)([this.version, this.text, this.group, JSON.stringify(this.attachments || [])].join(','));
+    }
+    toString() {
+        return this.toJSON();
+    }
+    toJSON() {
+        return JSON.stringify({
+            version: MessageConstructor.version,
+            text: this.text,
+            group: this.group,
+            attachments: JSON.stringify(this.attachments)
+        });
+    }
+}
+MessageConstructor.version = 1;