diff --git a/docs/index.md b/docs/index.md index 424e4f8..a12eae7 100644 --- a/docs/index.md +++ b/docs/index.md @@ -132,6 +132,7 @@ Termix connects to a [RustDesk](https://rustdesk.com) device the way the RustDes - By default Termix finds the device through the public RustDesk server. To use your own, set the ID server, relay server and key in the admin settings, under Remote Desktop. The key is the contents of `id_ed25519.pub` on your server. A host can also set its own server. - The Termix server talks to the ID server on TCP 21116 and the relay on TCP 21117. It always goes through the relay, since a server can't hole punch. - Direct IP access connects to the host address on port 21118 instead, with no ID server. Turn on Direct IP access in RustDesk on the device first. The connection is encrypted, but with no ID server nothing proves which device answered. Jump hosts work in this mode. +- Older RustDesk versions answer direct IP access without encryption, and Termix refuses that by default. Turn on Allow unencrypted sessions on the host to connect anyway, and only over a network you trust, such as a VPN. - Video stays in RustDesk's own format and your browser decodes it, so it needs a recent Chrome, Edge, Firefox or Safari. VP9, AV1 and VP8 are used, never H.264 or H.265. - Clipboard text works both ways, and you hear the remote's audio. With more than one monitor, the toolbar has a button for each. - Not supported yet: file transfer and recording. diff --git a/locales/en.json b/locales/en.json index 23ed82f..d0b46b2 100644 --- a/locales/en.json +++ b/locales/en.json @@ -303,6 +303,8 @@ "rustdesk": { "direct": "Direct IP access", "directDesc": "Connect to the host address instead of looking up a RustDesk ID. Direct IP access must be on in RustDesk on that device.", + "allowPlain": "Allow unencrypted sessions", + "allowPlainDesc": "Older RustDesk versions answer direct IP access without encryption. Only turn this on over a network you trust, such as a VPN.", "port": "Direct IP port", "directNote": "The connection is encrypted, but with no ID server there is nothing to prove which device answered.", "id": "RustDesk ID", @@ -562,6 +564,9 @@ "rustdeskDirect": { "label": "RustDesk direct IP access" }, + "rustdeskAllowPlain": { + "label": "RustDesk unencrypted direct IP sessions" + }, "rustdeskIdServer": { "label": "RustDesk ID server" }, diff --git a/src/backend/engine/worker/rustdesk/client.ts b/src/backend/engine/worker/rustdesk/client.ts index 19f2380..be1c419 100644 --- a/src/backend/engine/worker/rustdesk/client.ts +++ b/src/backend/engine/worker/rustdesk/client.ts @@ -172,8 +172,16 @@ export class RustDeskClient implements RemoteClient { route.conn.close(); return; } - await secure(route.conn, peerId, route, { key, direct, idServer }); - this.host.log("debug", "RustDesk session secured", { direct }); + const { plain } = await secure(route.conn, peerId, route, { + key, + direct, + idServer, + allowPlain: s.bool("allow-plain"), + }); + this.host.log("debug", "RustDesk session secured", { + direct, + encrypted: !plain, + }); this.loginTimer = setTimeout(() => { if (this.loggedIn || this.stopped) return; this.abort( @@ -200,6 +208,8 @@ export class RustDeskClient implements RemoteClient { }); } }); + // An unencrypted peer already sent its password challenge. + if (plain) this.receive(plain, peerId); } /** Ends the session with an error, once. */ diff --git a/src/backend/engine/worker/rustdesk/handshake.ts b/src/backend/engine/worker/rustdesk/handshake.ts index 9b1084e..533852c 100644 --- a/src/backend/engine/worker/rustdesk/handshake.ts +++ b/src/backend/engine/worker/rustdesk/handshake.ts @@ -285,9 +285,15 @@ export async function secure( conn: Connection, peerId: string, route: Route, - options: { key: string; direct: boolean; idServer: string }, + options: { + key: string; + direct: boolean; + idServer: string; + /** Carry on when a direct peer skips the key exchange. */ + allowPlain?: boolean; + }, timeoutMs = 10_000, -): Promise<{ verified: boolean }> { +): Promise<{ verified: boolean; plain?: Uint8Array }> { let peerSignPk: Uint8Array | null = null; if (!options.direct) { const rsKey = serverKey( @@ -311,9 +317,19 @@ export async function secure( peerSignPk = idPk.pk; } - const first = PbMessage.decode(await conn.next(timeoutMs)); + const frame = await conn.next(timeoutMs); + const first = PbMessage.decode(frame); const signedId = first.message(MSG.signedId); if (!signedId) { + // Older RustDesk answers direct IP access with the password challenge + // straight away and never encrypts the session. + if (options.direct && first.has(MSG.hash)) { + if (options.allowPlain) return { verified: false, plain: frame }; + throw new RustDeskError( + "The remote device answered without encryption. Allow unencrypted sessions on this host to connect anyway", + UPSTREAM_ERROR, + ); + } throw new RustDeskError( "The remote device did not start a secure session", UPSTREAM_ERROR, diff --git a/src/backend/host-settings.ts b/src/backend/host-settings.ts index c81c3c5..37e7b6d 100644 --- a/src/backend/host-settings.ts +++ b/src/backend/host-settings.ts @@ -21,6 +21,7 @@ export interface RemoteDesktopHostSettings { rustdeskRelayServer: string; rustdeskKey: string; rustdeskDirect: boolean; + rustdeskAllowPlain: boolean; moonlightPort: number; moonlightHostId: number; moonlightAppId: number; @@ -140,6 +141,7 @@ export async function readHostSettings( rustdeskRelayServer: asText(values.rustdeskRelayServer), rustdeskKey: asText(values.rustdeskKey), rustdeskDirect: values.rustdeskDirect === true, + rustdeskAllowPlain: values.rustdeskAllowPlain === true, moonlightPort: asPort(values.moonlightPort) ?? MOONLIGHT_DEFAULT_PORT, moonlightHostId: asCount(values.moonlightHostId), moonlightAppId: asCount(values.moonlightAppId), @@ -218,6 +220,8 @@ export function normalizeImportedHost( } const direct = asBool(pick("rustdeskDirect")); if (direct !== undefined) out.rustdeskDirect = direct; + const allowPlain = asBool(pick("rustdeskAllowPlain")); + if (allowPlain !== undefined) out.rustdeskAllowPlain = allowPlain; const moonlight = asBool(pick("enableMoonlight")); if (moonlight !== undefined) out.enableMoonlight = moonlight; const moonlightPort = asPort(pick("moonlightPort")); diff --git a/src/backend/routes.ts b/src/backend/routes.ts index 56ca9f4..60ccedd 100644 --- a/src/backend/routes.ts +++ b/src/backend/routes.ts @@ -96,6 +96,7 @@ export async function rustdeskSettings( password: input.password, "rustdesk-id": settings.rustdeskId, direct: settings.rustdeskDirect, + "allow-plain": settings.rustdeskDirect && settings.rustdeskAllowPlain, "id-server": ownServer ? settings.rustdeskIdServer : await admin("rustdeskIdServer"), diff --git a/src/frontend/HostEditorRustdeskTab.tsx b/src/frontend/HostEditorRustdeskTab.tsx index 694933d..e51059f 100644 --- a/src/frontend/HostEditorRustdeskTab.tsx +++ b/src/frontend/HostEditorRustdeskTab.tsx @@ -66,6 +66,17 @@ export function HostEditorRustdeskTab({ onChange={(v) => setField("rustdeskDirect", v)} /> + {form.rustdeskDirect && ( + + setField("rustdeskAllowPlain", v)} + /> + + )} {form.rustdeskDirect ? (
diff --git a/src/frontend/host-remote.ts b/src/frontend/host-remote.ts index d202c70..54db452 100644 --- a/src/frontend/host-remote.ts +++ b/src/frontend/host-remote.ts @@ -27,6 +27,7 @@ export interface RemoteHostOptions { rustdeskPort: number; rustdeskId: string; rustdeskDirect: boolean; + rustdeskAllowPlain: boolean; rustdeskIdServer: string; rustdeskRelayServer: string; rustdeskKey: string; @@ -146,6 +147,7 @@ export function remoteOptions( rustdeskPort: port(values.rustdeskPort, DEFAULT_PORT.rustdesk), rustdeskId: text(values.rustdeskId), rustdeskDirect: values.rustdeskDirect === true, + rustdeskAllowPlain: values.rustdeskAllowPlain === true, rustdeskIdServer: text(values.rustdeskIdServer), rustdeskRelayServer: text(values.rustdeskRelayServer), rustdeskKey: text(values.rustdeskKey), diff --git a/src/frontend/remote-form.ts b/src/frontend/remote-form.ts index 244d02b..bbf5129 100644 --- a/src/frontend/remote-form.ts +++ b/src/frontend/remote-form.ts @@ -31,6 +31,7 @@ export interface RemoteDesktopForm { rustdeskPort: number; rustdeskId: string; rustdeskDirect: boolean; + rustdeskAllowPlain: boolean; rustdeskIdServer: string; rustdeskRelayServer: string; rustdeskKey: string; @@ -81,6 +82,7 @@ const SETTING_FOR_FIELD: Partial> = { rustdeskPort: "rustdeskPort", rustdeskId: "rustdeskId", rustdeskDirect: "rustdeskDirect", + rustdeskAllowPlain: "rustdeskAllowPlain", rustdeskIdServer: "rustdeskIdServer", rustdeskRelayServer: "rustdeskRelayServer", rustdeskKey: "rustdeskKey", @@ -195,6 +197,7 @@ export function remoteDesktopForm(props: HostEditorSectionProps): { rustdeskPort: options.rustdeskPort, rustdeskId: options.rustdeskId, rustdeskDirect: options.rustdeskDirect, + rustdeskAllowPlain: options.rustdeskAllowPlain, rustdeskIdServer: options.rustdeskIdServer, rustdeskRelayServer: options.rustdeskRelayServer, rustdeskKey: options.rustdeskKey, diff --git a/tests/backend/engine/worker/rustdesk/client.test.ts b/tests/backend/engine/worker/rustdesk/client.test.ts index 9279c38..d9c68f4 100644 --- a/tests/backend/engine/worker/rustdesk/client.test.ts +++ b/tests/backend/engine/worker/rustdesk/client.test.ts @@ -215,6 +215,34 @@ async function rustdeskWorld(options: PeerOptions) { }; } +/** + * A device on loopback that answers direct IP access the way older RustDesk + * does: no key exchange, the password challenge comes first. + */ +async function plainPeer(login: PeerOptions["login"]) { + const peerMessages: PbMessage[] = []; + const port = await listen((conn) => { + conn.send( + msg(MSG.hash, new PbWriter().string(1, "salt").string(2, "chal")), + ); + conn.onFrame((frame) => { + const m = PbMessage.decode(frame); + peerMessages.push(m); + const lr = m.message(MSG.loginRequest); + if (lr) login(lr, conn); + }); + }); + return { + peerMessages, + settings: { + direct: "true", + hostname: "127.0.0.1", + port: String(port), + password: PASSWORD, + } as Record, + }; +} + const peerInfo = () => new PbWriter().message( 2, @@ -238,7 +266,7 @@ function acceptLogin(lr: PbMessage, peer: Connection) { ); } -function start(world: Awaited>, extra = {}) { +function start(world: { settings: Record }, extra = {}) { const fake = fakeHost({ ...world.settings, ...extra }); const client = new RustDeskClient(fake.host); clients.push(client); @@ -410,6 +438,33 @@ describe("RustDeskClient", () => { expect(events.failed!.message).toBe("The remote device is offline"); }); + it("logs in to a direct peer without encryption when the host allows it", async () => { + const world = await plainPeer((lr, peer) => { + const ok = Buffer.from(lr.bytes(2)).equals( + Buffer.from(passwordHash(PASSWORD, "salt", "chal")), + ); + peer.send( + msg( + MSG.loginResponse, + ok ? peerInfo() : new PbWriter().string(1, "Wrong Password"), + ), + ); + }); + const { events } = start(world, { "allow-plain": "true" }); + await until(() => events.ready || !!events.failed); + expect(events.failed).toBeNull(); + expect(events.ready).toBe(true); + }); + + it("refuses a direct peer without encryption unless the host allows it", async () => { + const world = await plainPeer(() => {}); + const { events } = start(world); + await until(() => !!events.failed); + expect(events.failed!.message).toMatch(/without encryption/); + expect(events.ready).toBe(false); + expect(world.peerMessages).toEqual([]); + }); + it("needs an ID unless direct", async () => { const { events } = start({ settings: {} } as never, {}); await until(() => !!events.failed); diff --git a/tests/backend/rustdesk.test.ts b/tests/backend/rustdesk.test.ts index 9c7400f..913eeec 100644 --- a/tests/backend/rustdesk.test.ts +++ b/tests/backend/rustdesk.test.ts @@ -39,6 +39,25 @@ describe("RustDesk hosts", () => { expect(settings.rustdeskId).toBe("123 456 789"); expect(settings.rustdeskPort).toBe(21118); expect(settings.rustdeskIdServer).toBe(""); + expect(settings.rustdeskAllowPlain).toBe(false); + }); + + it("reads the switch for unencrypted direct sessions", async () => { + const settings = await readHostSettings( + ctxWith({}, { rustdeskDirect: true, rustdeskAllowPlain: true }), + 1, + ); + expect(settings.rustdeskAllowPlain).toBe(true); + }); + + it("imports the switch for unencrypted direct sessions", () => { + expect( + normalizeImportedHost({ + pluginSettings: { + "remote-desktop": { rustdeskDirect: true, rustdeskAllowPlain: true }, + }, + }), + ).toEqual({ rustdeskDirect: true, rustdeskAllowPlain: true }); }); it("imports its settings", () => { @@ -125,6 +144,21 @@ describe("rustdeskSettings", () => { expect(out["relay-server"]).toBe(""); }); + it("allows an unencrypted session only for direct IP", async () => { + const direct = await rustdeskSettings( + ctxWith({}), + { ...base, rustdeskDirect: true, rustdeskAllowPlain: true } as never, + input, + ); + expect(direct["allow-plain"]).toBe(true); + const byId = await rustdeskSettings( + ctxWith({}), + { ...base, rustdeskAllowPlain: true } as never, + input, + ); + expect(byId["allow-plain"]).toBe(false); + }); + it("drops codec lists it does not trust", async () => { const out = await rustdeskSettings(ctxWith({}), base as never, { ...input, diff --git a/tests/frontend/HostEditorRustdeskTab.test.tsx b/tests/frontend/HostEditorRustdeskTab.test.tsx index 18a845e..cfdbba2 100644 --- a/tests/frontend/HostEditorRustdeskTab.test.tsx +++ b/tests/frontend/HostEditorRustdeskTab.test.tsx @@ -66,4 +66,14 @@ describe("RustDesk host editor", () => { expect(screen.queryByText("RustDesk ID")).toBeNull(); expect(screen.queryByText("ID server")).toBeNull(); }); + + it("offers unencrypted sessions only for direct IP", async () => { + await renderSection({ enableRustdesk: true, rustdeskDirect: true }); + expect(await screen.findByText("Allow unencrypted sessions")).toBeTruthy(); + cleanup(); + await rendered?.deactivate(); + await renderSection({ enableRustdesk: true, rustdeskId: "123456789" }); + expect(await screen.findByText("RustDesk ID")).toBeTruthy(); + expect(screen.queryByText("Allow unencrypted sessions")).toBeNull(); + }); });