CVE Technical Deep-Dives

Critical Zero-Day Vulnerability in Citrix NetScaler RCE

By Pranav Khune

18 min read

CVE-2026-88771 Critical Zero-Day Vulnerability in Citrix NetScaler RCE

Citrix NetScaler ADC and Gateway are widely used in enterprises for application delivery, SSL VPN access, and load balancing. 

CVE-2026-88771 is a critical pre-authentication remote code execution flaw. It allows attackers to inject malicious content into the log-processing pipeline and execute commands as root on the underlying FreeBSD system, without authentication.

Attackers reportedly exploited the flaw as a zero-day for at least two weeks before Citrix disclosed it.

On September 27, 2026, Citrix published bulletin CTX697096, disclosing CVE-2026-88771 alongside CVE-2026-88772, a related DTLS memory overflow vulnerability. 

CISA added both flaws to its Known Exploited Vulnerabilities (KEV) catalog the same day.

Investigations revealed webshell deployments, rogue superuser accounts, and command-and-control (C2) infrastructure on hundreds of compromised appliances.

Help Net Security reported that exploitation had spread across multiple regions before the disclosure.

CVE-2026-88771 attack chain
CVE-2026-88771 attack chain: Log poisoning through the authentication endpoint, followed by forged PPE failure processing by a maintenance script, resulting in root-level remote code execution on NetScaler. 

What is Citrix NetScaler ADC and Gateway?

Citrix NetScaler ADC is used by enterprises to manage web traffic, balance server loads, and secure applications. NetScaler Gateway provides remote access through SSL VPN, allowing employees to connect to internal systems from outside the corporate network.

Both run on a FreeBSD-based operating system and use Citrix’s proprietary NetScaler Packet Processing Engine (NSPPE) to handle network traffic.

These appliances often sit at the edge of corporate networks, exposed directly to the internet. That makes them an attractive target for attackers. The 2023 CitrixBleed vulnerability (CVE-2023-4966), which was widely exploited in 2023 and 2024, showed how damaging such flaws can be.

NetScaler vulnerabilities have repeatedly appeared in CISA’s Known Exploited Vulnerabilities (KEV) catalog. Given their role in enterprise networks, a successful attack can give intruders a direct foothold in critical infrastructure.

Static Analysis and Root Cause

Source Material

The analysis below is based on firmware extracted from three NetScaler ADC builds obtained from Citrix’s support portal and published in the craigsblackie/cve-2026-88771-netscaler research repository:

BuildSHA-256 of ns_monuploadd_err.plStatus
14.1-66.59fb7f574a4c185fa8e520c47280939ce22899243a0083ee7120b7300c43baca29Vulnerable
14.1-72.61fb7f574a4c185fa8e520c47280939ce22899243a0083ee7120b7300c43baca29Vulnerable (byte-identical to 66.59)
14.1-73.3702b24a9923a6cee1fbee48137b7f81b7e0f5169246728b7368fc3a066c43a708Patched

The vulnerable Perl script is byte-identical across both vulnerable builds. All code excerpts below are from the extracted firmware, cross-referenced against published incident response analyses and threat intelligence reports.

End-to-End Data Flow

The complete chain from unauthenticated input to root shell, as documented in the firmware root-cause assessment:

Unauthenticated management login request: 

  • Failed login audited to /var/log/ns.log as CMD_EXECUTED.
  • Root-owned adm_auto_reg_daemon.py begins its first or hourly probe.
  • Initial NetScaler Console endpoint discovery succeeds.
  • CriticalEvent.check_critical_events().
  • _check_disk_pe_failure() (first call immediately, then every 24 hours).
  • util.get_pe_failure_info().
  • /netscaler/ns_monuploadd_err.pl -WR.
  • grep, sed, and awk derive a “core filename” from attacker-influenced log text.
  • Unquoted interpolation into find … -name ${value}* ….
  • Shell command execution as root, before any core-existence check.

The Caller: Administered Daemon (Python)

The Perl script is not a standalone process. The adm_auto_reg_daemon.py service invokes it and starts at boot through nsstartpe.sh. The calling constants are defined in mastools/scripts/admautoreg/constant.py:

# constant.py (extracted from mastools-72.61)WAITING_TIME_HDDCF_PE_FAILURE_CHECK = 24*60*60  # 24:00HCHECK_PE_FAILURE_CMD = '/netscaler/ns_monuploadd_err.pl -WR'

