From RMM Agent to Remote Shell: Tracing the N-central Zero-Day Chains

From RMM Agent to Remote Shell: Tracing the N-central Zero-Day Chains

pr0h0••23 min read•hacking
AI Usage (92%)

N-able pulled N-central offline on 2026-11-14, according to BankInfoSecurity's reporting, after researchers published details on 33 zero-days. A day later, a Meteora Web piece named two of the exploit chains: Agent2Shell and 4EverAble2Shell. That is roughly the sum of what is publicly verifiable at the time of writing, so this post traces what those RMM-agent-to-remote-shell chains plausibly do, separates confirmed reporting from inference, and lays out the lab tests and detection signals an MSP can deploy now.

The count is the least interesting number in this story.

My position up front: the severity here does not live in "33." It lives in what an RMM agent actually is — a privileged service whose day job is running code on thousands of hosts — and in how MSP deployments work, where one console session fans out across customers who have never heard of your RMM vendor. Whether or not every one of those 33 bugs is real, the architecture they live in is the story.

On this page

N-central Went Offline Because of 33 Zero-Days, Not One

What the N-central zero-day disclosures actually state

Stripping out the adjectives, the reporting establishes a short list:

  • N-central is N-able's RMM platform, used by MSPs to monitor and manage customer endpoints.
  • On 2026-11-14, N-able took the platform offline, per BankInfoSecurity.
  • The trigger, per that reporting, was the release of details on 33 zero-days.
  • On 2026-11-15, Meteora Web's headline named two exploit chains: Agent2Shell and 4EverAble2Shell, describing them as "two new zero-day exploit chains."

What is conspicuously absent matters just as much:

  • No CVE identifiers in the material I have.
  • No affected version range.
  • No statement about whether authentication is required, or what privilege level an attacker needs.
  • No confirmation of in-the-wild exploitation.
  • No explanation of why the outage was chosen over targeted mitigation — whether the platform itself showed evidence of compromise, or the vendor simply could not enumerate a safe configuration.

The Meteora Web headline also references "ACN," which the snippet never defines. I am not going to guess what that acronym stands for or what role it played. If a reader knows, that detail is worth chasing down before drawing conclusions about coordinated disclosure.

⚠️

Do not run speculative exploit attempts against an N-central server or agent — yours or a client's — to "see if it works." Without a vendor advisory, you cannot know whether a probe is harmless, and you may be creating the incident you were hired to prevent.

Why shutting down an RMM platform is itself a supply-chain event

Taking an RMM offline is not a neutral safety action. It is a trade: the vendor removes a possible attack path and, in the same motion, removes the customer's ability to see and act.

For an MSP, the management plane is not one tool among many. It is the channel through which patch compliance is enforced, alerts reach the technician, backup failures get flagged, and remediation scripts run. When it goes dark:

  1. Detection degrades. Endpoint agents still check in to something, but the console that would show you anomalies is gone.
  2. Response degrades. Your fastest remediation path — push a script, restart a service, isolate a host via the agent — is exactly the path that is offline.
  3. Audit evidence becomes scarce. Console audit logs are often only complete inside the platform. If you were not exporting them continuously, the freeze may mean you cannot reconstruct what happened in the 24 hours before it.
  4. Downstream customers are blind. They do not run N-central. They run whatever they were told to run, and they will learn about this from the news.

The mitigation is unglamorous, and you can start today: keep a read-only mirror of console audit events, agent inventory, and per-client credential references somewhere outside the RMM — a log pipeline, a data warehouse, a nightly CSV drop. The outage taught me more about log egress than about exploitation.

An RMM Agent Is Already a Remote Shell — That Is the Product

What an RMM agent service can do by design

The uncomfortable part: if you wrote a list of capabilities an attacker wants after landing on a host, it would look almost exactly like an RMM agent feature brochure.

Agent capabilityLegitimate useAttacker value
Run scripts as SYSTEM / rootautomation, patchingprivileged execution with a support-ticket-shaped audit trail
Push and execute binariessoftware deploymenttooling delivery that looks like a deploy
Start / stop / reconfigure servicesagent maintenance, app restartsdisabling endpoint protection
Registry and config writespolicy enforcementpersistence
Remote control sessionshelpdesk supportinteractive access, screen capture, input
Credential reference / "run as" storetasks that need domain auththe actual prize

