In one week this month, the remote-management industry had the kind of run usually reserved for VPN appliances.

On November 8 a researcher dumped public exploits for 33 alleged zero-days in N-able N-central. By November 9 N-able had taken its hosted N-central platform offline in every region and told on-prem customers to shut their servers down. The November 10 hotfix was reportedly bypassed by two new chains on November 11. That same day, attackers used a blank shared key in a third-party ScreenConnect extension to push a rogue second ScreenConnect client to 288 endpoints across 48 organizations in about 90 minutes. They came back on November 13 and hit 205 more.

None of this is new. It is the latest round of something that has run all year, and the industry keeps describing it as a series of separate vendor incidents. It isn’t. Every RMM, remote-support broker and endpoint-management console is a Tier-0 asset, in the same class as a domain controller: it can run code as SYSTEM on everything it touches. Most of them are still deployed like a helpdesk ticketing tool, with a public web UI, a few extra integrations and a shared admin account.

This piece covers what the 2026 incidents have in common, the four ways attackers keep getting in, and a concrete hardening and detection baseline for anyone running this layer, whether you are an MSP or an internal IT team with one ScreenConnect server and 3,000 endpoints.

The 2026 scorecard

A partial list, drawn only from what this site has covered:

WhenProductEntryWhat attackers did with it
SpringSimpleHelp (CVE-2024-57726/57727/57728)Path traversal → tech API privesc → Zip SlipDragonForce pushed ransomware to whole MSP customer fleets in one go
AprilSimpleHelp, MeshAgent (brought in)Zero-days in mail/MFT, then installed RMMStorm-1175 used RMM for persistence and lateral movement, then Medusa ransomware in under 24h
June–JulySimpleHelp (CVE-2026-48558)OIDC ID token signature never verifiedForged technician sessions, TaskWeaver loader, Djinn Stealer going after cloud, registry and AI-assistant credentials
AugustN-central (CVE-2026-18556, then CVE-2026-18577)Auth bypass, then a bypass of the fixTake Control into endpoints, cloudflared services as an independent back door
SeptemberN-central (CVE-2026-86218)Pre-auth static code injection, CVSS 10Exploited as a zero-day before Hotfix 4
Aug–OctBeyondTrust Remote Support (CVE-2026-102764)Unauthenticated file operationsChina-linked espionage cluster on the appliance for about six weeks before disclosure
NovemberN-central (Able2Shell, 4EverAble2Shell, Agent2Shell)Legacy API Axis SOAP RCE → local root; server-to-agent channel bugsMiners first; Agent2Shell reaches SYSTEM on managed Windows endpoints
NovemberScreenConnect + RMM+ extensionEmpty AccessKey accepted as validRun Command fan-out, a second rogue client, a relay to hide it, attempted technician cookie theft

The vendor reports point the same way. Blackpoint’s 2026 annual report puts RMM abuse in roughly 30% of triaged incidents. Guardz attributes 26% of MSP endpoint threats to it. The numbers vary by telemetry, but the trend is clear: attackers would rather use your remote-management tool than bring their own C2, because yours is already signed, already allowlisted, already set to allow egress, and already running as SYSTEM.

Why this layer is different

When people say “the RMM is a supply-chain risk” they usually mean the blast radius. That’s true, but it is only one of six properties that together make this layer worse than an edge firewall:

  1. One-to-many execution by design. “Run this script on every device in this group” is the main feature, not a flaw. SCKit hit a third of its first-wave victims within ten minutes because that is how quickly the product delivers commands.
  2. SYSTEM on the far end. The agent is a privileged service. Every console action arrives as NT AUTHORITY\SYSTEM or root.
  3. Pre-trusted by your other controls. EDR exclusions, application-control allowlists and firewall egress rules are all set up so the agent keeps working. The attacker inherits all of them.
  4. Indistinguishable traffic. A forged SimpleHelp technician session uses the same protocol as a real one. Network monitoring sees no difference.
  5. A credential store. Consoles hold domain admin passwords for “run as” scripts, PSA and backup API keys, and cloud credentials for integrations. Djinn Stealer was not after the RMM itself. It was after everything the RMM could reach.
  6. Authentication that isn’t your authentication. This one doesn’t get enough attention, and it has its own section below.

Put these together and a pre-auth bug in an RMM console amounts to unauthenticated, EDR-blessed code execution as SYSTEM across thousands of hosts in dozens of organizations. Nothing else in a typical estate offers that.

The four ways in

1. Pre-auth bugs on an internet-facing console

This is the boring, dominant pattern: N-central five times since August, SimpleHelp’s 2024 trio still feeding ransomware crews in 2026, BeyondTrust’s file-operation bug. These products are large Java or .NET web applications. They carry legacy SOAP endpoints (4EverAble2Shell went in through the bundled Apache Axis stack behind N-central’s Legacy API), file upload handlers and XML parsers. They are exposed to the internet because technicians want to work from home and agents need to check in.

