vigor-bridge 1.0.0

package/rollup.config.mjs

@@ -0,0 +1,25 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'src/index.ts',
+  output: [
+      {
+        file: 'dist/index.js',
+        format: 'cjs',
+        exports: 'named',
+        sourcemap: true,
+      },
+      {
+        file: 'dist/index.mjs',
+        format: 'esm',
+        sourcemap: true,
+      }
+    ],
+  plugins: [
+    resolve(),
+    commonjs(),
+    typescript({ tsconfig: './tsconfig.json' })
+  ]
+};

package/src/index.ts

@@ -0,0 +1,672 @@
+const Bridge_Error_Messages = {
+    INVALID_TYPE: ({expected, received}: {expected: Array<unknown>, received: unknown}) => `Invalid Type: ${typeof received} (expected: ${expected.map(e => JSON.stringify(e)).join(', ')})`,
+    INVALID_VALIDATION: ({expected, received}: {expected: Array<string>, received: unknown}) => `Invalid Validation: ${typeof received} (expected: ${expected.join(', ')})`,
+    INVALID_PORT: ({expected, received}: {expected: Array<unknown>, received: unknown}) => `Invalid Type: ${typeof received} (expected: ${expected.map(e => JSON.stringify(e)).join(', ')})`,
+    MALICIOUS_DATA: ({position, step}: {position: string, step: number}) => `Malicious Data Detected: ${position}`
+}
+
+type BridgeErrorCode = keyof typeof Bridge_Error_Messages
+type BridgeErrorData<C extends BridgeErrorCode> = 
+    Parameters<typeof Bridge_Error_Messages[C]>  extends [infer A]
+        ? A
+        : undefined;
+
+type BridgeErrorOptions<C extends BridgeErrorCode> = {
+    data: BridgeErrorData<C>
+}
+
+class BridgeError<C extends BridgeErrorCode> extends Error {
+    public readonly timestamp: Date = new Date()
+
+    constructor(
+        public readonly code: C,
+        options: BridgeErrorOptions<C>
+    ) {
+        const messageFn = Bridge_Error_Messages[code] as (args: BridgeErrorData<C>) => string
+        const message = `[${code}] ${messageFn(options.data)}`
+        super(message)
+        this.name = new.target.name
+        Object.assign(this, options)
+
+        Object.setPrototypeOf(this, new.target.prototype)
+        (Error as any).captureStackTrace?.(this, new.target)
+    }
+}
+
+class BridgeConnectError<C extends "INVALID_PORT"|"INVALID_VALIDATION"> extends BridgeError<C> {
+    constructor(code: C, options: BridgeErrorOptions<C>) {
+        super(code, options)
+    }
+}
+
+class BridgeDirectError<C extends "MALICIOUS_DATA"> extends BridgeError<C> {
+    constructor(code: C, options: BridgeErrorOptions<C>) {
+        super(code, options)
+    }
+}
+
+class BridgeChannelError<C extends "MALICIOUS_DATA"> extends BridgeError<C> {
+    constructor(code: C, options: BridgeErrorOptions<C>) {
+        super(code, options)
+    }
+}
+
+type BridgeUtilCryptoResult = {
+    iv: Array<number>,
+    encrypted: Uint8Array<ArrayBuffer>
+}
+
+class BridgeUtilCrypto {
+    public static generateRandomHex(length: number = 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);
+    }
+    public static aes = {
+        convertPassword: async(passwordRaw: string) => {
+            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: string, passwordRaw: string): Promise<BridgeUtilCryptoResult> => {
+            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}: BridgeUtilCryptoResult, passwordRaw: string) => {
+            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);
+        }
+    }
+    public static hmac = {
+        convertPassword: async (passwordRaw: string): Promise<CryptoKey> => {
+            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: string, passwordRaw: string) => {
+            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) as BufferSource
+        },
+        verify: async(text: string, passwordRaw: string, signature: BufferSource) => {
+            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
+            )
+        }
+    }
+}
+
+type BridgeUtilListenerId = symbol & {
+    __brand__: "ListenerId"
+}
+
+class BridgeUtilListener {
+    private static listenerMap = new Map<symbol, (event: MessageEvent) => void>()
+    public static addEventListener(callback: (event: MessageEvent) => void) {
+        const listenerId = Symbol("Listener") as unknown as BridgeUtilListenerId
+        window.addEventListener("message", callback)
+        this.listenerMap.set(listenerId, callback)
+        return {
+            id: listenerId,
+            removeEventListener: () => this.removeEventListener(listenerId)
+        }
+    }
+    public static removeEventListener(listenerId: BridgeUtilListenerId) {
+        const callback = this.listenerMap.get(listenerId)
+        if(!callback) return false
+        window.removeEventListener("message", callback)
+        this.listenerMap.delete(listenerId)
+        return true
+    }
+}
+
+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)>;
+
+class BridgeDirect {
+    private caches: Array<{action: string, content: BridgeChannelContent, type: string, host: boolean}> = []
+    constructor(
+        private listeners: Map<
+            BridgeChannelListenerId, 
+            { action: string, callback: BridgeValidationWrapper, type: string, host: boolean }
+        >,
+        private host: boolean,
+        private readonly validation: string
+    ) {
+        
+    }
+    public addEventListener(action: string, callback: (content: BridgeChannelContent) => void) {
+        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") as unknown as BridgeChannelListenerId
+        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)
+        }
+    }
+    public removeEventListener(listenerId: BridgeChannelListenerId) {
+        return this.listeners.delete(listenerId)
+    }
+    public postMessage(action: string, content: BridgeChannelContent) {
+        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: string) => {
+                return await BridgeUtilCrypto.aes.encrypt(random, this.validation)
+            })
+            if (callback) callback(content)
+        });
+        Promise.all(promises)
+    }
+    public handle(action: string, callback: <T>(content: BridgeChannelContent) => T|Promise<T>) {
+        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") as unknown as BridgeChannelListenerId
+        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 as {requestId: number, data: BridgeChannelContent, host: boolean}
+                    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
+        })
+    }
+    public request(action: string, content: BridgeChannelContent) {
+        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: string) => {
+                const encryptedRandom = await BridgeUtilCrypto.aes.encrypt(random, this.validation)
+                return encryptedRandom
+            }).then(callback => callback({
+                action,
+                content: {
+                    requestId,
+                    data: content
+                },
+                type
+            }).then(({content}: {content: {success: boolean, data: unknown, error: unknown, responseId: string}}) => {
+                const {success, data, error, responseId} = content
+                if(responseId !== requestId) return
+                
+                if(success) resolve(data)
+                else reject(error)
+            }))
+        })
+    }
+}
+
+class BridgeChannel {
+    private listeners = new Map<BridgeChannelListenerId, {action: string, callback: (content: BridgeChannelContent) => void, type: string}>()
+    private caches: Array<{action: string, content: BridgeChannelContent, type: string}> = []
+    constructor(
+        private readonly port: MessagePort,
+    ) {
+        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)
+            }
+        }
+    }
+    public addEventListener(action: string, callback: (content: BridgeChannelContent) => void) {
+        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") as unknown as BridgeChannelListenerId
+        this.listeners.set(listenerId, {action, callback, type})
+        return {
+            id: listenerId,
+            removeEventListener: () => this.removeEventListener(listenerId)
+        }
+    }
+    public removeEventListener(listenerId: BridgeChannelListenerId) {
+        return this.listeners.delete(listenerId)
+    }
+    public postMessage(action: string, content: BridgeChannelContent) {
+        const type = "normal"
+        this.port.postMessage({
+            action,
+            content,
+            type
+        })
+    }
+    public handle(action: string, callback: <T>(content: BridgeChannelContent) => T|Promise<T>) {
+        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") as unknown as BridgeChannelListenerId
+        this.listeners.set(listenerId, {action, callback: async(content) => {
+            const type = "response"
+            const {requestId, data} = content as {requestId: number, data: BridgeChannelContent}
+            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)
+        }
+    }
+    public request(action: string, content: BridgeChannelContent) {
+        return new Promise((resolve, reject) => {
+            const listenerId = Symbol("LISTENER_RESPONSE") as unknown as BridgeChannelListenerId
+            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
+            })
+        })
+    }
+    public static async create(
+        port: MessagePort,
+        host: boolean,
+        validation: {
+            host: string,
+            remote: string
+        }
+    ) {
+        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: BridgeTokensType = {
+            validation: {
+                request: BridgeUtilCrypto.generateRandomHex(),
+                receive: BridgeUtilCrypto.generateRandomHex()
+            }
+        }
+        const tokens: BridgeTokens = {
+            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<BridgeChannel|BridgeDirect>(async(resolve, reject) => {
+            const connectReceive = BridgeUtilListener.addEventListener(async(event) => {
+                const {data} = event
+                if(data.type !== type.validation.request) return
+                connectReceive.removeEventListener()
+                const main = (window as any)[tokens.bridge]
+                delete (window as any)[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}: {tokens: BridgeTokens, type: BridgeTokensType}) => {
+        return new Promise<BridgeChannel|BridgeDirect>(async(resolve, reject) => {
+            const random = BridgeUtilCrypto.generateRandomHex()
+            const main = (window as any)[tokens.bridge] = new Map([[tokens.testFn, () => tokens.testResult]]) as Map<any,any>
+            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))
+                }
+            })
+        })
+    }
+}
+
+export default BridgeEntry