Merge 5bca760d58 into b45dc6787d

server/monitor-types/websocket-upgrade.js

@@ -0,0 +1,50 @@
+const { MonitorType } = require("./monitor-type");
+const WebSocket = require("ws");
+const { UP, DOWN } = require("../../src/util");
+
+class WebSocketMonitorType extends MonitorType {
+    name = "websocket-upgrade";
+
+    /**
+     * @inheritdoc
+     */
+    async check(monitor, heartbeat, _server) {
+        const [ message, code ] = await this.attemptUpgrade(monitor);
+        heartbeat.status = code === 1000 ? UP : DOWN;
+        heartbeat.msg = message;
+    }
+
+    /**
+     * Uses the builtin Websocket API to establish a connection to target server
+     * @param {object} monitor The monitor object for input parameters.
+     * @returns {[ string, int ]} Array containing a status message and response code
+     */
+    async attemptUpgrade(monitor) {
+        return new Promise((resolve) => {
+            const ws = new WebSocket(monitor.wsurl);
+
+            ws.addEventListener("open", (event) => {
+                // Immediately close the connection
+                ws.close(1000);
+            });
+
+            ws.onerror = (error) => {
+                // Give user the choice to ignore Sec-WebSocket-Accept header
+                if (monitor.wsIgnoreHeaders && error.message === "Invalid Sec-WebSocket-Accept header") {
+                    resolve([ "101 - OK", 1000 ]);
+                }
+                // Upgrade failed, return message to user
+                resolve([ error.message, error.code ]);
+            };
+
+            ws.onclose = (event) => {
+                // Upgrade success, connection closed successfully
+                resolve([ "101 - OK", event.code ]);
+            };
+        });
+    }
+}
+
+module.exports = {
+    WebSocketMonitorType,
+};

server/monitor-types/websocket.js

@@ -1,75 +0,0 @@
-const { MonitorType } = require("./monitor-type");
-const WebSocket = require("ws");
-const { UP, DOWN } = require("../../src/util");
-const childProcessAsync = require("promisify-child-process");
-
-class websocket extends MonitorType {
-    name = "websocket";
-
-    /**
-     * @inheritdoc
-     */
-    async check(monitor, heartbeat, _server) {
-        let statusCode = await this.attemptUpgrade(monitor);
-        //let statusCode = await this.curlTest(monitor.url);
-        this.updateStatus(heartbeat, statusCode);
-    }
-
-    /**
-     * Attempts to upgrade HTTP/HTTPs connection to Websocket. Use curl to send websocket headers to server and returns response code. Close the connection after 1 second and wrap command in bash to return exit code 0 instead of 28.
-     * @param {string} url Full URL of Websocket server
-     * @returns {string} HTTP response code
-     */
-    async curlTest(url) {
-        let res = await childProcessAsync.spawn("bash", [ "-c", "curl -s -o /dev/null -w '%{http_code}' --http1.1 -N --max-time 1 -H 'Upgrade: websocket' -H 'Sec-WebSocket-Key: test' -H 'Sec-WebSocket-Version: 13' " + url + " || true" ], {
-            timeout: 5000,
-            encoding: "utf8",
-        });
-        return res.stdout.toString();
-    }
-
-    /**
-     * Checks if status code is 1000(Normal Closure) and sets status and message
-     * @param {object} heartbeat The heartbeat object to update.
-     * @param {[ string, int ]} status Array containing a status message and response code
-     * @returns {void}
-     */
-    updateStatus(heartbeat, [ message, code ]) {
-        heartbeat.status = code === 1000 ? UP : DOWN;
-        heartbeat.msg = message;
-    }
-
-    /**
-     * Uses the builtin Websocket API to establish a connection to target server
-     * @param {object} monitor The monitor object for input parameters.
-     * @returns {[ string, int ]} Array containing a status message and response code
-     */
-    async attemptUpgrade(monitor) {
-        return new Promise((resolve) => {
-            const ws = new WebSocket(monitor.wsurl);
-
-            ws.addEventListener("open", (event) => {
-                ws.close(1000);
-            });
-
-            ws.onerror = (error) => {
-                // console.log(error.message);
-                // Give user the choice to ignore Sec-WebSocket-Accept header
-                if (monitor.wsIgnoreHeaders && error.message === "Invalid Sec-WebSocket-Accept header") {
-                    resolve([ "101 - OK", 1000 ]);
-                }
-                resolve([ error.message, error.code ]);
-            };
-
-            ws.onclose = (event) => {
-                // console.log(event.message);
-                // console.log(event.code);
-                resolve([ "101 - OK", event.code ]);
-            };
-        });
-    }
-}
-
-module.exports = {
-    websocket,
-};