The mistake is treating “agents need to reach it” as meaning “the admin console needs to be reachable.” Those are different surfaces, and most products let you separate them.

2. Side-door authentication

This is the pattern I’d ask every reader to audit this week. Three of 2026’s worst RMM incidents never touched the product’s main login:

  • RMM+ gave ScreenConnect a second API that authenticated with one shared secret, RMMPlus.AccessKey. It didn’t use ScreenConnect users, roles or MFA. The key defaulted to empty, and empty matched empty. ConnectWise says about 400 partner environments had at least one extension from the RMM+ family installed, and it disabled five of them remotely where it could.
  • SimpleHelp CVE-2026-48558: OIDC was set up to federate technicians to the corporate IdP, which should have made things safer. The server never verified the ID token signature, so anyone could create their own identity, groups included.
  • N-central’s Legacy API: N-able’s own defence of 4EverAble2Shell was that it needs a “non-default configuration” with the Legacy API exposed. In practice that means a second, older way into the server that nobody was watching.

The lesson: your MFA policy covers the login page. It does not cover the product. Extensions, legacy APIs, integration tokens, agent-registration endpoints and “alternate” SSO flows are all authentication paths, and each one is only as strong as the weakest of them. In ScreenConnect’s case, the weakest was a blank field.

3. Hijacked sessions and abused features

TeamViewer’s CVE-2026-92370 let an authenticated peer rewrite the access controls the host had set for the session. SCKit’s last stage tried to steal ScreenConnect session cookies when a technician next connected to an infected host. The goal was to inherit an authenticated, MFA-satisfied console session and spread into other customers. That stage failed against patched clients, but the design is right, and the next version will be better.

The general point is that the technician’s browser session is a Tier-0 credential. It’s rarely treated as one.

4. Bring your own RMM

Storm-1175 installs SimpleHelp and MeshAgent after getting in some other way. Huntress has watched operators install one commercial RMM and then add a second for longer-term access. Attackers pick commercial RMM for the same reasons you do: it’s reliable, signed, and blends in. This is the easiest pattern to stop, because the fix is purely on the endpoint side: allowlist the specific instances you operate, not the product.

The persistence pattern: a second channel

Every serious 2026 RMM intrusion established an access path that does not depend on the way in:

  • N-central intrusions in August registered a new service running a Cloudflare Tunnel on managed endpoints. It is outbound-only, invisible to inbound firewall rules, and it outlives any fix on the server.
  • SCKit installed a second ScreenConnect client pointed at attacker infrastructure. It set the legitimate client’s service to manual start, then ran RelayTrap on TCP/81 so the technician’s console still showed the machine as online and healthy. Huntress saw hosts reinfected after isolation was lifted.
  • Djinn Stealer took credentials that work with no RMM at all.

This changes how you respond. Patching the console, rotating the admin password and disabling the extension do nothing to a fleet that already has a second channel. If your RMM was compromised, your remediation plan has to run through something else: EDR live response, a separate management plane, or physical or out-of-band access. Huntress explicitly advises against investigating SCKit hosts through ScreenConnect. If the tool you’re investigating with is the compromised one, the attacker controls what you see.

The hardening baseline

These are ordered by impact per hour of effort. Most can be done this quarter without buying anything.

Split the surfaces: agents in, technicians through a gate

Agents need to reach the relay or check-in endpoint. Technicians need the web console. These should be different listeners, ideally on different hostnames, and only the first should be on the internet.