That last row is where RMM breaches become domain breaches. A console that can execute a task as a stored domain administrator is a console that holds domain administrator credentials, whether or not anyone calls it a vault.

Why outbound-only agent check-in is not a trust boundary

I keep hearing "the agent only makes outbound connections, so there's nothing to scan." That is true and irrelevant. Outbound-only describes network direction. It says nothing about authority.

The agent dials out, authenticates, and then asks: what should I do? Whatever answers that question is trusted by the agent, because the protocol has no other option — the whole design assumes the server is honest. So the questions that matter are:

  • What does the agent accept from the server, and does it validate the shape of that input?
  • How does the agent prove it is your agent, and can that proof be replayed or transplanted to another host?
  • Where does the installer key or registration token live on disk, and can a local unprivileged user read it?

The second point is the one I would test first in a lab. RMM agents need an enrollment credential. Enrollment credentials that are static per tenant, stored on every endpoint, and long-lived are functionally a shared password for the management plane. That is not a zero-day; it is a design decision that turns one compromised laptop into an inventory-wide problem.

Blast radius math: one RMM console across many MSP tenants

This is why these chains get named:

Deployment shapeHosts under one consoleNotes
Single SMB IT dept200–2,000one tenant, one boundary
Small MSP20 clients × 80 endpoints = 1,60020 credential sets, one console login
Mid MSP60 clients × 150 endpoints = 9,00060 customer trust boundaries behind one session cookie
Large MSP / aggregator150 clients × 400 endpoints = 60,000plus subcontractors with console access

A normal web app vulnerability gives the attacker one tenant. An RMM vulnerability gives the attacker every tenant the console can reach — and then, via stored credentials, potentially every domain those tenants connect to.

Confirmed Facts Versus the Exploit-Chain Narrative

Claims table: source and verification status

ClaimSourceStatus
N-able took N-central offlineBankInfoSecurity headline, 2026-11-14Reported by press; I have not read a vendor advisory confirming the sequence
33 zero-days disclosedsameReported; individual bugs not enumerated in the material I have
Two chains named Agent2Shell and 4EverAble2ShellMeteora Web, 2026-11-15Reported
Both are "zero-day exploit chains"Meteora WebAs characterized by the publication
Affected versions, CVE IDs, auth requirements—Unknown
Exploitation in the wild—Unknown / unconfirmed
Agent2Shell moves agent → interactive shellInferred from the nameInference, not evidence
4EverAble2Shell restores revoked accessInferred from the nameInference, not evidence

Everything from row seven down is me reading a name and reasoning about how RMM platforms work. Treat it as a hypothesis to test, not a finding.

What is still unknown about Agent2Shell and 4EverAble2Shell

Five unknowns would change my advice completely:

  1. Pre-auth or post-auth? A pre-auth agent-facing bug means internet-exposed N-central servers were attackable by anyone. A post-auth bug means the attacker needed a console session first — bad, but a very different detection story.
  2. Agent-side or server-side execution? "Shell" could mean a shell on the agent host, a shell on the N-central server, or a shell delivered through the agent to a managed endpoint. Each implies a different containment.
  3. Does it survive agent removal? This is the whole question for 4EverAble2Shell. If removing an agent does not remove the attacker's access, every "we cleaned it up" statement in the industry is wrong.
  4. Is the outage precautionary or reactive? A precautionary outage is a vendor choosing caution. A reactive outage means the platform was, or was believed to be, compromised. Those are different incidents.
  5. Were the 33 reported to the vendor first? Coordinated disclosure versus a mass drop changes whether defenders get patch windows or fire drills.

Agent2Shell: A Plausible Trace From Compromised Agent to Interactive Shell

The name says agent to shell. What follows is the most likely trace based on how RMM products are built. This is a hypothesis. I have not seen the technical details, and I have not tested it.

Step 1: reach the agent-facing attack surface

Every RMM deployment has surfaces that face the agent rather than the human:

  • the check-in / task-fetch endpoint the agent polls,
  • the agent installer and upgrade download path,
  • a registration or re-enrollment endpoint,
  • in some builds, a local listener on the managed host for on-host tooling.

