All About RustDesk: Remote Access Inside MSP Pulse
Remote access is the module where an MSP's risk is most concentrated. It's the one piece of software that routinely gets a direct, interactive session onto a client's machine (screen, keyboard, clipboard, files), which makes it both indispensable and, if it's ever compromised or misconfigured, the component with the widest possible blast radius. We've treated it that way from the start: our own threat register rates the engineer-machine-to-client pivot through remote access as Critical.
RustDesk is the engine underneath MSP Pulse's remote access. What follows is how it works, what we built around it to make it fit a multi-tenant platform properly, how it's secured, and, just as important, which parts are live for everyone and which are still being rolled out and proven.
What RustDesk actually is
RustDesk is an open-source remote-desktop project, one of the most popular on GitHub, and its engine is AGPL-3.0 licensed, free to self-host. Two small server programs do the real work:
hbbs, the ID and rendezvous server. Every RustDesk client checks in with it continuously so the server knows a device's current address, and it brokers the handshake when one device wants to reach another.hbbr, the relay server. RustDesk first tries to connect two devices directly, using NAT hole-punching so the session data never has to touch a server at all. When that fails (common behind strict corporate firewalls, exactly the kind of network an MSP's clients often sit behind) the session falls back to relaying throughhbbr.
Sessions are encrypted between the two devices and authenticated against a keypair generated per server. Native clients exist for Windows, macOS and Linux. That combination of open, self-hostable and production-grade is why RustDesk was the right foundation to build on rather than inventing a remote-desktop protocol from scratch.
RustDesk also sells a commercial "Pro" server, which adds a web console, a browser client, single sign-on into the client and an access-control layer. We ran on it for a time. When that licence lapsed we moved to the free community server, and the platform has kept working because the things we depend on (tenant isolation, sign-in, password handling, auditing) are built by us, around the engine, rather than bought in as part of it.
A relay per tenant, not a shared one
The obvious way to run RustDesk under a multi-tenant platform is one shared hbbs/hbbr pair serving every customer. We ran that way, and it's worth being honest about the gap it leaves: the relay has no concept of a tenant at all. It's keyed on connection ID, nothing more. If a scoping bug, a stale ID or a misissued token ever handed the wrong ID or password to the wrong engineer, there would be nothing else in the way, because every tenant's sessions would be flowing through the same relay process.
For most of the platform there's a strong backstop already: every table carries a tenant identifier, and every client-supplied reference is validated against the caller's tenant before it's written. A shared relay has no equivalent. So we built something stronger: each tenant gets its own dedicated hbbs/hbbr pair, with its own never-shared keypair, reachable only through that tenant's own Secure Access service. It's the same no-public-DNS pattern used for the application itself, so the relay doesn't have a public address to find. A registry in the platform tracks each tenant's instance and its health, and a background process creates it, pauses it when a tenant is suspended, repairs it if it drifts, and removes it after a grace period when remote access is switched off.
The practical effect: there's no shared component for a misconfiguration to leak across. Tenant A's relay and tenant B's relay are separate processes, on separate network paths, with separate keys.
Where this stands today: it's live and proven end to end for our pilot tenants, and we're moving the remaining tenants across in stages. Until a tenant is moved, it still uses the shared relay. Moving a customer means re-running the remote-support installer on their devices, because the installer is what points a device at its new server and key.
Getting in without typing a password
Network isolation answers which relay a session can reach. It doesn't answer how an engineer gets into a session without passwords being copied around by hand, where they're easy to mistype, paste into the wrong window, or leave in a clipboard history.
Every device that supports remote access has its device password stored in the Password Vault, linked to that device's record. The installer sets that password on the device and stores it for you; nobody picks it or types it.
In the browser, the engineer clicks Connect. The platform issues a short-lived, single-use connect ticket, which opens the session page on that tenant's own Secure Access address. The ticket is redeemed once, the device password is passed straight into the session, and the engineer never sees or copies it. Every one of those password reveals writes a vault access-log row, so there is a record of who connected, independent of anything RustDesk itself logs.
With the native RustDesk app, Connect shows the engineer the server, key and device ID to enter into their own client. The browser path is the one with the password handled for you.
A browser client of our own
Connecting from a tab with nothing installed is the most convenient way to reach a device, and RustDesk's own browser client is a commercial feature. We looked at licensing it, and we looked at adopting an open-source one. Neither fitted: a per-tenant commercial licence stops making sense at scale, and the open-source option was under a licence that would have forced us to publish our integration.
So we wrote our own. The browser client is a separate, proprietary component whose engine was written clean-room (the author worked from a written description of the protocol and never saw RustDesk's source), with the whole process recorded. It's served to each tenant from that tenant's own Secure Access address, talks to the tenant's own relay, and supports file transfer as well as the screen.
Where this stands today: it's deployed and working against our pilot tenant, including real sessions. What it hasn't had yet is a full acceptance pass against a wide range of real customer devices, so we're treating it as proven in the pilot, not proven everywhere. A solicitor's review of the clean-room provenance is also still to come, and we'd rather say that than skip it.
What's secured, and what's logged
No cross-tenant bridge, not even for us. It would be technically possible to build a support path that lets platform staff reach into any tenant's remote sessions. We deliberately didn't. When a platform administrator signs in as a tenant user for support, the vault is hidden from them and remote Connect is blocked, even if the tenant asks. The platform's own administration surface is reachable only over its own Secure Access path, gated the same way a tenant is.
Every connection is recorded. Alongside the vault's access log, the platform records remote activity: who connected, to which device, on which tenant's relay, and when it started and ended. It also records connects that were refused, such as during a support session, and attempts that presented the wrong server key. A session is written when it ends, and a session that can't be tied to a person's Connect click is flagged for review rather than quietly dropped.
Accountability, not friction. The vault doesn't put an extra prompt in front of a password reveal, on the reasoning that an engineer in the middle of an incident shouldn't have to stop and re-authenticate to read a password. The protection comes from the log and from Secure Access, not from a second prompt.
Isolation doesn't depend on RustDesk's own access control. The commercial access-control feature is irrelevant to this design. Tenant separation is structural: which network path and which dedicated relay a session can even reach, before any RustDesk-level check would apply.
What's live and what's still being proven
- Live and proven: per-tenant relays for the pilot tenants, vault-backed device passwords, attended and unattended installers for Windows and Linux (macOS is attended-only and still being finished), audited sessions, and native-client connections.
- Live in the pilot, not yet proven widely: the browser client, including file transfer.
- In progress: moving the remaining tenants from the shared relay to their own.
Everything above holds regardless of which of those lands first, because the parts that protect a customer (a dedicated relay, no public address, a recorded session, no staff shortcut) don't depend on the browser client at all.