server/uptime-kuma-server.js

@@ -111,7 +111,7 @@ class UptimeKumaServer {
         // Set Monitor Types
         UptimeKumaServer.monitorTypeList["real-browser"] = new RealBrowserMonitorType();
         UptimeKumaServer.monitorTypeList["tailscale-ping"] = new TailscalePing();
-        UptimeKumaServer.monitorTypeList["websocket"] = new websocket();
+        UptimeKumaServer.monitorTypeList["websocket-upgrade"] = new WebSocketMonitorType();
         UptimeKumaServer.monitorTypeList["dns"] = new DnsMonitorType();
         UptimeKumaServer.monitorTypeList["mqtt"] = new MqttMonitorType();
         UptimeKumaServer.monitorTypeList["snmp"] = new SNMPMonitorType();
@@ -550,7 +550,7 @@ module.exports = {
 // Must be at the end to avoid circular dependencies
 const { RealBrowserMonitorType } = require("./monitor-types/real-browser-monitor-type");
 const { TailscalePing } = require("./monitor-types/tailscale-ping");
-const { websocket } = require("./monitor-types/websocket");
+const { WebSocketMonitorType } = require("./monitor-types/websocket-upgrade");
 const { DnsMonitorType } = require("./monitor-types/dns");
 const { MqttMonitorType } = require("./monitor-types/mqtt");
 const { SNMPMonitorType } = require("./monitor-types/snmp");

src/lang/en.json

@@ -86,7 +86,8 @@
     "ignoreTLSError": "Ignore TLS/SSL errors for HTTPS websites",
     "ignoreTLSErrorGeneral": "Ignore TLS/SSL error for connection",
     "upsideDownModeDescription": "Flip the status upside down. If the service is reachable, it is DOWN.",
-    "wsIgnoreHeadersDescription": "Test non compliant Websocket servers that don't respond with correct headers.",
+    "wsIgnoreHeadersDescription": "The websocket upgrade succeeds, but the server does not reply with Sec-WebSocket-Accept header.",
+    "Ignore Sec-WebSocket-Accept header": "Ignore Sec-WebSocket-Accept header",
     "maxRedirectDescription": "Maximum number of redirects to follow. Set to 0 to disable redirects.",
     "Upside Down Mode": "Upside Down Mode",
     "Max. Redirects": "Max. Redirects",

src/pages/EditMonitor.vue

@@ -47,7 +47,7 @@
                                             HTTP(s) - Browser Engine (Chrome/Chromium) (Beta)
                                         </option>
 
-                                        <option value="websocket">
+                                        <option value="websocket-upgrade">
                                             Websocket Upgrade
                                         </option>
                                     </optgroup>
@@ -123,7 +123,7 @@
                             </div>
 
                             <!-- Websocket -->
-                            <div v-if="monitor.type === 'websocket'" class="my-3">
+                            <div v-if="monitor.type === 'websocket-upgrade'" class="my-3">
                                 <label for="wsurl" class="form-label">{{ $t("URL") }}</label>
                                 <input id="wsurl" v-model="monitor.wsurl" type="wsurl" class="form-control" pattern="wss?://.+" required data-testid="url-input">
                             </div>
@@ -631,10 +631,10 @@
                                 </div>
                             </div>
 
-                            <div v-if="monitor.type === 'websocket' " class="my-3 form-check">
+                            <div v-if="monitor.type === 'websocket-upgrade' " class="my-3 form-check">
                                 <input id="ws-ignore-headers" v-model="monitor.wsIgnoreHeaders" class="form-check-input" type="checkbox">
                                 <label class="form-check-label" for="ws-ignore-headers">
-                                    {{ $t("Ignore Server Headers") }}
+                                    {{ $t("Ignore Sec-WebSocket-Accept header") }}
                                 </label>
                                 <div class="form-text">
                                     {{ $t("wsIgnoreHeadersDescription") }}

test/backend-test/test-websocket.js

@@ -1,12 +1,13 @@
+const { WebSocketServer } = require("ws");
 const { describe, test } = require("node:test");
 const assert = require("node:assert");
-const { websocket } = require("../../server/monitor-types/websocket");
+const { WebSocketMonitorType } = require("../../server/monitor-types/websocket-upgrade");
 const { UP, DOWN, PENDING } = require("../../src/util");
 
 describe("Websocket Test", {
 }, () => {
     test("Non Websocket Server", {}, async () => {
-        const websocketMonitor = new websocket();
+        const websocketMonitor = new WebSocketMonitorType();
 
         const monitor = {
             wsurl: "wss://example.org",
@@ -18,13 +19,17 @@ describe("Websocket Test", {
             status: PENDING,
         };
 
+        const expected = {
+            msg: "Unexpected server response: 200",
+            status: DOWN,
+        };
+
         await websocketMonitor.check(monitor, heartbeat, {});
-        assert.strictEqual(heartbeat.status, DOWN);
-        assert.strictEqual(heartbeat.msg, "Unexpected server response: 200");
+        assert.deepStrictEqual(heartbeat, expected);
     });
 
     test("Secure Websocket", async () => {
-        const websocketMonitor = new websocket();
+        const websocketMonitor = new WebSocketMonitorType();
 
         const monitor = {
             wsurl: "wss://echo.websocket.org",
@@ -36,18 +41,22 @@ describe("Websocket Test", {
             status: PENDING,
         };
 
+        const expected = {
+            msg: "101 - OK",
+            status: UP,
+        };
+
         await websocketMonitor.check(monitor, heartbeat, {});
-        assert.strictEqual(heartbeat.status, UP);
-        assert.strictEqual(heartbeat.msg, "101 - OK");
+        assert.deepStrictEqual(heartbeat, expected);
     });
 
-    test("Insecure Websocket", {
-        skip: !!process.env.CI,
-    }, async () => {
-        const websocketMonitor = new websocket();
+    test("Insecure Websocket", async (t) => {
+        t.after(() => wss.close());
+        const websocketMonitor = new WebSocketMonitorType();
+        const wss = new WebSocketServer({ port: 8080 });
 
         const monitor = {
-            wsurl: "ws://ws.ifelse.io",
+            wsurl: "ws://localhost:8080",
             wsIgnoreHeaders: false,
         };
 
@@ -56,13 +65,17 @@ describe("Websocket Test", {
             status: PENDING,
         };
 
+        const expected = {
+            msg: "101 - OK",
+            status: UP,
+        };
+
         await websocketMonitor.check(monitor, heartbeat, {});
-        assert.strictEqual(heartbeat.status, UP);
-        assert.strictEqual(heartbeat.msg, "101 - OK");
+        assert.deepStrictEqual(heartbeat, expected);
     });
 
     test("Test a non compliant WS server without ignore", async () => {
-        const websocketMonitor = new websocket();
+        const websocketMonitor = new WebSocketMonitorType();
 
         const monitor = {
             wsurl: "wss://c.img-cdn.net/yE4s7KehTFyj/",
@@ -74,13 +87,17 @@ describe("Websocket Test", {
             status: PENDING,
         };
 
+        const expected = {
+            msg: "Invalid Sec-WebSocket-Accept header",
+            status: DOWN,
+        };
+
         await websocketMonitor.check(monitor, heartbeat, {});
-        assert.strictEqual(heartbeat.status, DOWN);
-        assert.strictEqual(heartbeat.msg, "Invalid Sec-WebSocket-Accept header");
+        assert.deepStrictEqual(heartbeat, expected);
     });
 
     test("Test a non compliant WS server with ignore", async () => {
-        const websocketMonitor = new websocket();
+        const websocketMonitor = new WebSocketMonitorType();
 
         const monitor = {
             wsurl: "wss://c.img-cdn.net/yE4s7KehTFyj/",
@@ -92,8 +109,12 @@ describe("Websocket Test", {
             status: PENDING,
         };
 
+        const expected = {
+            msg: "101 - OK",
+            status: UP,
+        };
+
         await websocketMonitor.check(monitor, heartbeat, {});
-        assert.strictEqual(heartbeat.status, UP);
-        assert.strictEqual(heartbeat.msg, "101 - OK");
+        assert.deepStrictEqual(heartbeat, expected);
     });
 });