After the first boot, the daemon waits 1,800 seconds before its initial probe. Once it caches the NetScaler Console endpoint, the local event parser runs before each outbound heartbeat. This check is limited to once every 24 hours.

These service, connectivity, and timing requirements explain the CVSS v4 AT:P rating.

The Authentication Handler: Unsanitized Input to Log

The NetScaler Packet Engine (NSPPE) processes login requests through the NITRO API (/nitro/v1/config/login) and the browser login controller (/nf/auth/doAuthentication.do).

The decompiled login handler (nsppe_api_login_799b90.c from the firmware extract) checks only the username length. It does not enforce a character allowlist or sanitize the input.

username length < 128 = accepted

Failed login attempts are recorded in /var/log/ns.log as CMD_EXECUTED events. The raw username is preserved, including shell metacharacters such as ;, |, backticks, $() and $ {IFS}.

Expected legitimate log entry:

pitboss: NSPPE-00 (12345) unexpectedly died

Forged entry injected by an attacker:

pitboss: NSPPE-00 (12345) unexpectedly died; $(echo YmFzZTY0...|base64 -d|sh)

The Vulnerable Script: ns_monuploadd_err.pl (Full Source)

The 668-line Perl script is a maintenance tool that handles five operational checks: HDD errors (-HDDCF), warm restarts and PPE crashes (-WR), memory anomalies (-MA/-MAWO), and nsapps core dumps (-NSAPPS_CORES).

The vulnerability lies in the-WR branch, specifically lines 359–455.

Log files read by the script (line 363):

# ns_monuploadd_err.pl — extracted from rootfs-72.61 (VULNERABLE)
my @WR_FILES = ("$OFF_DIR/var/log/ns.log.0", "$OFF_DIR/var/log/ns.log", "$OFF_DIR/var/log/messages");

The vulnerable shell pipeline (lines 368–369):

my $WR_PPE_COREFILE_NAME = `grep -E -i "pitboss.*PPE.*missed too many heartbeats|pitboss.*PPE.*unexpectedly died" @WR_FILES |\
tail -1 | sed -e 's!.*NSPPE!NSPPE!g' -e 's!(!!g' -e 's!)!!g' | awk '{ print \$1"-"\$2 }'`;

The shell sink (line 377):

chomp($WR_PPE_COREFILE_NAME);
my $WR_PPE_CORE =`find $OFF_DIR/var/core -name ${WR_PPE_COREFILE_NAME}* -print | tail -1`;

The vulnerability has two parts:

1. Inject after the filename pattern. No validation of extracted text. The grep/sed/awk pipeline extracts text from the last matching log entry. The sed command removes everything before NSPPE and strips parentheses. 

The awk command then takes the first two whitespace-delimited words and joins them with a hyphen. However, it never checks whether the result matches a valid PPE name and numeric PID. 

An attacker can use $ {IFS} instead of literal spaces to preserve shell metacharacters through the pipeline.

2. Shell interpolation of unvalidated input. The extracted $WR_PPE_COREFILE_NAME is inserted directly into a second Perl backtick command. 

Perl passes backtick commands to /bin/sh for execution, allowing embedded shell metacharacters to trigger command execution. The wildcard (*) appended to the filename pattern provides another opportunity for injection.

The Sink:  Root-Level Shell Execution via Perl Backticks

Perl’s backtick operator (`…`) launches a /bin/sh process and returns its output. On NetScaler, both admautoregd and the maintenance scripts run as root.

There is no privilege separation, sandboxing, or Capsicum/jail restriction between the maintenance script and the operating system.

As a result, an injected command runs with root privileges and can access:

  • /flash/nsconfig/: Contains ns.conf, encrypted administrator passwords, LDAP/RADIUS/TACACS bind credentials, TLS certificates and private keys, SSH host keys, and HA synchronization settings.
  • /etc/httpd.conf: Contains web server configuration. Attackers can modify it to enable PHP/CGI and map webshells to CSS-like URLs.
  • /var/netscaler/logon/LogonPoint/: Contains web-accessible directories that can be used to deploy webshells.
  • Network interfaces and internal networks: The appliance operates at the network edge, giving attackers with root access a potential path to systems and services inside the corporate network.

The Timing Gap: Delayed Execution Creates a Forensic Blind Spot

