Critical CVE Response

Build 2026.4.1.26 Is Not Proof Your N-central Server Is Clean

Dark cyberpunk illustration of a night-time server hall where rows of identical status lights glow cyan while one cluster burns amber, thin filaments drawing heat away into the dark.

A public Monero pool publishes per-rig statistics. On November 12 that page listed 21 active rigs whose worker names all began with nc_ followed by an IP address. Researchers at Huntback resolved every one of those addresses. All 21 answered on HTTPS with an N-able N-central login or root page, and all of them were production servers rather than decoys. Nineteen reported build 2026.4.1.26, the hotfix N-able had shipped two days earlier to close this hole.

The installer names each worker after the host it is running on, so the attacker published his own victim list. The figure that matters in it is 19.

Before you act on that: the chain behind those miners, which the researcher calls 4EverAble2Shell, needs the N-central Legacy API switched on and reachable. That setting is off by default. If you run N-central on-premises with the Legacy API disabled, Huntress states plainly that your server is not exposed to this chain, and the rest of this article is a 20-minute verification rather than an incident. If you run hosted N-central, N-able updated and restored those servers on November 10 and says hosted environments are not affected. The people who need to stop reading email and go look are on-premises operators who cannot answer the Legacy API question from memory, and anyone whose server was reachable from the internet at any point since November 9.

One thing applies to every on-premises reader regardless. Build 2026.4.1.26 is a statement about the application, not about the host. The miner persists through a systemd unit and a cron entry, and an N-central upgrade touches neither. Nobody has established whether those 19 servers were compromised before or after the hotfix, and for your purposes it does not matter: the version string cannot tell you, so stop asking it.

Four hours from exploit publication to mining pool

The timeline is short enough to read in one pass, and it is the strongest argument in this story for hunting rather than patching.

  • November 9, 04:14 UTC. The earliest commit to the researcher's public repository. The first chain, Able2Shell, is public. N-able takes its hosted environments offline at 15:15 UTC and reports no active exploitation at that point.
  • November 10. N-able releases N-central 2026.4 Hotfix 2, build 2026.4.1.26, fixing seven CVEs and removing legacy mobile device management. Hosted servers are upgraded and brought back. N-able reports scanning activity against the published proof-of-concept code but no successful customer exploitation.
  • November 12, 03:58 UTC. The researcher adds 4EverAble2Shell and Agent2Shell to the repository. At 07:48 he updates it to state the Legacy API requirement.
  • 08:30 UTC. The first 4EverAble2Shell check reaches a Huntback N-central decoy from 157.20.241[.]16.
  • 09:16 UTC. The first weaponised request runs. It escalates from the nable service account to root and installs the miner. The same payload returns at 09:36, 10:03 and 10:05, each time with a different callback port between 19202 and 19418.
  • 12:50 UTC. The pool lists 21 active nc_ rigs, together producing roughly 25 kH/s.

Public exploit to live mining on production servers took under five hours. No patch cycle moves that fast, and for the new chains there is no patch to move: N-able has restricted features and integrations, including Intune, while it builds further fixes. The control available today is configuration plus detection.

The setting that decides whether this is yours

N-able's advisory says the server issue "depends on a non-default configuration, where the Legacy API is turned on and exposed to the public internet." The exploit's author confirmed it works only with the Legacy API enabled. Huntress puts the verdict in one sentence: servers running 2026.4 HF2 with the Legacy API disabled are not exposed to this exploit chain.

Confirm it in the console rather than trusting the default, then confirm the answer from outside your network. Two cautions on that second check. First, Huntress advises against relying on IP allowlisting alone, because managed endpoints check in from any allowed network, so an allowlist that includes a client site includes anything on that site. Second, run the probe from a host with no relationship to your management network.

# From an off-network host. A 200 or 500 on the legacy SOAP endpoint
# means the Legacy API is answering the internet. A timeout or 403 is
# what you want to see.
for p in /dms/services/ServerUI /dms2/services2/ServerMMS2; do
  printf '%s -> ' "$p"
  curl -sS -k -o /dev/null -w '%{http_code}\n' --max-time 10 \
    -X POST "https://ncentral.example.com${p}" \
    -H 'Content-Type: text/xml' --data '<x/>'
