vigor-bridge 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+type BridgeUtilCryptoResult = {
+    iv: Array<number>;
+    encrypted: Uint8Array<ArrayBuffer>;
+};
+type BridgeTokensType = {
+    validation: {
+        request: string;
+        receive: string;
+    };
+};
+type BridgeTokens = {
+    validation: string;
+    bridge: string;
+    testFn: string;
+    testResult: string;
+    portValidation: {
+        host: string;
+        remote: string;
+    };
+    directValidation: string;
+};
+type BridgeChannelListenerId = symbol & {
+    __brand__: 'Bridge Listener Id';
+};
+type BridgeChannelContent = any;
+type BridgeValidationWrapper = (getEncrypted: (random: string) => BridgeUtilCryptoResult | Promise<BridgeUtilCryptoResult>) => Promise<(<T>(content: BridgeChannelContent) => any)>;
+declare class BridgeDirect {
+    private listeners;
+    private host;
+    private readonly validation;
+    private caches;
+    constructor(listeners: Map<BridgeChannelListenerId, {
+        action: string;
+        callback: BridgeValidationWrapper;
+        type: string;
+        host: boolean;
+    }>, host: boolean, validation: string);
+    addEventListener(action: string, callback: (content: BridgeChannelContent) => void): {
+        id: BridgeChannelListenerId;
+        removeEventListener: () => boolean;
+    };
+    removeEventListener(listenerId: BridgeChannelListenerId): boolean;
+    postMessage(action: string, content: BridgeChannelContent): void;
+    handle(action: string, callback: <T>(content: BridgeChannelContent) => T | Promise<T>): void;
+    request(action: string, content: BridgeChannelContent): Promise<unknown>;
+}
+declare class BridgeChannel {
+    private readonly port;
+    private listeners;
+    private caches;
+    constructor(port: MessagePort);
+    addEventListener(action: string, callback: (content: BridgeChannelContent) => void): {
+        id: BridgeChannelListenerId;
+        removeEventListener: () => boolean;
+    };
+    removeEventListener(listenerId: BridgeChannelListenerId): boolean;
+    postMessage(action: string, content: BridgeChannelContent): void;
+    handle(action: string, callback: <T>(content: BridgeChannelContent) => T | Promise<T>): {
+        id: BridgeChannelListenerId;
+        removeEventListener: () => boolean;
+    };
+    request(action: string, content: BridgeChannelContent): Promise<unknown>;
+    static create(port: MessagePort, host: boolean, validation: {
+        host: string;
+        remote: string;
+    }): Promise<BridgeChannel>;
+}
+declare const BridgeEntry: {
+    create: () => {
+        certification: {
+            tokens: BridgeTokens;
+            type: BridgeTokensType;
+        };
+        bridge: Promise<BridgeDirect | BridgeChannel>;
+    };
+    connect: ({ tokens, type }: {
+        tokens: BridgeTokens;
+        type: BridgeTokensType;
+    }) => Promise<BridgeDirect | BridgeChannel>;
+};
+export default BridgeEntry;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,571 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const Bridge_Error_Messages = {
+    INVALID_TYPE: ({ expected, received }) => `Invalid Type: ${typeof received} (expected: ${expected.map(e => JSON.stringify(e)).join(', ')})`,
+    INVALID_VALIDATION: ({ expected, received }) => `Invalid Validation: ${typeof received} (expected: ${expected.join(', ')})`,
+    INVALID_PORT: ({ expected, received }) => `Invalid Type: ${typeof received} (expected: ${expected.map(e => JSON.stringify(e)).join(', ')})`,
+    MALICIOUS_DATA: ({ position, step }) => `Malicious Data Detected: ${position}`
+};
+class BridgeError extends Error {
+    code;
+    timestamp = new Date();
+    constructor(code, options) {
+        const messageFn = Bridge_Error_Messages[code];
+        const message = `[${code}] ${messageFn(options.data)}`;
+        super(message);
+        this.code = code;
+        this.name = new.target.name;
+        Object.assign(this, options);
+        Object.setPrototypeOf(this, new.target.prototype)(Error).captureStackTrace?.(this, new.target);
+    }
+}
+class BridgeConnectError extends BridgeError {
+    constructor(code, options) {
+        super(code, options);
+    }
+}
+class BridgeDirectError extends BridgeError {
+    constructor(code, options) {
+        super(code, options);
+    }
+}
+class BridgeChannelError extends BridgeError {
+    constructor(code, options) {
+        super(code, options);
+    }
+}
+class BridgeUtilCrypto {
+    static generateRandomHex(length = 100) {
+        const byteLength = Math.ceil(length / 2);
+        const array = new Uint8Array(byteLength);
+        self.crypto.getRandomValues(array);
+        const hex = Array.from(array)
+            .map(byte => byte.toString(16).padStart(2, '0'))
+            .join('');
+        return hex.substring(0, length);
+    }
+    static aes = {
+        convertPassword: async (passwordRaw) => {
+            const encoder = new TextEncoder();
+            const password = encoder.encode(passwordRaw.padEnd(32, '0').substring(0, 32));
+            return await window.crypto.subtle.importKey("raw", password, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+        },
+        encrypt: async (text, passwordRaw) => {
+            const encoder = new TextEncoder();
+            const password = await BridgeUtilCrypto.aes.convertPassword(passwordRaw);
+            const data = encoder.encode(text);
+            const iv = window.crypto.getRandomValues(new Uint8Array(12));
+            const encryptedBuffer = await window.crypto.subtle.encrypt({ name: "AES-GCM", iv: iv }, password, data);
+            return {
+                iv: Array.from(iv),
+                encrypted: new Uint8Array(encryptedBuffer)
+            };
+        },
+        decrypt: async ({ iv: ivArray, encrypted }, passwordRaw) => {
+            const decoder = new TextDecoder();
+            const password = await BridgeUtilCrypto.aes.convertPassword(passwordRaw);
+            const iv = new Uint8Array(ivArray);
+            const decryptedBuffer = await window.crypto.subtle.decrypt({
+                name: "AES-GCM",
+                iv
+            }, password, encrypted);
+            return decoder.decode(decryptedBuffer);
+        }
+    };
+    static hmac = {
+        convertPassword: async (passwordRaw) => {
+            const encoder = new TextEncoder();
+            const passwordBytes = encoder.encode(passwordRaw.padEnd(32, '0').substring(0, 32));
+            return await window.crypto.subtle.importKey("raw", passwordBytes, {
+                name: "HMAC",
+                hash: { name: "SHA-256" }
+            }, false, ["sign", "verify"]);
+        },
+        sign: async (text, passwordRaw) => {
+            const encoder = new TextEncoder();
+            const password = await BridgeUtilCrypto.hmac.convertPassword(passwordRaw);
+            const data = encoder.encode(text);
+            const encryptedBuffer = await window.crypto.subtle.sign("HMAC", password, data);
+            return new Uint8Array(encryptedBuffer);
+        },
+        verify: async (text, passwordRaw, signature) => {
+            const encoder = new TextEncoder();
+            const password = await BridgeUtilCrypto.hmac.convertPassword(passwordRaw);
+            const data = encoder.encode(text);
+            return await window.crypto.subtle.verify("HMAC", password, signature, data);
+        }
+    };
+}
+class BridgeUtilListener {
+    static listenerMap = new Map();
+    static addEventListener(callback) {
+        const listenerId = Symbol("Listener");
+        window.addEventListener("message", callback);
+        this.listenerMap.set(listenerId, callback);
+        return {
+            id: listenerId,
+            removeEventListener: () => this.removeEventListener(listenerId)
+        };
+    }
+    static removeEventListener(listenerId) {
+        const callback = this.listenerMap.get(listenerId);
+        if (!callback)
+            return false;
+        window.removeEventListener("message", callback);
+        this.listenerMap.delete(listenerId);
+        return true;
+    }
+}
+class BridgeDirect {
+    listeners;
+    host;
+    validation;
+    caches = [];
+    constructor(listeners, host, validation) {
+        this.listeners = listeners;
+        this.host = host;
+        this.validation = validation;
+    }
+    addEventListener(action, callback) {
+        const type = "normal";
+        for (const cache of this.caches) {
+            if (cache.action !== action || cache.type !== type)
+                continue;
+            callback(cache.content);
+        }
+        const listenerId = Symbol("LISTENER_NORMAL");
+        this.listeners.set(listenerId, {
+            action,
+            callback: async (getEncrypted) => {
+                const random = BridgeUtilCrypto.generateRandomHex();
+                const encryptedRandom = await getEncrypted(random);
+                const decryptedRandom = await BridgeUtilCrypto.aes.decrypt(encryptedRandom, this.validation);
+                if (decryptedRandom !== random)
+                    throw new BridgeDirectError("MALICIOUS_DATA", {
+                        data: { position: this.host ? "host" : "remote", step: 2 }
+                    });
+                return callback;
+            },
+            type,
+            host: this.host
+        });
+        return {
+            id: listenerId,
+            removeEventListener: () => this.removeEventListener(listenerId)
+        };
+    }
+    removeEventListener(listenerId) {
+        return this.listeners.delete(listenerId);
+    }
+    postMessage(action, content) {
+        const type = "normal";
+        const targets = Array.from(this.listeners.values()).filter(listener => listener.action === action && listener.type === type && listener.host !== this.host);
+        const promises = targets.map(async (listener) => {
+            const callback = await listener.callback(async (random) => {
+                return await BridgeUtilCrypto.aes.encrypt(random, this.validation);
+            });
+            if (callback)
+                callback(content);
+        });
+        Promise.all(promises);
+    }
+    handle(action, callback) {
+        const type = "request";
+        for (const [listenerId, listener] of this.listeners) {
+            if (listener.action !== action || listener.type !== type)
+                continue;
+            this.listeners.delete(listenerId);
+        }
+        for (const cache of this.caches) {
+            if (cache.action !== action || cache.type !== type)
+                continue;
+            callback(cache.content);
+        }
+        const listenerId = Symbol("LISTENER_HANDLE");
+        this.listeners.set(listenerId, {
+            action,
+            callback: async (getEncrypted) => {
+                const random = BridgeUtilCrypto.generateRandomHex();
+                const encryptedRandom = await getEncrypted(random);
+                const decryptedRandom = await BridgeUtilCrypto.aes.decrypt(encryptedRandom, this.validation);
+                if (decryptedRandom !== random)
+                    throw new BridgeDirectError("MALICIOUS_DATA", {
+                        data: { position: this.host ? "host" : "remote", step: 2 }
+                    });
+                return async (content) => {
+                    const { requestId, data, host } = content;
+                    try {
+                        const result = await callback(data);
+                        return {
+                            action,
+                            content: {
+                                success: true,
+                                data: result,
+                                error: null,
+                                responseId: requestId
+                            },
+                            type,
+                            host
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            action,
+                            content: {
+                                success: false,
+                                data: null,
+                                error: (error instanceof Error) ? error.message : error,
+                                responseId: requestId
+                            },
+                            type,
+                            host
+                        };
+                    }
+                };
+            },
+            type,
+            host: this.host
+        });
+    }
+    request(action, content) {
+        return new Promise((resolve, reject) => {
+            const requestId = BridgeUtilCrypto.generateRandomHex();
+            const type = "request";
+            const listener = Array.from(this.listeners.values()).find(listener => listener.action === action && listener.type === type && listener.host !== this.host);
+            listener?.callback(async (random) => {
+                const encryptedRandom = await BridgeUtilCrypto.aes.encrypt(random, this.validation);
+                return encryptedRandom;
+            }).then(callback => callback({
+                action,
+                content: {
+                    requestId,
+                    data: content
+                },
+                type
+            }).then(({ content }) => {
+                const { success, data, error, responseId } = content;
+                if (responseId !== requestId)
+                    return;
+                if (success)
+                    resolve(data);
+                else
+                    reject(error);
+            }));
+        });
+    }
+}
+class BridgeChannel {
+    port;
+    listeners = new Map();
+    caches = [];
+    constructor(port) {
+        this.port = port;
+        port.onmessage = ({ data }) => {
+            this.caches.push({ action: data.action, content: data.content, type: data.type });
+            for (const listener of this.listeners.values()) {
+                if (listener.action !== data.action || listener.type !== data.type)
+                    continue;
+                listener.callback(data.content);
+            }
+        };
+    }
+    addEventListener(action, callback) {
+        const type = "normal";
+        for (const cache of this.caches) {
+            if (cache.action !== action || cache.type !== type)
+                continue;
+            callback(cache.content);
+        }
+        const listenerId = Symbol("LISTENER_NORMAL");
+        this.listeners.set(listenerId, { action, callback, type });
+        return {
+            id: listenerId,
+            removeEventListener: () => this.removeEventListener(listenerId)
+        };
+    }
+    removeEventListener(listenerId) {
+        return this.listeners.delete(listenerId);
+    }
+    postMessage(action, content) {
+        const type = "normal";
+        this.port.postMessage({
+            action,
+            content,
+            type
+        });
+    }
+    handle(action, callback) {
+        const type = "request";
+        for (const [listenerId, listener] of this.listeners) {
+            if (listener.action !== action || listener.type !== type)
+                continue;
+            this.listeners.delete(listenerId);
+        }
+        for (const cache of this.caches) {
+            if (cache.action !== action || cache.type !== type)
+                continue;
+            callback(cache.content);
+        }
+        const listenerId = Symbol("LISTENER_HANDLE");
+        this.listeners.set(listenerId, { action, callback: async (content) => {
+                const type = "response";
+                const { requestId, data } = content;
+                try {
+                    const result = await callback(data);
+                    this.port.postMessage({
+                        action,
+                        content: {
+                            success: true,
+                            data: result,
+                            error: null,
+                            responseId: requestId
+                        },
+                        type
+                    });
+                }
+                catch (error) {
+                    this.port.postMessage({
+                        action,
+                        content: {
+                            success: false,
+                            data: null,
+                            error: (error instanceof Error) ? error.message : error,
+                            responseId: requestId
+                        },
+                        type
+                    });
+                }
+            }, type });
+        return {
+            id: listenerId,
+            removeEventListener: () => this.removeEventListener(listenerId)
+        };
+    }
+    request(action, content) {
+        return new Promise((resolve, reject) => {
+            const listenerId = Symbol("LISTENER_RESPONSE");
+            const requestId = BridgeUtilCrypto.generateRandomHex();
+            this.listeners.set(listenerId, { action, callback: (content) => {
+                    const { success, data, error, responseId } = content;
+                    if (responseId !== requestId)
+                        return;
+                    this.listeners.delete(listenerId);
+                    if (success)
+                        resolve(data);
+                    else
+                        reject(error);
+                }, type: "response" });
+            const type = "request";
+            this.port.postMessage({
+                action,
+                content: {
+                    requestId,
+                    data: content
+                },
+                type
+            });
+        });
+    }
+    static async create(port, host, validation) {
+        await new Promise((resolve, reject) => {
+            const random = BridgeUtilCrypto.generateRandomHex();
+            if (host) {
+                port.onmessage = async ({ data }) => {
+                    if (data.type === 'port-validation-1') {
+                        const encryptedRandom = await BridgeUtilCrypto.aes.encrypt(data.content.random, validation.remote);
+                        port.postMessage({
+                            type: 'port-validation-2',
+                            content: {
+                                random,
+                                encrypted: encryptedRandom
+                            }
+                        });
+                    }
+                    else if (data.type === 'port-validation-3') {
+                        const decryptedRandom = await BridgeUtilCrypto.aes.decrypt(data.content.encrypted, validation.host);
+                        if (decryptedRandom !== random) {
+                            port.close();
+                            return reject(new BridgeChannelError("MALICIOUS_DATA", {
+                                data: {
+                                    position: "host",
+                                    step: 3
+                                }
+                            }));
+                        }
+                        port.postMessage({
+                            type: 'port-validation-4',
+                            content: {}
+                        });
+                        resolve({});
+                    }
+                    else {
+                        port.close();
+                        return reject(new BridgeChannelError("MALICIOUS_DATA", {
+                            data: {
+                                position: "host",
+                                step: 0
+                            }
+                        }));
+                    }
+                };
+            }
+            else {
+                const portValidationRequest = setInterval(() => {
+                    port.postMessage({
+                        type: 'port-validation-1',
+                        content: {
+                            random
+                        }
+                    });
+                }, 100);
+                port.onmessage = async ({ data }) => {
+                    clearInterval(portValidationRequest);
+                    if (data.type === 'port-validation-2') {
+                        const decryptedRandom = await BridgeUtilCrypto.aes.decrypt(data.content.encrypted, validation.remote);
+                        if (decryptedRandom !== random) {
+                            port.close();
+                            return reject(new BridgeChannelError("MALICIOUS_DATA", {
+                                data: {
+                                    position: "remote",
+                                    step: 2
+                                }
+                            }));
+                        }
+                        const encryptedRandom = await BridgeUtilCrypto.aes.encrypt(data.content.random, validation.host);
+                        port.postMessage({
+                            type: 'port-validation-3',
+                            content: {
+                                encrypted: encryptedRandom
+                            }
+                        });
+                    }
+                    else if (data.type === 'port-validation-4') {
+                        resolve({});
+                    }
+                    else {
+                        port.close();
+                        return reject(new BridgeChannelError("MALICIOUS_DATA", {
+                            data: {
+                                position: "host",
+                                step: 0
+                            }
+                        }));
+                    }
+                };
+            }
+        });
+        return new BridgeChannel(port);
+    }
+}
+const BridgeEntry = {
+    create: () => {
+        const type = {
+            validation: {
+                request: BridgeUtilCrypto.generateRandomHex(),
+                receive: BridgeUtilCrypto.generateRandomHex()
+            }
+        };
+        const tokens = {
+            validation: BridgeUtilCrypto.generateRandomHex(),
+            bridge: BridgeUtilCrypto.generateRandomHex(),
+            testFn: BridgeUtilCrypto.generateRandomHex(),
+            testResult: BridgeUtilCrypto.generateRandomHex(),
+            portValidation: {
+                host: BridgeUtilCrypto.generateRandomHex(),
+                remote: BridgeUtilCrypto.generateRandomHex()
+            },
+            directValidation: BridgeUtilCrypto.generateRandomHex()
+        };
+        const bridge = new Promise(async (resolve, reject) => {
+            const connectReceive = BridgeUtilListener.addEventListener(async (event) => {
+                const { data } = event;
+                if (data.type !== type.validation.request)
+                    return;
+                connectReceive.removeEventListener();
+                const main = window[tokens.bridge];
+                delete window[tokens.bridge];
+                const shareContext = ((main) => {
+                    if (main instanceof Map) {
+                        const testFn = main.get(tokens.testFn);
+                        if (typeof testFn === 'function' && testFn() === tokens.testResult)
+                            return true;
+                    }
+                    return false;
+                })(main);
+                const encryptedRandom = await BridgeUtilCrypto.aes.encrypt(data.content.random, tokens.validation);
+                if (shareContext) {
+                    window.postMessage({
+                        type: type.validation.receive,
+                        content: {
+                            encrypted: encryptedRandom,
+                            shareContext
+                        }
+                    }, event.origin);
+                    resolve(new BridgeDirect(main, true, tokens.directValidation));
+                }
+                else {
+                    const channel = new MessageChannel();
+                    const port1 = channel.port1;
+                    window.postMessage({
+                        type: type.validation.receive,
+                        content: {
+                            encrypted: encryptedRandom,
+                            shareContext
+                        }
+                    }, event.origin, [channel.port2]);
+                    resolve(await BridgeChannel.create(port1, true, tokens.portValidation));
+                }
+            });
+        });
+        return { certification: { tokens, type }, bridge };
+    },
+    connect: ({ tokens, type }) => {
+        return new Promise(async (resolve, reject) => {
+            const random = BridgeUtilCrypto.generateRandomHex();
+            const main = window[tokens.bridge] = new Map([[tokens.testFn, () => tokens.testResult]]);
+            const connectValidationRequest = setInterval(() => {
+                window.postMessage({
+                    type: type.validation.request,
+                    content: {
+                        random
+                    }
+                });
+            }, 100);
+            const connectValidationReceive = BridgeUtilListener.addEventListener(async (event) => {
+                const { data } = event;
+                if (data.type !== type.validation.receive)
+                    return;
+                connectValidationReceive.removeEventListener();
+                clearInterval(connectValidationRequest);
+                const decryptedRandom = await BridgeUtilCrypto.aes.decrypt(data.content.encrypted, tokens.validation);
+                if (random !== decryptedRandom)
+                    return reject(new BridgeConnectError("INVALID_VALIDATION", {
+                        data: {
+                            expected: [random],
+                            received: decryptedRandom
+                        }
+                    }));
+                const shareContext = data.content.shareContext;
+                if (shareContext) {
+                    resolve(new BridgeDirect(main, false, tokens.directValidation));
+                }
+                else {
+                    const [port2] = event.ports;
+                    if (!(port2 instanceof MessagePort))
+                        return reject(new BridgeConnectError("INVALID_PORT", {
+                            data: {
+                                expected: ["MessagePort"],
+                                received: port2
+                            }
+                        }));
+                    resolve(await BridgeChannel.create(port2, false, tokens.portValidation));
+                }
+            });
+        });
+    }
+};
+
+exports.default = BridgeEntry;
+//# sourceMappingURL=index.js.map