You can enumerate the local side on any authorized lab host without touching exploit code:

Get-NetTCPConnection -State Established |
  Where-Object { $_.OwningProcess -ne 0 } |
  Select-Object RemoteAddress, RemotePort, OwningProcess,
    @{n='Proc';e={ (Get-Process -Id $_.OwningProcess).ProcessName }}

Representative shape of what an RMM agent produces (illustrative — run it on your own host for real data):

RemoteAddress  RemotePort OwningProcess Proc
-------------  ---------- ------------- ----
203.0.113.24          443          4180 ncagent
203.0.113.24          443          4180 ncagent

If all you ever see is one or two long-lived TLS connections to a single vendor FQDN, you have a clean baseline. Anything else — a second destination, a different port, a burst of new connections after an upgrade — is worth a ticket.

Step 2: cross the agent-to-server trust boundary

Two directions exist, and both matter:

  • Server → agent: the agent accepts instructions, scripts, and packages. If the server can be made to serve attacker-chosen content, the agent executes it. That could be a server-side authz flaw, a task-injection bug in the console, or an API that lets a low-privilege console user queue work against a host they should not reach.
  • Agent → server: the server accepts inventory, status, and results from the agent. If a forged agent can register, or an existing agent's identity can be transplanted, the attacker gets a foothold inside the management plane — which is where the credentials live.

The second direction is what I would bet on for a chain named "Agent2Shell." A shell obtained on the managed endpoint is table stakes; a session obtained on the server is where the fan-out happens.

Step 3: command execution in the agent's security context

Whatever the injection point, the payload runs as the agent service's identity. On Windows that is commonly LocalSystem; on macOS and Linux, root via a LaunchDaemon or systemd unit. Confirm it on a lab host:

Get-CimInstance Win32_Service -Filter "Name='<agent-service-name>'" |
  Select-Object Name, StartName, PathName, StartMode

Illustrative output format:

Name          : <agent-service-name>
StartName     : LocalSystem
PathName      : "C:\Program Files\<vendor>\agent\agent.exe" -service
StartMode     : Auto

StartName: LocalSystem plus StartMode: Auto is the whole foothold in two lines. There is no privilege escalation step in this chain because the agent arrives pre-escalated. That is the design.

Step 4: convert code execution into a durable shell

Getting one command to run is not a shell. The difference is durability, and RMM platforms are unusually good at durability:

  • Scheduled tasks created by the agent look like agent-created tasks. Baseline them or you will never notice.
  • Service creation or reconfiguration in the agent's own program directory blends into maintenance.
  • RMM-native persistence is the nasty one: a policy, automation, or scheduled script defined in the console will be re-pushed to the host on every check-in. Removing the artifact on the host changes nothing. This is also the mechanism that makes 4EverAble2Shell plausible.

If I had to name the single most under-defended property of RMM architecture, it is that the deployment channel is, by construction, an allowlisted, authenticated, recurring code-delivery path. Any attacker who reaches the console does not need a C2 channel. They have yours.

What evidence would confirm this trace

Before repeating any of the above as fact, I would want one of these:

  1. An advisory from N-able enumerating affected components and required privilege.
  2. A patch diff or changelog entry showing a validation change in an agent-facing handler.
  3. A packet capture showing the agent accepting a task payload it should have rejected.
  4. Agent debug logs from an affected build showing the instruction that produced execution.
  5. Server-side audit entries for task creation that do not correspond to a human console action.

Absent those, the trace stays a hypothesis.

4EverAble2Shell: The Re-Enable Primitive Hypothesis

Why the name suggests persistence over re-entry

Read it literally: "forever able to shell." That sounds like a persistence property, not an initial access vector. Agent2Shell sounds like the way in; 4EverAble2Shell sounds like the reason cleaning up does not work.

If that reading is right — and this is inference from a product name, nothing more — then the chain is not about a bug in a service. It is about an object that can be resurrected: a disabled account, a revoked token, or a removed agent that comes back.

Disabled accounts, revoked tokens, and removed agents

The defensive playbook in every RMM incident is the same four moves. Each has an obvious way to be undone:

Containment actionWhat an attacker needs to undo it
Disable the compromised console accounta second account, a service account, or an SSO identity that maps back in
Revoke API tokensa token with a longer TTL that was never inventoried, or a refresh path
Remove the agent from the hostan install path that still exists, or a deployment policy that re-pushes it
Change the passworda session that is still valid, or a re-enrollment credential on disk

Every one of those undo mechanisms is a feature. RMM agents reinstall themselves after failed upgrades. Console accounts get re-enabled by support. API tokens outlive the person who created them because nobody sets a TTL.

Why 'we disabled the agent' is not containment

Because "disabled" is a state in the console, and the console is the thing whose integrity is in question.

The verification has to happen on the host, from a channel the attacker does not control:

## Does the service exist, and is anything restarting it?
Get-Service | Where-Object { $_.Name -like '*agent*' }
Get-ScheduledTask | Where-Object { $_.TaskPath -like '*<vendor>*' } |
  Select-Object TaskName, State

And on the network side, from a tap or span port rather than from the endpoint's own reporting:

sudo tcpdump -ni any -s 0 'host 203.0.113.24 and tcp port 443' -c 5

If a host you believe is decommissioned still completes a TLS handshake to the RMM server after you removed the agent, the removal did not happen, or something put it back. That is a finding, not a flake.

Management-Plane Weak Points These Zero-Day Chains Likely Lean On

Session and token lifetime in RMM consoles

Long-lived API tokens are the most common serious finding I see in management planes, and they are boring:

  • tokens created for a one-off integration in 2021 and never revoked,
  • tokens with no expiry because expiry breaks the integration,
  • tokens scoped to "all clients" because per-client scoping required extra work,
  • sessions that survive a password change.

A chain that reaches the console does not need to beat authentication if there is a token lying around that never expires.

Impersonation and 'take over' features

Support-oriented products ship support-oriented powers: log in as a user, start a remote-control session, take over a device. These are legitimate and necessary. They are also indistinguishable, in an audit log, from an attacker doing exactly the same thing — which is why the audit schema matters more than the feature list. If your console records "remote session started by technician X" but not "which customer, which host, from which source IP, under which role," you cannot investigate your own platform.

Authorization checks that live only in the UI

The test is old and still catches things. Create two console users in a lab: one with access to client A, one with access to client B. Log in as A's user, capture a request that works, then replay it with B's object ID using A's session cookie.

curl -s -o /dev/null -w '%{http_code}\n' \
  -H "Cookie: <client-A-session>" \
  "https://<lab-ncentral>/api/<client-B-object-path>"

Expected: 403. If you get 200, the tenant boundary is decorative. I have found more real cross-tenant bugs with that four-line check than with any fuzzer.

Building an Authorized Lab to Watch RMM Agent Behavior

Network capture of agent check-ins

Put the lab agent behind a tap you control, or use a mirrored port. Do not capture on a production endpoint unless you have written authorization and a place to store the data.

## Capture the full check-in exchange, with timestamps and TLS SNI
sudo tcpdump -ni eth0 -s 0 -w agent-checkin.pcap \
  'tcp port 443 and host 203.0.113.24'

## Quick look at what the agent is asking for
tshark -r agent-checkin.pcap -Y 'tls.handshake.extensions_server_name' \
  -T fields -e tls.handshake.extensions_server_name

Representative output (illustrative shape, not a capture from N-central):

<vendor-fqdn>
<vendor-fqdn>
<patch-cdn-fqdn>

That short list is your egress allowlist candidate. Anything outside it is either a feature you did not know about or something you need to explain.

Probing the agent endpoint from a test host

In an authorized lab, with your own instance, confirm what the agent-facing surface exposes before you assume:

## TCP reachability only
nc -vz <lab-ncentral-host> 443

## TLS + response headers, no exploitation
curl -sSI https://<lab-ncentral-host>/ | head -20

Representative output:

Connection to <lab-ncentral-host> 443 port [tcp/https] succeeded!
HTTP/1.1 200 OK
Server: <server-header>
X-Frame-Options: SAMEORIGIN

Header disclosure is not a vulnerability. It is an inventory fact that tells you which build you are looking at and whether it matches what your asset list says.

Reading process and service context on the managed host

On a lab endpoint, record the agent's privilege, its parent process, and its token:

Get-Process -Name <agent-process> -IncludeUserName |
  Select-Object Id, ProcessName, UserName, Path
whoami /priv | Select-String -Pattern 'SeDebugPrivilege|SeImpersonatePrivilege'

SeImpersonatePrivilege present on the agent's service account is not a vulnerability in itself, but it is the reason a foothold in that process can become a foothold in any process.

Detection Signals Worth Deploying Today

Host-side process and service anomalies

SignalWhy it matters
Agent child process spawning cmd.exe, powershell.exe, or shagents do run scripts, but you should know which ones and from where
New service created outside a patch windowscript-driven service creation is a common post-exploitation step
Scheduled task created by the agent binarypersistence that survives reboot
Agent service identity changedan easy way to keep access after a password rotation
Agent binary hash changed outside an upgrade windowtampering or a sideloaded build

The first row is the one I would tune first, and accept the noise. If you cannot correlate script execution to a change ticket, you cannot tell an attacker's automation from your own.

Network-side egress and re-registration anomalies

  • Agent process making connections to a destination that is not the RMM FQDN or the patch CDN.
  • A host re-registering after it was removed from inventory.
  • A decommissioned hostname reappearing in console inventory.
  • Agent connections originating from a country or ASN you do not operate in.

Console-side audit log checks

This is where a small script earns its keep. Export the console audit log daily, and diff for the operations an attacker actually needs:

scan-console-audit.js
// Reads a CSV export of RMM console audit events and flags
// the operations that matter most during a management-plane incident.
const fs = require("fs");

const HIGH_RISK = [
/api.?token.?creat/i,
/role.?(chang|assign|grant)/i,
/user.?(enable|unlock|creat)/i,
/remote.?(session|control).?(start|connect)/i,
/(script|task|policy).?(creat|deploy|run)/i,
/agent.?(remov|delet|un enroll|regist)/i,
];

const lines = fs.readFileSync(process.argv[2], "utf8").split(/
?
/);
const header = lines.shift().split(",");

for (const line of lines) {
if (!line.trim()) continue;
const cols = line.split(",");
const row = Object.fromEntries(header.map((h, i) => [h.trim(), cols[i]]));
const action = String(row.action || row.event || row.operation || "");
if (HIGH_RISK.some((re) => re.test(action))) {
  console.log([row.timestamp, row.actor, row.action, row.target].join("	"));
}
}

Run it against yesterday's export and read the output:

node scan-console-audit.js audit-2026-11-13.csv | wc -l

Representative output:

2026-11-13T02:14:07Z	svc-integration	api_token.create	tenant-<redacted>
2026-11-13T02:14:09Z	svc-integration	role.assign	tenant-<redacted>

Two events, ninety seconds apart, at 02:14, from a service account, against a tenant you did not touch that week. That is a five-minute investigation that the platform's own UI will never surface for you.

Containment Order of Operations When the Vendor Pulls the Platform

What to do in the first hour

  1. Write down the timeline. Vendor notice time, your discovery time, the exact scope you believe is affected. You will not remember this later.
  2. Confirm you can still push. If the platform is offline, you have no remote remediation. Establish what out-of-band channel exists — EDR console, MDM, direct RDP with a break-glass account — before you need it.
  3. Export audit and inventory data for the 30 days before the outage, if the console is reachable at all. If it is not, note the gap explicitly in your incident record.
  4. Assume console credentials are burned and plan rotation, but do not rotate everything immediately (see below).
  5. Snapshot, do not reboot. Reboots destroy memory-resident evidence and, if the persistence is agent-side, they do not help anyway.

Credential rotation sequencing and why order matters

The instinct is to rotate domain admin first. That is usually the wrong first move.

OrderWhat to rotateWhy here
1RMM console users, API tokens, session secretsIf the console is the entry point, every other rotation is visible to the attacker until this one lands
2Credentials stored inside the RMM for task executionThese are the ones that turn a console compromise into a domain compromise
3Local administrator passwords (LAPS-style) on managed endpointsBreaks lateral movement that relies on shared local admin
4Service accounts used by agent-run automationOften over-privileged, rarely rotated
5Domain-level accounts, including krbtgtOnly with evidence of domain compromise — twice, per established practice