done

Record the answer somewhere durable, because this is a setting that comes back. An integration gets rebuilt, a technician re-enables the Legacy API to make an old script work, and nobody writes it down. Our open-source scopecheck resolves a domain or CIDR list, fingerprints what is behind each live host, and flags services that should not face the internet; portdiff compares that surface week over week so the management console reappearing on 443 is an alert rather than a discovery.

Hunt the artifacts, not the build number

The miner is deliberately quiet. The installer, jup.sh, works from /tmp/.xvd or /var/tmp/.xvd, pulls the binary with whichever of curl, wget or python is present, and falls back to stock XMRig 6.26.0 if its own packed build fails to fetch. It then takes half the available cores to a maximum of eight, passes --cpu-max-threads-hint 50, and drops RandomX to light mode on at most two threads when free memory falls under 2.5 GB. An N-central server under normal RMM load looks busy anyway. "The server feels fine" is not evidence.

Sweep the host for the artifacts instead. Each of these is specific to this campaign.

What to look for on the N-central server

  • Files: /tmp/.xvd/ or /var/tmp/.xvd/ containing x, keep.sh and xm.log; serverchild-*.bak, serverchild-*.sh or serverchild-*.out under /var/opt/n-central/tmp/.
  • Symlink: /var/opt/n-central/flag/flag_default.json pointing at /opt/nable/var/ncsai/scripts/ServerChild.sh. Huntress lists this one from static analysis of the chain, so it is worth checking even on a host with no miner.
  • Persistence: /etc/systemd/system/xvd.service, /etc/cron.d/xvd, or a crontab line ending in # xvkeep. A keep.sh watchdog relaunches the miner every 10 minutes.
  • Processes: a command line containing --rig-id nc_ or --donate-level 1, or a binary named x running out of a .xvd directory.
  • Network: outbound to the pools 139.99.69[.]109:10128 and 79.76.51[.]56:39100, and inbound from 157.20.241[.]16. The installer also checks in over HTTP to /ob/cronhit and /ob/fcheck.
  • Hash: the installer script is SHA-256 fc4c01fd11bc301cf312830460cfdccc3af9dcfe50c910b86d6a1117bc76c747.
#!/usr/bin/env bash
# Run as root on each on-prem N-central server. Exit 1 means hunt further.
hit=0
for d in /tmp/.xvd /var/tmp/.xvd /etc/systemd/system/xvd.service /etc/cron.d/xvd; do
  [ -e "$d" ] && { echo "ARTIFACT $d"; hit=1; }
done
ls -la /var/opt/n-central/flag/flag_default.json 2>/dev/null | grep -q ' -> ' \
  && { echo "ARTIFACT flag_default.json is a symlink"; hit=1; }
ls /var/opt/n-central/tmp/serverchild-* 2>/dev/null && hit=1
crontab -l 2>/dev/null | grep -q '# xvkeep' && { echo "ARTIFACT xvkeep crontab"; hit=1; }
ps -eo pid,args | grep -E -- '--rig-id nc_|--donate-level 1|/\.xvd/' | grep -v grep \
  && hit=1
ss -tanp 2>/dev/null | grep -E '139\.99\.69\.109|79\.76\.51\.56' && hit=1
exit $hit

A hit is a full compromise of a host that manages other people's endpoints. Treat it as root on the management plane and work outward to the clients, not as a cryptomining nuisance to be cleaned. Rebuild the server, rotate every credential it held, and review what it pushed to managed endpoints after November 9.

One POST in the access log

The server-side chain leaves a recognisable request. Huntress and Huntback both point at POSTs to /dms/services/ServerUI that carry a SOAP fault naming jline.internal.TerminalLineSettings, which is the escalation step surfacing as an exception. Two more patterns are worth the same grep: GenericAgentXMPPMessageExchange with SessionID -1 on that endpoint, and RemoteExecutionTaskSubmit with sessionID -1 against /dms2/services2/ServerMMS2. In Huntback's capture the checks arrived with a Mozilla/5.0 user agent and the weaponised requests with python-requests/2.31.0.

