chemicaljs 1.0.4 → 1.2.0

package/README.md

@@ -1,5 +1,5 @@
 # Chemical
-Create your own web proxy using Ultraviolet fast, easy, and no experience required.
+Easily create your own web proxy with no experience required.
 
 ## Setup
 
@@ -19,6 +19,17 @@ import { ChemicalServer } from "chemicaljs";
 const chemical = new ChemicalServer();
 ```
 
+You can pass options to disable proxy services and set the default service.
+
+```js
+const chemical = new ChemicalServer({
+    default: "rammerhead",
+    uv: true,
+    scramjet: false,
+    rammerhead: true
+});
+```
+
 3. Use `chemical.app` which is an express app. You may need to import express for certain APIs.
 
 ```js
@@ -62,10 +73,22 @@ In your project create a folder to store your static assets. Create an index.htm
 <script src="/chemical.js"></script>
 ```
 
-2. In a inline script or javascript file, encode a URL with Chemical using `window.chemicalEncode`.
+If you want to set the wisp server to an external server just change the `wisp` attribute.
+
+```html
+<script wisp="wss://wisp.mercurywork.shop" src="/chemical.js"></script>
+```
+
+2. In a inline script or javascript file, encode a URL with Chemical using the async function `window.chemicalEncode`.
+
+```js
+await window.chemicalEncode("https://example.com")
+```
+
+Optional: Change service to `ultraviolet`, `scramjet`, or `rammerhead`. Defaults to `uv` or server option.
 
 ```js