The principle: rotate the credential the attacker most wants first, and do not touch the channel they are watching until that is done. If you rotate local admin while the console token still works, the attacker sees you do it.

Re-onboarding without rebuilding the same exposure

When the platform comes back, resist restoring the configuration you saved. That configuration included the long-lived tokens, the over-scoped service accounts, and the "all clients" API integration. Rebuild instead:

  • new registration credential per client, not per tenant,
  • new API tokens with explicit expiry and per-client scope,
  • agent installer hash verified before deployment,
  • a documented list of who can start a remote session, and for which client.

Hardening the Agent So a Compromise Stops at One Host

Egress allowlisting and proxy enforcement

Allowlist the RMM FQDN and the patch CDN. Default-deny everything else from the agent's service account. Then verify the allowlist is enforced at the OS level, not just documented:

New-NetFirewallRule -DisplayName "RMM-Agent-Egress" -Direction Outbound `
  -Program "C:\Program Files\<vendor>\agent\agent.exe" `
  -RemoteAddress 203.0.113.24 -Action Allow -Profile Domain,Private

Note the two traps. First, a rule that allows the program anywhere is not an allowlist. Second, TLS inspection in front of agent traffic can break certificate pinning and generate an outage you will blame on the vendor — verify with the vendor before enabling it.

Least privilege for the agent service account

If your build supports running the agent under a managed service account or a gMSA rather than LocalSystem, do it and measure what breaks. If it does not, treat LocalSystem as a documented risk with compensating controls: EDR on the host, script-execution logging, and alerting on agent child processes.

Getting tenant credentials out of the RMM database

This is the highest-value architectural change on the list, and the hardest. If the console stores credentials that can authenticate to customer domains, then the console is a domain controller in all but name. The direction of travel:

  • short-lived, brokered credentials issued per task (secretless / PAM broker),
  • no interactive logon rights for anything the RMM stores,
  • a documented inventory of what the RMM can authenticate as, reviewed quarterly.

Tenant-to-tenant segmentation

Assume one agent credential will be compromised and design so it does not matter. Separate client endpoints onto different network segments where practical, use distinct service accounts per client rather than one fleet-wide account, and make sure the console enforces per-client authorization on the API, not just on the navigation menu.

What I Would Fix First, and What I Think Is Overweighted

Fix first: the agent privilege model. Everything else is downstream. A LocalSystem agent with script execution is a permanent, authenticated, allowlisted remote-code-execution channel that ships with documentation. Until that process is constrained and monitored, no amount of vulnerability patching changes the outcome of a console compromise.

Fix second: what the console can authenticate as. That is the difference between one compromised MSP and forty compromised domains.

Fix third: session and token lifetime. Boring, cheap, and it shortens every incident.

Overweighted: the number 33. Vulnerability counts are a disclosure artifact. A single unauthenticated agent-facing bug is worse than thirty-three that require an authenticated console session.

Also overweighted: "we run outbound-only." That describes your firewall, not your trust model.

And the same goes for waiting on CVE IDs before acting. If the vendor pulled the platform, you already have enough information to export logs, verify agent presence from the host side, and inventory your console tokens. Waiting for a CVE record to start is how the first hour gets wasted.

What I Confirmed Versus What I Did Not Test

What I confirmed: the reporting timeline and the two named chains, as published by BankInfoSecurity on 2026-11-14 and Meteora Web on 2026-11-15. The commands above are standard, non-exploit diagnostics; the outputs shown are illustrative of the format you should expect on your own hosts, not captures from N-central.

What I did not test: I have not run any part of Agent2Shell or 4EverAble2Shell, have no access to an affected build, and do not know the affected versions, required privilege level, or whether either chain requires authentication. The four-step trace and the re-enable hypothesis are reasoned from how RMM products are generally built and from the names themselves. They are starting points for investigation, not findings. No CVE identifiers, version numbers, or researcher names are stated here because the public material I have does not contain them.

What would change my assessment: a vendor advisory showing both chains require an authenticated console session. That would downgrade this from an internet-facing emergency to a credential-theft and persistence problem — still serious for an MSP, but a different set of first-hour actions.

Further Reading

Share this post

More posts

Loading comments…