The maintenance script runs on a schedule, not immediately on each log write. The WAITING_TIME_HDDCF_PE_FAILURE_CHECK constant in the daemon is set to 24*60*60 (24 hours). This creates two operational consequences:

  1. Attackers must ensure their poisoned log entry remains the last matching line when the script runs. The script uses tail -1 to select only the most recent match, so attackers periodically resubmit the trigger request.
  2. The temporal gap complicates forensic correlation. The authentication log entry and the root-level command execution may be hours apart, making it harder to connect the two during incident response.

Chaining with CVE-2026-88779: According to Rapid7’s incident response findings, attackers combined CVE-2026-88771 with CVE-2026-88779, a SAML parsing vulnerability, to trigger repeated nsaaad crashes and force a Pitboss reboot.

After the reboot, the crash handler processed the previously injected log entry and executed the attacker’s payload as root. This allowed attackers to bypass the normal 24-hour execution interval and trigger the payload much sooner.

The Full Call Stack

CVE-2026-88771 full attack chain
CVE-2026-88771 full attack chain: three-stage flow from unauthenticated login input through log file trust boundary to root shell execution via unquoted Perl backtick interpolation

Firmware Regression Matrix

Evidence14.1-66.5914.1-72.6114.1-73.37
Unsafe ns_monuploadd_err.pl -WR shell parserpresentpresentremoved/hardened
CHECK_PE_FAILURE_CMD = … -WR in constant.pypresentpresentremoved
_check_disk_pe_failure() in daemonpresentpresentremoved
get_pe_failure_info() subprocess callpresentpresentremoved
Boot-time admautoregd_ctl startuppresentpresentpresent

CVE-2023-3519 and CitrixBleed (CVE-2023-4966): Same Product and Recurring Pattern

DimensionCVE-2023-3519 (Jul 2023)CVE-2023-4966 / CitrixBleed (Oct 2023)CVE-2026-88771 (Sep 2026)
Bug classStack overflow in SAML parser (C code)Buffer over-read in HTTP header parsingCommand injection via log poisoning (Perl)
Auth requiredNoneNoneNone
ImpactRCE as nobody followed by privescSession token disclosure followed by  account takeoverDirect root RCE
Exploit complexitySingle crafted SAML assertionSingle requestTwo-stage: log storage + maintenance script trigger
Exploited as zero-dayYes (state actors, per CISA)Yes (mass exploitation)Yes (weeks before disclosure)
CISA KEVYesYesYes
CVSS9.8 (v3.1)9.4 (v3.1)9.5 (v4.0)

Why This Class of Bug Persisted

  1. Log injection: The vulnerability stems from a fundamental trust boundary violation: the maintenance script treats log content as trusted data. Log injection leading to code execution is a well-documented attack pattern (CWE-117, Log Injection), but it rarely results in root-level remote code execution. On NetScaler, three architectural factors increase the severity:
  2. Monolithic privilege model: The entire NetScaler stack, including NSPPE, the management plane, and maintenance scripts, runs with root privileges. As a result, successful injection into any component can lead to maximum system-level impact.
  3. Perl maintenance scripts: The crash-handling scripts appear to have been designed as operational tools without accounting for adversarial input. They assume that logs contain only legitimate crash data, creating an opportunity for attackers to manipulate how that data is processed.
  4. Authentication logs as an attack surface: The username field in authentication requests provides an obvious injection point. However, the path from user-controlled input to shell execution crosses multiple components, including the authentication handler, logging mechanism, and maintenance script. This makes the vulnerability difficult to identify during isolated, component-level code reviews.

Patch Diffing

The diff below compares the actual firmware-extracted code from builds 14.1-72.61 (vulnerable) and 14.1-73.37 (patched), both obtained from Citrix’s support portal.

1. Strict regex capture replaces the shell pipeline (lines 368-376)

BEFORE: rootfs-72.61/netscaler/ns_monuploadd_err.pl, lines 368-369

my $WR_PPE_COREFILE_NAME = `grep -E -i "pitboss.*PPE.*missed too many heartbeats|pitboss.*PPE.*unexpectedly died" @WR_FILES |
tail -1 | sed -e 's!.*NSPPE!NSPPE!g' -e 's!(!!g' -e 's!)!!g' | awk '{ print $1"-"$2 }'`;