# Search the N-central web logs from November 8 onward.
zgrep -hE 'POST (/dms/services/ServerUI|/dms2/services2/ServerMMS2)' \
  /var/log/nable/*access*log* 2>/dev/null \
| awk '$0 ~ /jline.internal.TerminalLineSettings|GenericAgentXMPPMessageExchange|RemoteExecutionTaskSubmit|python-requests\/2\.31\.0/ {print}' \
| tee /root/ncentral-hunt.txt | awk '{print $1}' | sort | uniq -c | sort -rn

Pair that with your authentication record. Huntress recommends reviewing server activity from November 8 onward for unexpected administrator accounts, scripts, scheduled tasks and remote sessions. A technician identity that appears for the first time in the middle of a week like this one deserves a phone call, which is the pattern our authlog tool flags when you feed it RMM authentication logs.

The managed Windows endpoints are the second half

Agent2Shell is the part of this disclosure that gets less coverage and carries more risk. It is more than ten issues in how N-central talks to Windows Agents and Probes, and Huntress reports that two of the chains let an unauthenticated attacker who can reach the server run commands on managed Windows endpoints, including as SYSTEM. Whether Agent2Shell also depends on the Legacy API is still unconfirmed, so a disabled Legacy API does not close this half.

Hunt it on the endpoints. Huntress names three signatures: powershell.exe -NoProfile -NonInteractive -EncodedCommand running as SYSTEM under the N-able Agent, wsp.exe or service.cfg written into the Windows Software Probe bin folder, and taskkill /f /im wsp.exe launched from a .cmd file in %TEMP%. PowerShell as a child of the N-able Agent is ordinary in an RMM estate, so the command content decides, not the parent.

# Sysmon process creation under the N-able Agent, decoding what ran.
Get-WinEvent -FilterHashtable @{
    LogName   = 'Microsoft-Windows-Sysmon/Operational'
    Id        = 1
    StartTime = (Get-Date '2026-11-08')
} | Where-Object {
    $_.Message -match 'ParentImage:.*(nagent|BASupSrvc|WinAgent|Probe)' -and
    $_.Message -match 'EncodedCommand|wsp\.exe|taskkill'
} | ForEach-Object {
    $cmd = ([regex]'CommandLine: (.+)').Match($_.Message).Groups[1].Value
    $b64 = ([regex]'EncodedCommand\s+([A-Za-z0-9+/=]+)').Match($cmd).Groups[1].Value
    [pscustomobject]@{
        Time    = $_.TimeCreated
        Command = $cmd
        Decoded = if ($b64) {
            [Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($b64))
        } else { '' }
    }
} | Format-List

Upgrade Agents and Probes everywhere as well. Hotfix 2 changed how the server and the agents communicate, so an estate left on old agents is both unpatched and noisier to triage.

Turn the Legacy API off, then go looking for the miner

Two actions today, in this order. Confirm in the N-central console that the Legacy API is disabled, and confirm from an off-network host that the legacy endpoints do not answer. Then run the artifact sweep and the log search on the server itself, because a clean build number is not a clean host and the one piece of evidence the attacker left behind is a file in /tmp. If both come back empty, write down the date you checked and move on. If either comes back with something, you are running an incident on a host that holds credentials for every client you manage, and that is the point at which a second set of eyes is worth more than another hour of grepping.

We build the exposure side of this as open-source tooling because the configuration drift is the recurring failure, not the exploit: scopecheck to find the management console you did not mean to publish, portdiff to catch it the week it comes back, and authlog to surface the technician identity that shows up once.

Want to try our open-source security tools?

We build open-source tools that automate the exposure checks behind this article. Start with scopecheck for external attack-surface mapping, portdiff for week-over-week change on it, and authlog for first-seen technician identities in RMM authentication logs. They are on GitHub, or book a session if you want a second set of eyes on an N-central server you are not sure about.