← All posts

All About the PON: True Zero Trust Inside MSP Pulse

"Zero trust" has become one of the most misused phrases in security marketing. Plenty of products that call themselves zero trust are, underneath, a VPN with a new name: still a single tunnel into a network that, once you're in, mostly trusts you. MSP Pulse's Secure Access, internally called PON and built on the OpenZiti overlay, is different in a specific, checkable way: when a tenant turns it on, their data stops having a public address at all. There's nothing to race, nothing to bypass, nothing to misconfigure your way around, because the thing an attacker would normally attack isn't there.

This post explains how that actually works (the mechanism, not the marketing), including where it's genuinely strong and where, honestly, it isn't the whole story.

What zero trust actually means

The definition comes from NIST Special Publication 800-207, the reference document most serious zero-trust implementations are measured against. Its core idea, in plain terms: no user, device or connection is trusted because of where it's sitting on the network. Being "inside" the office, the VPN, or the firewall earns nothing by itself. Every request is authenticated and authorised on its own merits, every time, as if the network itself were already assumed to be hostile.

That's a real shift from how most business software is still secured. A traditional VPN draws a hard line at the edge of the network: get past that line, by whatever means, and you're generally trusted to roam inside it. That's exactly the model a stolen credential, a phished session, or a misconfigured firewall rule defeats, because the hard part (getting past the edge) is also the only part that's actually checked.

A lot of products marketed as "zero trust" are a VPN with a new label: still one tunnel, still one perimeter, just drawn with more modern branding. PON takes a more literal reading of the NIST definition: if network location shouldn't grant trust, the cleanest way to enforce that isn't to check harder at the edge, it's to remove the edge a public attacker can reach at all.

The mechanism: a hostname that isn't there

Once Secure Access is switched on, a tenant's application is carried on a dedicated hostname under pon.msp-pulse.com. The detail that makes it structurally different from an ordinary access-controlled endpoint: that hostname has no public A, AAAA or HTTPS DNS record at all. There's nothing published for the public internet to find, nothing to port-scan, nothing to send a crafted request to. You can't misconfigure your way around a bypass that has no address to begin with. The usual DNS-leak or origin-discovery attack class doesn't just get harder, it has no target.

An enrolled device reaches that hostname differently. It runs a small OpenZiti tunneler that intercepts requests for the hostname locally, before public DNS ever gets involved, and routes them through the encrypted overlay to a loopback-only web server sitting behind it. That server is reachable only from loopback, never from the public network, and stamps every request it forwards with a trusted marker. The application's gate checks for exactly that marker: present, the request proceeds; absent, a Secure Access tenant gets a flat 403.

The anti-spoof step matters as much as the gate itself: the public-facing server explicitly strips that same marker from anything it receives, so even a request that somehow reached the public origin directly can't forge its way past the check by setting it itself. Only a request that genuinely passed through the overlay's own loopback path ever carries a valid one.

Enrol-then-darken: impossible to lock yourself out

A tenant making their own data network-dark raises an obvious worry: what if a mistake in that process locks the owner out of their own tenant? PON is built so that failure mode can't happen, through a deliberately simple design: two separate flags, read on every request, with no restart required for either to take effect.

Enabled is a platform-level switch. Turning it on makes Secure Access available to a tenant: the agent download appears, devices can enrol. It darkens nothing by itself.

Enforced is the tenant's own self-service switch, and it's the actual data gate. Only once this is on does the dark hostname start rejecting requests that don't arrive over the overlay.

The sequencing is the safeguard: the endpoint that flips the second flag only accepts a request that itself arrived over the overlay. A tenant can only darken their data from a position where they've already proven they're inside it. Enrol a device first, confirm it works, and only then can enforcement be switched on. There's no order of operations that strands an admin outside their own locked door, because the lock can't be turned from outside.

And if something still goes wrong, such as a bad enrolment or a tenant that needs emergency access restored, a break-glass path exists that instantly restores the public path, because switching off the first flag doesn't just stop new enrolments, it undoes the darkening itself. A platform-wide kill switch exists too, for the scenario where the overlay infrastructure itself needs to be bypassed across every tenant at once.

The network gate is one layer, not the only one

This is the part a lot of "zero trust" products quietly skip: reaching the network is treated as the whole problem, and once you're in, you're in. PON deliberately isn't a replacement for identity and access controls. It's stacked on top of them, as one additional layer that has to be passed before the ones MSP Pulse already had.

Reaching the overlay doesn't log anyone in. A user with an active enrolled device still has to authenticate (password, then TOTP, then a valid tenant-scoped session) exactly as they would on the public path, except the login request itself now has to travel over the overlay too. Suspend a user's last enrolled device, and they don't get stuck; they simply drop back to the standard public bootstrap path, which is also the account-recovery route.

The platform's own superadmin control panel follows the identical pattern one level up: it has no public DNS record at all and is reachable only over its own overlay, so the people with the deepest access to every tenant are gated by the same network-invisibility principle as the tenants they administer, not treated as a trusted exception to it.

The vault is a useful contrast for why layering matters. Credential reveals in the vault are deliberately not TOTP-gated: a live session is enough, so an engineer on the phone to a panicking client doesn't have to stop and re-authenticate mid-call to read a password. Instead, every reveal writes an access-log row: who, which credential, view or copy, when. That's accountability instead of friction, a conscious trade-off for that specific action. A tenant who wants a harder boundary around it gets one the moment they enforce Secure Access, because an engineer has to have cleared the network layer before any of the vault's own session-level rules are even reached.

Being honest about the edges

A security feature that oversells itself is worse than one that's modest and accurate, so it's worth being precise about what PON actually gates.

It's a network-path gate, not an endpoint gate. The overlay confirms a request arrived via a specific, enrolled tunnel. It doesn't independently verify every device sharing that tunnel's path. A user-mode-NAT'd virtual machine running on an enrolled host inherits that host's access, because it borrows the host's resolver and tunnel rather than needing its own enrolment. That's a real caveat, not a hidden one.

It's also a low-severity one in practice: exploiting it means already controlling the enrolled host, and the password, TOTP and tenant-session checks still apply after the network gate regardless. So the claim isn't "every machine that can touch the data runs the agent". It's "every machine that can touch the data has to come through an enrolled host's tunnel, then still pass everything else." Testing confirmed the gap is real for a NAT'd VM and does not extend to a tethered phone, which was tested separately and doesn't inherit access the same way. Enrolment testing is done on a bridged VM precisely to avoid masking this distinction.

Nothing here replaces authentication, authorisation, or auditing; it stands in front of them. PON answers "can this request reach the application at all," not "should this specific user be allowed to do this specific thing." Those remain separate, necessary layers, covered above.

The structural guarantee is about network reachability, not about every component behind it being equally hardened. RustDesk, MSP Pulse's remote-access tool, runs over PON precisely because exposing it to the public internet directly would be a much larger risk than exposing it only to enrolled devices. But that's PON doing its job of narrowing the attack surface, not a claim that everything running behind the overlay is independently bulletproof.

That combination (a public attack surface that's genuinely, structurally not there, conventional identity controls still fully intact behind it, and the one real caveat stated plainly rather than buried) is what "true" zero trust is meant to signal in the first place: not a product claim, but an architecture you can actually go and check.