AFTER: rootfs-73.37/netscaler/ns_monuploadd_err.pl, lines 368-376

code

The regex (NSPPE-\d{2}) accepts only a PPE name consisting of NSPPE- followed by exactly two digits. The PID capture (\d+) accepts digits only. Text outside these patterns, including shell metacharacters, cannot become part of the captured filename components. This prevents untrusted log content from being passed directly into the filename variable.

2. List-form open replaces backtick shell invocation (line 377 to lines 384-396):

BEFORE: rootfs-72.61, line 377

my $WR_PPE_CORE = `find $OFF_DIR/var/core -name ${WR_PPE_COREFILE_NAME}* -print | tail -1`;

AFTER: rootfs-73.37, lines 384-396

if (open my $find, '-|', 'find', "$OFF_DIR/var/core", '-type', 'f',
    '(', '-name', $WR_PPE_COREFILE_NAME,
    '-o', '-name', "$WR_PPE_COREFILE_NAME.gz", ')')
{
    while (my $found = <$find>) {
        chomp $found;
        # path should contain only alphanumeric chars and [/-.]
        # it gets used downstream within backticks
        if ($found =~ /\A[A-Za-z0-9\/\-.]+\z/) {
            $WR_PPE_CORE = $found;
        }
    }
    close $find;
}

The list-form open ‘-|’ passes arguments directly to find as an argument array. No shell is spawned, so shell metacharacters cannot alter command execution. The wildcard (*) is also removed. The patched code explicitly searches for either an exact filename or its .gz variant.

The additional path validation restricts the resulting path to alphanumeric characters and the permitted /, -, and . characters. This is particularly relevant because the path is subsequently used in backtick commands.

3. Output validation (defense-in-depth):

The comment in Citrix’s own patched code is revealing:

# path should contain only alphanumeric chars and [/-.]
# it gets used downstream within backticks

This confirms that the developers were aware that downstream code still uses backticks. To reduce the risk of command injection, they added a character-class whitelist (/\A[A-Za-z0-9\/\-.]+\z/) to validate the resulting file path before it reaches those commands.

4. Caller removal (mastools-73.37):

In the patched mastools package, Citrix removed the entire call path:

Component72.6173.37
CHECK_PE_FAILURE_CMD constantPresentRemoved
_check_disk_pe_failure() methodPresentRemoved
get_pe_failure_info() subprocess callPresentRemoved

The patched build both hardens the Perl script and removes the daemon code that invoked it. This provides an additional layer of protection beyond fixing the vulnerable script itself.

Fix strategy: Four layers of defense

  1. Safe API adoption: List-form open eliminates shell interpretation when invoking find.
  2. Strict input validation: Regex captures restrict the PPE name and PID to expected formats.
  3. Output validation: A character-class whitelist restricts the resulting file path before downstream use.
  4. Caller removal: The daemon’s subprocess call path is removed, preventing the original execution flow from being triggered.

Together, these changes constitute a defense-in-depth fix that addresses the injection risk at multiple stages.

What the patch does not fix:

  • Root-level execution remains: NSPPE and maintenance scripts continue to run with root privileges. The underlying monolithic privilege model is unchanged.
  • Log-processing risks remain: The log-processing pipeline still exists. Other scripts that trust log content without proper validation could introduce similar injection vulnerabilities.
  • No privilege separation: The management plane and data plane still lack privilege isolation.
  • No sandboxing: The maintenance scripts are not isolated using mechanisms such as Capsicum, seccomp, or jail.

The patch addresses the immediate vulnerability through safer command execution, input and output validation, and removal of the original caller. However, it does not address the broader architectural risks associated with running privileged maintenance processes without isolation.

Severity and Impact

Affected Versions

BranchAffectedFixed
NetScaler ADC/Gateway 14.1All builds before 14.1-73.4614.1-73.46
NetScaler ADC/Gateway 13.1All builds before 13.1-64.2913.1-64.29
NetScaler ADC 14.1-FIPSAll builds before 14.1-73.46 FIPS14.1-73.46 FIPS
NetScaler ADC 13.1-FIPS / NDcPPAll builds before 13.1.37.28313.1.37.283
NetScaler ADC/Gateway 12.1All builds (EOL)No fix: EOL, upgrade to 13.1 or 14.1

