chemicaljs 1.0.3 → 1.1.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
 
@@ -62,10 +62,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`.
 
 ```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 +104,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 +116,7 @@ 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.
+- Server options to disable services.
 - Easy client components.
 - Easy tab cloaking components.
 

package/client/chemical.js

@@ -0,0 +1,235 @@
+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 = "ultraviolet") {
+    switch (service) {
+        case "ultraviolet":
+            return (
+                window.location.origin +
+                window.__uv$config.prefix +
+                window.__uv$config.encodeUrl(url)
+            );
+            break;
+        case "rammerhead":
+            return window.location.origin + (await rammerheadEncode(url));
+            break;
+        case "scramjet":
+            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");
+    await loadScript("/uv/uv.bundle.js");
+    await loadScript("/uv/uv.config.js");
+    await loadScript("/scramjet/scramjet.codecs.js");
+    await loadScript("/scramjet/scramjet.config.js");
+    await registerSW();
+    chemicalLoaded = true;
+    window.dispatchEvent(new Event("chemicalLoaded"));
+})();

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

@@ -3,25 +3,69 @@ import { createServer } from "node:http";
 import express from "express";
 import wisp from "wisp-server-node";
 import { baremuxPath } from "@mercuryworkshop/bare-mux/node";
-import { libcurlPath } from "@mercuryworkshop/libcurl-transport";
 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() {
+        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.use(express.static(resolve(import.meta.dirname, "client")));
         this.app.use("/baremux/", express.static(baremuxPath));
-        this.app.use("/libcurl/", express.static(libcurlPath));
         this.app.use("/epoxy/", express.static(epoxyPath));
         this.app.use("/uv/", express.static(uvPath));
+        this.app.use("/scramjet/", express.static(scramjetPath));
         this.server.on("request", (req, res) => {
-            this.app(req, res);
+            if (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 (shouldRouteRh(req)) {
+                routeRhUpgrade(req, socket, head);
             } else {
                 socket.end();
             }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "chemicaljs",
-    "version": "1.0.3",
-    "description": "Create your own web proxy using Ultraviolet fast, easy, and no experience required.",
+    "version": "1.1.0",
+    "description": "Easily create your own web proxy with no experience required.",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/chemicaljs/chemical.git"
@@ -11,11 +11,12 @@
     "author": "Nebelung",
     "license": "MIT",
     "dependencies": {
-        "@mercuryworkshop/bare-mux": "^1.1.4",
-        "@mercuryworkshop/epoxy-transport": "^2.0.6",
-        "@mercuryworkshop/libcurl-transport": "^1.3.2",
-        "@titaniumnetwork-dev/ultraviolet": "^3.1.5",
+        "@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,44 +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() {
-    if ("serviceWorker" in navigator) {
-        await navigator.serviceWorker.register("/chemical.sw.js");
-
-        await window.BareMux.SetTransport("CurlMod.LibcurlClient", {
-            wisp: wispURL || (location.protocol === "https:" ? "wss" : "ws") + "://" + location.host + "/wisp/",
-        });
-    } 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/bare.cjs");
-    await loadScript("/libcurl/index.js");
-    await loadScript("/epoxy/index.js");
-    await loadScript("/uv/uv.bundle.js");
-    await loadScript("/uv/uv.config.js");
-    await registerSW();
-    chemicalLoaded = true;
-    window.dispatchEvent(new Event("chemicalLoaded"));
-})();