-window.chemicalEncode("https://example.com")
+await window.chemicalEncode("https://example.com", "rammerhead")
 ```
 
 3. You may want to check if Chemical has loaded before encoding a URL.
@@ -92,9 +115,9 @@ Below is a simple example of a simple input that redirects to the encoded URL wh
 <script>
     const search = document.getElementById("search");
 
-    search.addEventListener("keydown", function (e) {
+    search.addEventListener("keydown", async function (e) {
         if (e.key == "Enter" && window.chemicalLoaded && e.target.value) {
-            window.location = window.chemicalEncode(e.target.value)
+            window.location = await window.chemicalEncode(e.target.value)
         }
     })
 </script>
@@ -104,7 +127,6 @@ Below is a simple example of a simple input that redirects to the encoded URL wh
 
 Some features that may come in the future are:
 
-- More proxy services.
 - Easy client components.
 - Easy tab cloaking components.
 

package/client/chemical.js

@@ -0,0 +1,245 @@
+window.chemicalLoaded = false;
+
+function rammerheadEncode(baseUrl) {
+    const mod = (n, m) => ((n % m) + m) % m
+    const baseDictionary =
+        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~-"
+    const shuffledIndicator = "_rhs"
+    const generateDictionary = function () {
+        let str = ""
+        const split = baseDictionary.split("")
+        while (split.length > 0) {
+            str += split.splice(Math.floor(Math.random() * split.length), 1)[0]
+        }
+        return str
+    }
+    class StrShuffler {
+        constructor(dictionary = generateDictionary()) {
+            this.dictionary = dictionary
+        }
+        shuffle(str) {
+            if (str.startsWith(shuffledIndicator)) {
+                return str
+            }
+            let shuffledStr = ""
+            for (let i = 0; i < str.length; i++) {
+                const char = str.charAt(i)
+                const idx = baseDictionary.indexOf(char)
+                if (char === "%" && str.length - i >= 3) {
+                    shuffledStr += char
+                    shuffledStr += str.charAt(++i)
+                    shuffledStr += str.charAt(++i)
+                } else if (idx === -1) {
+                    shuffledStr += char
+                } else {
+                    shuffledStr += this.dictionary.charAt(
+                        mod(idx + i, baseDictionary.length)
+                    )
+                }
+            }
+            return shuffledIndicator + shuffledStr
+        }
+        unshuffle(str) {
+            if (!str.startsWith(shuffledIndicator)) {
+                return str
+            }
+
+            str = str.slice(shuffledIndicator.length)
+
+            let unshuffledStr = ""
+            for (let i = 0; i < str.length; i++) {
+                const char = str.charAt(i)
+                const idx = this.dictionary.indexOf(char)
+                if (char === "%" && str.length - i >= 3) {
+                    unshuffledStr += char
+                    unshuffledStr += str.charAt(++i)
+                    unshuffledStr += str.charAt(++i)
+                } else if (idx === -1) {
+                    unshuffledStr += char
+                } else {
+                    unshuffledStr += baseDictionary.charAt(
+                        mod(idx - i, baseDictionary.length)
+                    )
+                }
+            }
+            return unshuffledStr
+        }
+    }
+    function get(url, callback, shush = false) {
+        var request = new XMLHttpRequest()
+        request.open("GET", url, true)
+        request.send()
+
+        request.onerror = function () {
+            if (!shush) console.log("Cannot communicate with the server")
+        }
+        request.onload = function () {
+            if (request.status === 200) {
+                callback(request.responseText)
+            } else {
+                if (!shush)
+                    console.log(
+                        'unexpected server response to not match "200". Server says "' +
+                        request.responseText +
+                        '"'
+                    )
+            }
+        }
+    }
+    var api = {
+        newsession(callback) {
+            get("/newsession", callback)
+        },
+        sessionexists(id, callback) {
+            get("/sessionexists?id=" + encodeURIComponent(id), function (res) {
+                if (res === "exists") return callback(true)
+                if (res === "not found") return callback(false)
+                console.log("unexpected response from server. received" + res)
+            })
+        },
+        shuffleDict(id, callback) {
+            console.log("Shuffling", id)
+            get("/api/shuffleDict?id=" + encodeURIComponent(id), function (res) {
+                callback(JSON.parse(res))
+            })
+        }
+    }
+    var localStorageKey = "rammerhead_sessionids"
+    var localStorageKeyDefault = "rammerhead_default_sessionid"
+    var sessionIdsStore = {
+        get() {
+            var rawData = localStorage.getItem(localStorageKey)
+            if (!rawData) return []
+            try {
+                var data = JSON.parse(rawData)
+                if (!Array.isArray(data)) throw "getout"
+                return data
+            } catch (e) {
+                return []
+            }
+        },
+        set(data) {
+            if (!data || !Array.isArray(data)) throw new TypeError("must be array")
+            localStorage.setItem(localStorageKey, JSON.stringify(data))
+        },
+        getDefault() {
+            var sessionId = localStorage.getItem(localStorageKeyDefault)
+            if (sessionId) {
+                var data = sessionIdsStore.get()
+                data.filter(function (e) {
+                    return e.id === sessionId
+                })
+                if (data.length) return data[0]
+            }
+            return null
+        },
+        setDefault(id) {
+            localStorage.setItem(localStorageKeyDefault, id)
+        }
+    }
+    function addSession(id) {
+        var data = sessionIdsStore.get()
+        data.unshift({ id: id, createdOn: new Date().toLocaleString() })
+        sessionIdsStore.set(data)
+    }
+    function getSessionId() {
+        return new Promise(resolve => {
+            var id = localStorage.getItem("session-string")
+            api.sessionexists(id, function (value) {
+                if (!value) {
+                    console.log("Session validation failed")
+                    api.newsession(function (id) {
+                        addSession(id)
+                        localStorage.setItem("session-string", id)
+                        console.log(id)
+                        console.log("^ new id")
+                        resolve(id)
+                    })
+                } else {
+                    resolve(id)
+                }
+            })
+        })
+    }
+    var ProxyHref
+
+    return getSessionId().then(id => {
+        return new Promise(resolve => {
+            api.shuffleDict(id, function (shuffleDict) {
+                var shuffler = new StrShuffler(shuffleDict)
+                ProxyHref = "/" + id + "/" + shuffler.shuffle(baseUrl)
+                resolve(ProxyHref)
+            })
+        })
+    })
+}
+
+async function chemicalEncode(url, service = defaultService) {
+    switch (service) {
+        case "uv":
+            if (uvEnabled) {
+                return (
+                    window.location.origin +
+                    window.__uv$config.prefix +
+                    window.__uv$config.encodeUrl(url)
+                );
+            }
+            break;
+        case "rammerhead":
+            if (rammerheadEnabled) {
+                return window.location.origin + (await rammerheadEncode(url));
+            }
+            break;
+        case "scramjet":
+            if (scramjetEnabled) {
+                return (
+                    window.location.origin +
+                    window.__scramjet$config.prefix +
+                    window.__scramjet$config.codec.encode(url)
+                );
+            }
+            break;
+    }
+}
+
+let wispURL = document.currentScript.getAttribute("wisp");
+
+async function registerSW() {
+    const connection = new window.BareMux.BareMuxConnection("/baremux/worker.js");
+    await connection.setTransport("/epoxy/module.js", [{ wisp: wispURL || (location.protocol === "https:" ? "wss" : "ws") + "://" + location.host + "/wisp/" }]);
+
+    if ("serviceWorker" in navigator) {
+        await navigator.serviceWorker.register("/chemical.sw.js");
+    } else {
+        console.error("Service worker failed to register.")
+    }
+}
+
+async function loadScript(src) {
+    await new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.src = src;
+        script.onload = () => {
+            resolve();
+        };
+        script.onerror = () => {
+            reject();
+        };
+        document.head.appendChild(script);
+    });
+}
+
+(async () => {
+    await loadScript("/baremux/index.js");
+    if (uvEnabled) {
+        await loadScript("/uv/uv.bundle.js");
+        await loadScript("/uv/uv.config.js");
+    }
+    if (scramjetEnabled) {
+        await loadScript("/scramjet/scramjet.codecs.js");
+        await loadScript("/scramjet/scramjet.config.js");
+    }
+    await registerSW();
+    chemicalLoaded = true;
+    window.dispatchEvent(new Event("chemicalLoaded"));
+})();

package/client/chemical.sw.js

@@ -0,0 +1,35 @@
+if (uvEnabled) {
+    importScripts("/uv/uv.bundle.js");
+    importScripts("/uv/uv.config.js");
+    importScripts(__uv$config.sw || "/uv/uv.sw.js");
+}
+if (scramjetEnabled) {
+    importScripts("/scramjet/scramjet.codecs.js");
+    importScripts("/scramjet/scramjet.config.js");
+    importScripts(__scramjet$config.bundle || "/scramjet/scramjet.bundle.js");
+    importScripts(__scramjet$config.worker || "/scramjet/scramjet.worker.js");
+}
+
+Object.defineProperty(self, "crossOriginIsolated", { value: true }); // Firefox fix
+
+let uv, scramjet;
+
+if (uvEnabled) {
+    uv = new UVServiceWorker();
+}
+if (scramjetEnabled) {
+    scramjet = new ScramjetServiceWorker();
+}
+
+self.addEventListener("fetch", (event) => {
+    event.respondWith(
+        (async () => {
+            if (uvEnabled && uv.route(event)) {
+                return await uv.fetch(event);
+            } else if (scramjetEnabled && scramjet.route(event)) {
+                return await scramjet.fetch(event);
+            }
+            return await fetch(event.request);
+        })(),
+    );
+});

package/config/scramjet/scramjet.config.js

@@ -0,0 +1,9 @@
+self.__scramjet$config = {
+	prefix: "/~/sj/",
+	codec: self.__scramjet$codecs.plain,
+	config: "/scramjet/scramjet.config.js",
+	bundle: "/scramjet/scramjet.bundle.js",
+	worker: "/scramjet/scramjet.worker.js",
+	client: "/scramjet/scramjet.client.js",
+	codecs: "/scramjet/scramjet.codecs.js",
+};

package/{public → config}/uv/uv.config.js

@@ -1,5 +1,5 @@
 self.__uv$config = {
-	prefix: "/~/",
+	prefix: "/~/uv/",
 	encodeUrl: Ultraviolet.codec.xor.encode,
 	decodeUrl: Ultraviolet.codec.xor.decode,
 	handler: "/uv/uv.handler.js",

package/example/public/index.html

@@ -5,9 +5,9 @@
 <script>
     const search = document.getElementById("search");
 
-    search.addEventListener("keydown", function (e) {
+    search.addEventListener("keydown", async function (e) {
         if (e.key == "Enter" && window.chemicalLoaded && e.target.value) {
-            window.location = window.chemicalEncode(e.target.value)
+            window.location = await window.chemicalEncode(e.target.value, "rammerhead")
         }
     })
 </script>

package/index.js

@@ -1,25 +1,136 @@
 import { resolve } from "node:path";
+import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import express from "express";
 import wisp from "wisp-server-node";
 import { baremuxPath } from "@mercuryworkshop/bare-mux/node";
 import { epoxyPath } from "@mercuryworkshop/epoxy-transport";
 import { uvPath } from "@titaniumnetwork-dev/ultraviolet";
+import { scramjetPath } from "@mercuryworkshop/scramjet";
+import createRammerhead from "rammerhead/src/server/index.js";
 
 class ChemicalServer {
-    constructor() {
+    constructor(options) {
+        if (typeof options !== "object" || Array.isArray(options)) {
+            options = {}
+            console.error("Error: ChemicalServer options invalid.")
+        }
+
+        const rh = createRammerhead()
+
+        const rammerheadScopes = [
+            "/rammerhead.js",
+            "/hammerhead.js",
+            "/transport-worker.js",
+            "/task.js",
+            "/iframe-task.js",
+            "/worker-hammerhead.js",
+            "/messaging",
+            "/sessionexists",
+            "/deletesession",
+            "/newsession",
+            "/editsession",
+            "/needpassword",
+            "/syncLocalStorage",
+            "/api/shuffleDict"
+        ]
+
+        const rammerheadSession = /^\/[a-z0-9]{32}/
+
+        const shouldRouteRh = req => {
+            const url = new URL(req.url, "http://0.0.0.0")
+            return (
+                rammerheadScopes.includes(url.pathname) ||
+                rammerheadSession.test(url.pathname)
+            )
+        }
+
+        const routeRhRequest = (req, res) => {
+            rh.emit("request", req, res)
+        }
+
+        const routeRhUpgrade = (req, socket, head) => {
+            rh.emit("upgrade", req, socket, head)
+        }
+
         this.server = createServer();
         this.app = express();
-        this.app.use(express.static(resolve(import.meta.dirname, "public")));
+        this.app.get("/chemical.js", async function (req, res) {
+            let chemicalMain = await readFileSync(resolve(import.meta.dirname, "client/chemical.js"), "utf8");
+
+            if (options.default) {
+                if (["uv", "rammerhead", "scramjet"].includes(options.default)) {
+                    chemicalMain = `const defaultService = "${options.default}";\n\n` + chemicalMain
+                } else {
+                    chemicalMain = `const defaultService = "uv";\n\n` + chemicalMain
+                    console.error("Error: Chemical default option invalid.")
+                }
+            }
+
+            if (options.uv == false) {
+                chemicalMain = "const uvEnabled = false;\n" + chemicalMain
+            } else {
+                chemicalMain = "const uvEnabled = true;\n" + chemicalMain
+            }
+            if (options.scramjet == false) {
+                chemicalMain = "const scramjetEnabled = false;\n" + chemicalMain
+            } else {
+                chemicalMain = "const scramjetEnabled = true;\n" + chemicalMain
+            }
+            if (options.rammerhead == false) {
+                chemicalMain = "const rammerheadEnabled = false;\n" + chemicalMain
+            } else {
+                chemicalMain = "const rammerheadEnabled = true;\n" + chemicalMain
+            }
+
+            res.type("application/javascript");
+            return res.send(chemicalMain);
+        });
+        this.app.get("/chemical.sw.js", async function (req, res) {
+            let chemicalSW = await readFileSync(resolve(import.meta.dirname, "client/chemical.sw.js"), "utf8");
+
+            if (options.uv == false) {
+                chemicalSW = "const uvEnabled = false;\n\n" + chemicalSW
+            } else {
+                chemicalSW = "const uvEnabled = true;\n\n" + chemicalSW
+            }
+            if (options.scramjet == false) {
+                chemicalSW = "const scramjetEnabled = false;\n" + chemicalSW
+            } else {
+                chemicalSW = "const scramjetEnabled = true;\n" + chemicalSW
+            }
+            if (options.rammerhead == false) {
+                chemicalSW = "const rammerheadEnabled = false;\n" + chemicalSW
+            } else {
+                chemicalSW = "const rammerheadEnabled = true;\n" + chemicalSW
+            }
+
+            res.type("application/javascript");
+            return res.send(chemicalSW);
+        });
+        this.app.use(express.static(resolve(import.meta.dirname, "client")));
         this.app.use("/baremux/", express.static(baremuxPath));
         this.app.use("/epoxy/", express.static(epoxyPath));
-        this.app.use("/uv/", express.static(uvPath));
+        if (options.uv !== false) {
+            this.app.use("/uv/", express.static(resolve(import.meta.dirname, "config/uv")));
+            this.app.use("/uv/", express.static(uvPath));
+        }
+        if (options.scramjet !== false) {
+            this.app.use("/scramjet/", express.static(resolve(import.meta.dirname, "config/scramjet")));
+            this.app.use("/scramjet/", express.static(scramjetPath));
+        }
         this.server.on("request", (req, res) => {
-            this.app(req, res);
+            if (options.rammerhead !== false && shouldRouteRh(req)) {
+                routeRhRequest(req, res);
+            } else {
+                this.app(req, res);
+            }
         });
         this.server.on("upgrade", (req, socket, head) => {
             if (req.url && req.url.endsWith("/wisp/")) {
                 wisp.routeRequest(req, socket, head);
+            } else if (options.rammerhead !== false && shouldRouteRh(req)) {
+                routeRhUpgrade(req, socket, head);
             } else {
                 socket.end();
             }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "chemicaljs",
-    "version": "1.0.4",
-    "description": "Create your own web proxy using Ultraviolet fast, easy, and no experience required.",
+    "version": "1.2.0",
+    "description": "Easily create your own web proxy with no experience required.",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/chemicaljs/chemical.git"
@@ -13,8 +13,10 @@
     "dependencies": {
         "@mercuryworkshop/bare-mux": "^2.0.0",
         "@mercuryworkshop/epoxy-transport": "^2.1.0",
+        "@mercuryworkshop/scramjet": "^1.0.2",
         "@titaniumnetwork-dev/ultraviolet": "^3.2.0",
         "express": "^4.19.2",
+        "rammerhead": "file:rammerhead.tgz",
         "wisp-server-node": "^1.1.0"
     }
 }

package/public/chemical.js

@@ -1,41 +0,0 @@
-window.chemicalLoaded = false;
-
-function chemicalEncode(url) {
-    return window.location.origin + window.__uv$config.prefix + window.__uv$config.encodeUrl(url)
-}
-
-let wispURL = document.currentScript.getAttribute("wisp");
-
-async function registerSW() {
-    const connection = new window.BareMux.BareMuxConnection("/baremux/worker.js");
-    await connection.setTransport("/epoxy/module.js", [{ wisp: wispURL || (location.protocol === "https:" ? "wss" : "ws") + "://" + location.host + "/wisp/" }]);
-
-    if ("serviceWorker" in navigator) {
-        await navigator.serviceWorker.register("/chemical.sw.js");
-    } else {
-        console.error("Service worker failed to register.")
-    }
-}
-
-async function loadScript(src) {
-    await new Promise((resolve, reject) => {
-        const script = document.createElement("script");
-        script.src = src;
-        script.onload = () => {
-            resolve();
-        };
-        script.onerror = () => {
-            reject();
-        };
-        document.head.appendChild(script);
-    });
-}
-
-(async () => {
-    await loadScript("/baremux/index.js");
-    await loadScript("/uv/uv.bundle.js");
-    await loadScript("/uv/uv.config.js");
-    await registerSW();
-    chemicalLoaded = true;
-    window.dispatchEvent(new Event("chemicalLoaded"));
-})();

package/public/chemical.sw.js

@@ -1,19 +0,0 @@
-importScripts("/libcurl/index.js");
-importScripts("/uv/uv.bundle.js");
-importScripts("/uv/uv.config.js");
-importScripts(__uv$config.sw || "/uv/uv.sw.js");
-
-Object.defineProperty(self, "crossOriginIsolated", { value: true }); // Firefox fix
-
-const uv = new UVServiceWorker();
-
-self.addEventListener("fetch", (event) => {
-    event.respondWith(
-        (async () => {
-            if (uv.route(event)) {
-                return await uv.fetch(event);
-            }
-            return await fetch(event.request);
-        })(),
-    );
-});