Note: The initial advisory listed 14.1-73.37 and 13.1-64.23 as fixed builds; later updates superseded these with 14.1-73.46 and 13.1-64.29 which also address CVE-2026-88779. Check Citrix bulletin CTX697096 for current guidance.

Indicators of Compromise

Persistence Framework

FilePurpose
vcGo reconnaissance scanner — maps routes, DNS, LDAP/AD, vCenter
vcscan-agent.shScanner launcher
agent.plPerl TCP session manager and internal pivot
bridge.plPerl network bridge
boot.shBoot persistence survives reboots
reverse-agent.shOutbound command agent, polls C2 every 15 seconds

Directory: /flash/.nsvm/: nsvmd Proxy Agent

FilePurpose
nsvmdProxy agent binary, marked immutable with chflags uchg
watchdog.sh45-second watchdog loop
guard.shCron guard:  reseeds persistence every 5 minutes
restart.shDaily restart script

The nsvmd agent communicates with C2 domain v5v.in (SNI: c.v5v.in) on port 443. Persistence is maintained through cron jobs (5-minute and daily), /nsconfig/rc.netscaler boot hooks, and the watchdog loop.

Web Shells

Multiple web shell variants were deployed across different campaigns. Attackers modified Apache configurations to disguise web shells as legitimate files and URLs, making them harder to identify through routine inspection.

Apache httpd.conf modifications to serve web shells:

  • File extension mapping: The .deb and .sig extensions were mapped to execute as PHP files.
  • PHP execution enabled: The php_flag engine off directive was changed to on, allowing PHP execution.
  • AliasMatch rules: CSS-looking URLs were mapped to web shell files:
    • /logon/LogonPoint/custom/receiver.v2.min.css mapped to .slap.receiver.
    • /logon/LogonPoint/custom/receiver.min.<hex>.css mapped to .ctxs.receiver. The second mapping used a regular expression with a randomly generated hexadecimal suffix.
  • Apache configuration reload: Attackers sent SIGHUP to Apache to reload the modified configuration without restarting the service.

Web shell authentication:

The .ctxs.receiver web shell uses RC4 encryption with the passphrase Rhfajaf1H992. Its corresponding MD5 key is 7489a0f93c67fa5cdaeb4b921d90594d.

Commands are delivered through the NSC_TASS cookie. The CsrfToken cookie uses the fixed value e826d7ddf3c85920.

These mechanisms allowed attackers to conceal web shells behind URLs that resembled legitimate Citrix Gateway CSS resources while using encrypted cookie-based communication to interact with the compromised appliance.

Pivot Tools: WHIPSHOT and SLAPSHOT

ToolTypePurpose
WHIPSHOTPHP web shellReceives Base64 data in custom HTTP headers, returns HTTP 404 to hide C2
SLAPSHOTPython tunnelerOpens arbitrary TCP connections from NetScaler to internal hosts

SLAPSHOT commands: open, push, pull, exch, close, ping. The two tools communicate over a loopback TCP socket, WHIPSHOT is the internet-facing front end, SLAPSHOT is the internal pivot.

Privilege Escalation and Credential Theft:

  • /bin/sh set to mode 6555 (SUID/SGID):any process can obtain root
  • /flash/nsconfig archived and exfiltrated:contains encrypted admin passwords, LDAP/RADIUS bind credentials, TLS certificates and private keys, SSH host keys
  • Rogue superuser accounts created for persistent management access
  • HA peer manipulation:implant files synced to HA partner, forced failover to maintain access.

Network Indicators:

C2 Infrastructure:

IndicatorRole
v5v.in / c.v5v.innsvmd C2 (port 443)
209.74.64.192nsvmd C2
192.159.99.139.slap C2, relay, loot upload
213.209.159.55Stage server (delivers droppers)
179.60.146.241Dropper delivery
45.92.1.17Stage/loot (port 30444)
209.141.43[.]95FreeBSD payload server

Reconnaissance/Exploitation IPs:

104.248.244[.]66, 77.83.199[.]39, 78.47.24[.]217, 139.180.152[.]138, 66.135.19[.]18, 167.99.111[.]203, 142.93.85[.]227, 104.248.74[.]206, 137.184.91[.]207, 162.33.178[.]9, 193.149.176[.]207, 45.61.136[.]143, 66.227.183[.]84, 216.245.184[.]164

File Hashes (SHA-256):