For self-hosted ScreenConnect, the web UI (default 8040) and the relay (default 8041) are already separate ports. Put the relay on the internet and keep the web UI behind your VPN or a zero-trust access proxy. For products that serve both from one port, a reverse proxy in front can enforce the split. The paths below are placeholders. Get the real agent and API paths from your vendor’s networking documentation and test against a staging server first:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# Public listener: only what agents need
server {
    listen 443 ssl;
    server_name agents.rmm.example.net;

    # Agent check-in / relay paths (vendor-specific — confirm in docs)
    location ^~ /agent/  { proxy_pass https://rmm-backend; }
    location ^~ /relay/  { proxy_pass https://rmm-backend; }

    # Everything else — console, legacy APIs, extensions — is not here
    location / { return 404; }
}

# Console listener: reachable only from the access proxy / VPN range
server {
    listen 443 ssl;
    server_name console.rmm.internal.example.net;
    allow 10.50.0.0/24;   # ZTNA connector / VPN pool
    deny  all;
    location / { proxy_pass https://rmm-backend; }
}

This one change would have neutralised the internet-reachable version of every console-side bug in the table above, including RMM+, whose API lived on the ScreenConnect web interface. It does nothing for Agent2Shell-style bugs in the agent channel, which is why the endpoint-side controls further down matter.

Kill the side doors

Make a list of every way to authenticate to the server, not every user. For each one, either route it through your IdP with phishing-resistant MFA, or turn it off.

  • Extensions and plugins. List them, find who wrote them, and remove anything you can’t name a reason for. Check every extension setting for an empty or default shared secret. For ScreenConnect, look at the extension settings in the admin UI and in App_Extensions on disk.
  • Legacy and SOAP APIs. N-central’s Legacy API should be disabled unless a named integration needs it, and then allowlisted to that integration’s source IP.
  • API keys and integration tokens. Give each one an owner, a scope and an expiry date. Revoke any key that was minted on a build later found vulnerable. The SimpleHelp 2024 chain worked by minting over-privileged API keys.
  • Federated login. If you federate to OIDC or SAML, confirm the product is on a version that validates signatures, and test it. Send it a token signed with the wrong key and check that it’s rejected. That’s a five-minute test, and CVE-2026-48558 shows why it’s worth doing.

Shrink what one session can do

  • Separate tenants for real. One console with RBAC scoping per customer is better than one global admin. Separate instances per customer tier are better still. The goal is that one compromised technician can’t reach every client.
  • Make mass actions hard. If your product supports approval workflows, script signing, or limits on how many devices a command can hit, turn them on. If it doesn’t, ask the vendor for them. “Run Command on all sessions” without a second approver is how SCKit got 288 hosts in 90 minutes.
  • Take credentials out of the console. Don’t store domain admin credentials in RMM “run as” profiles. Use a per-customer, LAPS-style local account or a vault checkout that the RMM can’t read at rest.
  • Shorten technician sessions and bind them to device posture where your access proxy supports it. A stolen cookie that expires in an hour, and only works from a managed device, has far less value.

Get the audit log off the box

Every console has an audit log of sessions, commands, script runs and admin changes. Almost nobody ships it to a SIEM, so when the console is compromised the evidence sits on the compromised host. Forward it, and alert on at least these:

  • A single command or script sent to more than N devices within M minutes, outside an approved change window.
  • New admin users, new API keys, or extension installs and configuration changes.
  • Console logins or API calls from outside your access-proxy egress range. Once the console is behind a gate this should never happen, which makes it a very clean signal.

A starting point in KQL, assuming you’ve normalised the RMM audit log into a custom table:

1
2
3
4
5
6
RMMAudit_CL
| where EventType in ("RunCommand", "RunScript", "DeployPackage")
| summarize Targets = dcount(DeviceId), Customers = dcount(CustomerId),
            Cmds = make_set(CommandText, 5)
            by Actor, bin(TimeGenerated, 10m)
| where Targets > 50 or Customers > 3

Tune the thresholds to your real patch-night behaviour. The point is to page someone when a command fans out across several customers in ten minutes, because legitimate work almost never does that unannounced.

Allowlist instances, not products

This is the control that would have caught SCKit, Storm-1175’s MeshAgent and every “second RMM” persistence trick. It runs entirely on endpoints you already manage with EDR.

ScreenConnect names its client service after the instance thumbprint: ScreenConnect Client (<16 hex chars>). Each MSP’s instance has a stable ID. Make a list of the IDs you operate and alert on anything else. Here’s a Sigma rule for new service installs:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
title: ScreenConnect Client Service Installed for Unknown Instance
status: experimental
logsource:
  product: windows
  service: system
detection:
  selection:
    EventID: 7045
    ServiceName|startswith: 'ScreenConnect Client ('
  allowlist:
    ServiceName|contains:
      - '(0123456789abcdef)'   # replace with your instance ID(s)
  condition: selection and not allowlist
level: high
tags:
  - attack.persistence
  - attack.t1219

And a one-off fleet hunt to run through EDR live response (not through ScreenConnect). It flags unknown instances and legitimate clients that have been quietly set to manual start, which is SCKit’s signature:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
$Allowed = @('0123456789abcdef')   # your instance IDs
Get-CimInstance Win32_Service |
  Where-Object Name -like 'ScreenConnect Client (*' |
  ForEach-Object {
    $id = ($_.Name -replace '.*\(([0-9a-f]+)\).*','$1')
    [pscustomobject]@{
      Host      = $env:COMPUTERNAME
      Instance  = $id
      Known     = $Allowed -contains $id
      StartMode = $_.StartMode
      State     = $_.State
      Path      = $_.PathName
    }
  } | Where-Object { -not $_.Known -or $_.StartMode -ne 'Auto' }

Add SCKit’s specific artifacts to the same sweep: a scheduled task named TrapWatch, a RelayTrap directory, a RelayTrapLiteAlert Run key, a listener on TCP/81, and Defender exclusions you didn’t set. Huntress’s published rogue client IDs 2588ef5c15954b10 and ed630cc2c873b091 are worth matching, but SCKit rebuilds its scripts per host. Behaviour is the durable indicator, not hashes.

Apply the same idea to every RMM. AteraAgent, MeshAgent, SimpleHelp, AnyDesk, Splashtop and the rest each have a service name, install path or config file that ties them to a specific tenant. Keep a list of approved tenants. Anything outside it gets an alert, and on servers it gets blocked by application control.

Close the tunnels

Block cloudflared from running on endpoints and servers that have no reason to use it, and alert on it anywhere:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
title: Cloudflared Tunnel Executed or Installed as Service
logsource:
  product: windows
  category: process_creation
detection:
  selection_img:
    - Image|endswith: '\cloudflared.exe'
    - OriginalFileName: 'cloudflared.exe'
  selection_args:
    CommandLine|contains:
      - 'tunnel run'
      - 'service install'
      - '--token'
  condition: selection_img or selection_args
level: high

At the egress proxy, alert on DNS for *.trycloudflare.com and on connections to Cloudflare’s tunnel edge from endpoint subnets. Tune this to your environment: quick tunnels are a red flag on a domain-joined workstation, but a dev team may use named tunnels legitimately.

Have a second way in

The most important control here isn’t a configuration setting. It’s having a management path that doesn’t run through the RMM: EDR live response, an independent remote-access tool used only for break-glass, or Intune or GPO for internal estates. When N-able told customers to power off their servers on November 9, MSPs that had nothing else lost visibility into their whole fleet, during an active exploitation wave, exactly when they needed it most.

Test it. Pick a customer, pretend the RMM is gone, and see how long it takes to push a script to all their endpoints another way.

When the console is already compromised

If the console was reachable during an exploitation window, run your response as if the attacker established a second channel, because in 2026 they nearly always did:

  1. Take the console offline and image it before patching. You want the logs and the webshells.
  2. Work from an out-of-band tool. Don’t use the RMM to investigate the RMM’s endpoints.
  3. Sweep the whole fleet for second channels: unknown RMM instances, new services, cloudflared, legitimate agents set to manual start, new local admins, and Defender exclusions.
  4. Rotate everything the console could read: stored credentials, integration API keys, PSA, backup, and cloud keys. Invalidate every technician session and IdP refresh token, since SCKit was after the cookies.
  5. Watch for reinfection after you lift isolation. Huntress saw it with SCKit. A host isn’t clean until it has stayed clean while reconnected.
  6. Tell downstream customers. If the console could reach their endpoints, they’re in scope whether or not your vendor has named them.

The position

Here is where I land.

First: self-hosting an RMM is a decision to run Tier-0 infrastructure, and most operators who make it aren’t staffed for that. The N-central incidents of August through November show the patch cadence that self-hosters have to keep up with: four hotfixes in five weeks in late summer, then a patch that was bypassed within a day in November. If you can’t patch your RMM within 24 hours and keep its console off the internet, a hosted tenant is the better trade.

Second: hosted doesn’t excuse you either. CVE-2026-18577 hit hosted N-central too, and on November 9 the hosted option was a global outage. Moving to hosted shifts who patches the server. It does nothing about instance allowlisting, second channels, credentials stored in the console, or your lack of a break-glass path. Those stay your job wherever the console runs.

Third: buyers have to start asking vendors for specific features. Every RMM vendor should be able to answer yes to these: can I split agent and console listeners? Does every authentication path, including extensions and APIs, go through my IdP? Can I require two-person approval for mass commands? Can I sign scripts? Can I stream the audit log in real time? Vendors build what renewals depend on. Right now renewals depend on features, not on any of this.

Takeaways

  • Classify every RMM, remote-support broker and endpoint-management console as Tier-0. Give it the network isolation, admin hygiene and monitoring you give a domain controller.
  • Keep the console off the internet. Expose only the agent and relay listener. Put technicians behind a VPN or access proxy.
  • Inventory every authentication path, including extensions, legacy APIs, integration keys and federated flows. Route each through the IdP or turn it off. Check for blank shared secrets today.
  • Allowlist RMM instances on endpoints, not products. Alert on any second client, any unknown tenant, and any legitimate agent switched to manual start.
  • Ship the console audit log to your SIEM and page on cross-customer fan-out.
  • Block cloudflared where it isn’t needed, and alert on quick tunnels.
  • Take credentials out of the console, and treat the technician browser session as a Tier-0 credential.
  • Build and test a break-glass management path that doesn’t depend on the RMM, before you need it.

References