HashArtifact
a0ba4e1ad622d9c3d950b4156d4430812d05bee216ab22c3804a9f7a8053555617447d.sh (dropper)
6774bfed99da38cec82e721de4bd64a67db7840efadcc71e7df02eb6f0a03c441.sh (dropper)
56a892d80096a9db4ca473a9c3109729c60a5ba901d6ba65948bdb1f4a6fb1862.sh/r.sh (nsvmd installer)
8e8b9532ce40eacfe1b4cf2b11241878b70b910aabd90b453b1460df19b51a4dscanner-freebsd-amd64 (Go recon)
eaf0086237879bbaac00a5874c0e2ff84deede1ba10e6b706e2288fd3a31cddevc (scanner binary)
ffe052fc50271e7739d458b155df790438776032bfd125b974735e1dd9c0b138nsvmd (proxy agent)
ae22ef2517b5c0fb47f78745b9cb5260acee0e751b89bcd354640ff8bc8d29ecnsg64.deb (PHP web shell)
1bd314b661396c7086f6367fbbb48025e03ca2de69c073d53a8b0a38aa5fbb7dBase64 payload text
79c65fa04541032e251fa4796b97800374b63c7982593dd1a2e0db605d429186Decoded shell script

MITRE ATT&CK Mapping:

IDTechniqueObserved Behavior
T1190Exploit Public-Facing ApplicationLog poisoning + DTLS overflow
T1059.004Unix ShellShell commands via log injection
T1059.006PythonSLAPSHOT tunneler, relay agents
T1059.007JavaScript/PHPWHIPSHOT, .ctxs.receiver, nsg64.deb
T1053.003Cron5-minute and daily jobs for nsvmd
T1037.004RC Scripts/nsconfig/rc.netscaler boot hook
T1505.003Web Shell6+ web shells across directories
T1548.001Setuid and Setgid/bin/sh mode 6555
T1036Masquerading.deb/.css extensions for PHP shells
T1027Obfuscated FilesBase64 payloads, RC4 web shell encryption
T1090.001Internal ProxySLAPSHOT loopback proxy
T1552.001Credentials In Files/nsconfig credential harvesting
T1005Data from Local SystemConfig, certs, keys
T1074.001Local Data Staging/var/tmp/.s2loot/ staging directory
T1560.001Archive Collected Datatar archives of /flash/nsconfig
T1572Protocol TunnelingSLAPSHOT TCP tunneling to internal hosts
T1041Exfiltration Over C2 ChannelLoot upload to 192.159.99[.]139

Conclusion

CVE-2026-88771 highlights why network appliances remain among the most attractive targets in enterprise environments. These devices operate as trusted infrastructure, often with privileged access to critical network services. 

The vulnerability itself is not particularly exotic. It involves log injection leading to command execution through an unsanitized maintenance script. 

However, its impact is severe because NetScaler runs its processes with root privileges and operates at the network boundary, handling VPN sessions, SSL certificates, and traffic routing across the organization.

The two-stage attack, involving log injection followed by maintenance script execution, also highlights why vulnerabilities cannot always be understood in isolation.

 A code review focused only on the authentication handler would likely miss this issue. Identifying the vulnerability requires tracing user-controlled input from the authentication request into the log file and then into a separate crash-handling component, where the input eventually reaches command execution.

Other network appliances could have similar weaknesses. Operational scripts responsible for backups, monitoring, and crash handling often process log data generated by other components. 

If those scripts treat log entries as trusted input, they can introduce command injection risks. Vendors such as Fortinet, Ivanti, Citrix, and F5 have all faced critical vulnerabilities in internet-facing appliances in recent years. 

The recurring security concerns include excessive privileges, insufficient input validation, and maintenance processes that do not account for malicious data.

For security teams, the immediate priorities are clear:

  • Patch: Upgrade affected NetScaler appliances to the fixed firmware version.
  • Assume compromise: Investigate appliances for signs of exploitation, particularly if they were exposed while vulnerable.
  • Rotate credentials: Reset potentially exposed credentials, including administrative and service account credentials.
  • Hunt for web shells: Inspect Apache configurations, suspicious PHP files, unusual CSS-looking URLs, and unexpected changes to appliance files.

Patching addresses the vulnerability, but it does not establish that an appliance was never compromised. Organizations should treat remediation and compromise assessment as separate responsibilities.

References