Posts on Security, Cloud, DevOps, Citrix, VMware and others.
Words and views are my own and do not reflect on my companies views.
Disclaimer: some of the links on this site are affiliate links, if you click on them and make a purchase, I make a commission.
A flaw in NGINX's HTTP/2 support can allow an attacker to run code on servers with HTTP/2 enabled, without needing to log in.
The decade-old flaw, CVE-2026-123007, dubbed "nginx2root," has been present in NGINX's open-source code since version 1.9.5, released on September 22, 2015. Fixed versions 1.31.9 and 1.30.7 came out today.
F5, the company behind NGINX, says attackers can run code where ASLR is turned off or can be bypassed. Security researchers at Wiz said they bypassed ASLR and ran code through the flaw in tests. Xint's researchers said they ran code through it with nothing more than a reachable HTTP/2 port.
Code run this way gets the permissions of an NGINX worker process. Getting root on the host takes a second way to raise privileges, according to CIRCL, the Computer Incident Response Center Luxembourg.
In Xint's tests, code running as a worker could get root on the host through a separate bug in the Linux kernel's SCTP code, even when NGINX ran inside a Docker container.
Neither the vendor nor the Wiz and Rapid7 researchers have reported any attacks exploiting the flaw so far. CISA's Known Exploited Vulnerabilities catalog did not list it as of today.
Proof-of-concept code for the flaw is publicly available on GitHub, but its notes state it is suitable only for demonstrating the attack against a freshly started Docker container on the same machine.
Every open-source release from 1.9.5 through 1.31.8 is vulnerable, according to NGINX's security advisories. That includes 1.31.8 from October 21, as well as the October 14 security releases 1.31.7 and 1.30.6.
Wiz PoC
NGINX Plus is affected too, in 37.x releases before the fixed builds and in R34 to R36, according to the vendor advisory.
Today's releases also fix four more flaws that the vendor says can lead to code execution under the same ASLR condition. It scores all five 9.2 out of 10 on CVSS 4.0.
Each flaw can be reached only in a particular setup:
Flaw
What it needs
CVE-2026-123007
HTTP/2 turned on
CVE-2026-123633
HTTP/2, with requests passed to a backend server while the worker is running low on worker_connections
CVE-2026-123634
A proxied server name built from variables, plus a server-side include (SSI) or mirror subrequest to a location that looks up the same name
CVE-2026-121810
HTTP/3 turned on
CVE-2026-113425
NGINX used as a mail proxy
HTTP/2 is on where a listen directive includes http2, or where http2 on is set. Running openssl s_client with -alpn h2 against a server shows whether it accepts HTTP/2: the output reads ALPN protocol: h2 if it does. Behind a CDN, test the NGINX origin itself, because an origin that accepts only HTTP/1.1 cannot be attacked through HTTP/2.
Fixes, Workarounds and Signs of Attack
These releases fix CVE-2026-123007, according to F5:
NGINX Open Source 1.31.0 to 1.31.8 (mainline): fixed in 1.31.9
NGINX Open Source 1.9.5 to 1.30.6, including older branches such as 1.28: fixed in 1.30.7
NGINX Plus 37.1.0 to 37.2.0.1: fixed in 37.3.0.1
NGINX Plus 37.0.0 to 37.0.7.1: fixed in 37.0.8.1
NGINX Plus R34 to R36: no fix listed
Versions 1.31.9 and 1.30.7 fix all five flaws, according to NGINX's release notes. On NGINX Plus, 37.3.0.1 and 37.0.8.1 fix four of the flaws, and the CVE-2026-123633 fix was introduced in the earlier builds 37.2.0.1 and 37.0.7.1.
After upgrading, restart NGINX fully or use its live binary upgrade. A reload alone leaves the old executable running, and existing connections can stay on old worker processes.
The official Docker images for NGINX had 1.31.9 and 1.30.7 tags as of today, including Alpine variants.
Ubuntu and Debian had not shipped fixed packages as of today. Ubuntu's CVE status page listed nginx as vulnerable on its releases from 16.04 to 26.10, and Debian's security tracker listed it as vulnerable in bookworm, trixie, forky and sid. A distribution package can carry a fix without changing the version number that nginx -v reports, so compare the full package version with the distribution's own advisory.
Xint PoC
The vendor lists workarounds for only two of the five flaws. For the resolver flaw, CVE-2026-123634, avoid SSI and mirror directives, and do not build a proxied server name from variables. For the mail proxy flaw, CVE-2026-113425, limit listeners to trusted networks.
CIRCL's response guidance lists turning off HTTP/2 as a temporary mitigation until you can upgrade. That blocks CVE-2026-123007 and CVE-2026-123633, but not the other three flaws. Turning off HTTP/3 where it is used removes the setup that CVE-2026-121810 needs.
On NGINX 1.25.1 and later, set http2 off; in each affected server block and remove http2 from its listen directives. On 1.9.5 through 1.25.0, remove http2 from the listen directive, so listen 443 ssl http2; becomes listen 443 ssl;. Then restart NGINX where needed and rerun the openssl check to confirm the server no longer accepts HTTP/2.
Until the Linux kernel's SCTP bug is fixed, the same guidance advises that hosts not using SCTP, a network transport protocol like TCP, block its kernel module from loading. One way is to add the line install sctp /bin/false to a .conf file in /etc/modprobe.d/. That does not unload a module already loaded or turn off SCTP built into the kernel.
For signs of an attack, CIRCL suggests looking for NGINX workers that start unexpected programs, workers that exit abnormally or leave core dumps, long-lived HTTP/2 connections with heavy incoming traffic but few logged requests, and unusual outbound connections or DNS lookups. A clean access log does not rule out an attack, because HTTP/2 control frames do not normally show up there as requests. None of these signs is proof on its own.
Rapid7's version of the attack needs about 128 GB of HTTP/2 traffic, according to its technical analysis. The attack took two and a half minutes in its demonstration. On links slower than about 300 Mbit/s, the transfer would run past NGINX's default one-hour connection limit, and the attack would fail.
The method also depends on a glibc memory-copy routine that is chosen on x86-64 CPUs with the avx512f and avx512vl features.
Wiz ran its tests on official NGINX 1.31.7 and 1.31.8 builds, using HTTP/2 over TLS on 64-bit systems, according to its disclosure post.
Xint's attack worked against its test servers on AWS, GCP and Azure, including over a public IP address, according to its research report.
from The Hacker News https://ift.tt/ApEXLmn
via IFTTT
Six critical vulnerabilities in F5 BIG-IP allow an attacker to crash the Traffic Management Microkernel (TMM) without logging in, disrupting traffic until the TMM restarts.
Each flaw needs a specific setup on a virtual server: an iRule that uses a particular command, or an APM policy that includes two particular kinds of agent.
F5, which makes BIG-IP, disclosed the flaws today and says they may also allow remote code execution. The company has released engineering hotfixes and lists no workaround.
The company rates all six 9.8 under CVSS v3.1 and 9.3 under CVSS v4.0. They are stack-based buffer overflows in BIG-IP's data plane, the part that processes almost all of its network traffic. The management side is not exposed, according to the company.
None of the company's advisories says the flaws have been exploited. WatchTowr researcher Sina Kheirkhah reported four, and the company found the other two itself.
Five of the flaws are in iRules, a BIG-IP feature that administrators use to manage traffic, and one is in BIG-IP's APM module. Some also affect BIG-IP Next for Kubernetes and BIG-IP CNF, part of the company's BIG-IP Cloud-Native Edition.
Each flaw needs the setup listed below on a virtual server:
CVE-2026-123637: an APM per-request policy that includes both the Client Information agent and Endpoint Security agents. Affects BIG-IP APM only.
CVE-2026-121805: an iRule that uses PEM::subscriber on client traffic. Affects BIG-IP PEM, BIG-IP Next for Kubernetes and, as of today, BIG-IP CNF.
CVE-2026-120292: an HTTP profile and an iRule that uses MR::message route. Affects BIG-IP (all modules) and BIG-IP Next for Kubernetes.
CVE-2026-120285: an HTTP profile and an iRule that uses PSC::ip_address. Affects BIG-IP (all modules), BIG-IP Next for Kubernetes and, as of today, BIG-IP CNF.
CVE-2026-116953: an iRule that uses GENERICMESSAGE::route on client traffic. Affects BIG-IP (all modules) and BIG-IP Next for Kubernetes.
CVE-2026-120722: an iRule that uses DNS::scrape on client traffic. Affects BIG-IP DNS and BIG-IP Next for Kubernetes. The company's advisory lists BIG-IP CNF as not vulnerable, but its CVE record, updated today, lists CNF as affected.
F5's security notification lists the 22 advisories it published today, including 10 for NGINX.
For the six critical flaws, the only fixes are engineering hotfixes, builds that the company issues between its normal software releases. No scheduled release is listed as a fix, and the advisories provide no workaround until a hotfix is installed.
The company warns that "engineering hotfixes do not undergo the extensive QA assessment of scheduled software releases." Its hotfix policy adds that they come with no warranty or promise that they will work.
A system on a custom engineering hotfix needs a new one from the company's support team.
BIG-IP Next for Kubernetes is fixed in BNK-2.4.2-EHF1, BNK-2.3.4-EHF1 and BNK-2.2.5-EHF1, for versions 2.4.0 to 2.4.2, 2.3.0 to 2.3.4 and 2.2.0 to 2.2.5. BIG-IP CNF, on the same version ranges, is fixed in CNF-2.4.2-EHF1, CNF-2.3.4-EHF1 and CNF-2.2.5-EHF1 for CVE-2026-121805 and CVE-2026-120285.
The company checks only versions that are still within technical support, so an older release missing from its tables has not been shown to be safe.
Today's flaws differ from CVE-2026-94127, an APM flaw that F5 disclosed on September 22 and that was later exploited. The U.S. Cybersecurity and Infrastructure Security Agency (CISA) added it to its Known Exploited Vulnerabilities catalog the same day.
That flaw is a heap-based buffer overflow in APM setups that serve as OAuth authorization servers, allowing attackers to run code without logging in. Today's six are stack-based overflows that need different settings.
Six Other BIG-IP and BIG-IQ Flaws
Today's advisories also cover six lower-rated flaws in BIG-IP and BIG-IQ, each with its own fix. The scores below are CVSS v3.1:
CVE-2026-125274 (iControl SOAP, 8.8): A user with network access and at least the Guest role can send an unauthorized management request. The company says this may allow them to run system commands, create or delete files, or disable services. It is fixed in BIG-IP 21.1.0.3, 17.5.1.10 and 17.1.3.6, and in BIG-IQ 8.4.2.3. Until then, the SOAP advisory explains how to limit iControl SOAP access to trusted networks and warns that blocking it on self-IP addresses may break high-availability setups.
CVE-2026-120718 (iControl REST, 8.1): iControl REST tokens may not expire as expected. An attacker who already holds a token may be able to extend how long it stays valid unless its owner deletes it. It is fixed in BIG-IP 21.1.0.2, 17.5.1.10, and 17.1.3.6. As a workaround, scripts that create tokens can be changed to delete them when they are no longer needed.
CVE-2026-125272 (APM, 7.5): When an APM access profile on a virtual server has a per-request policy with a form-based Logon Page, an attacker can crash TMM without logging in. It is fixed in the same engineering hotfixes as the six critical flaws.
CVE-2026-126822 (APM SAML, 7.5): When an access profile is set up as a SAML Service Provider (SP), an attacker can crash TMM without logging in. It is fixed in the same engineering hotfixes. Until then, the company suggests removing the SAML Auth agent if SAML SP is not needed, and limiting access to that virtual server to trusted client networks.
CVE-2026-126336 (APM SAML, 7.5): A SAML SP agent with encrypted assertions turned on lets an attacker crash TMM without logging in. It is fixed in BIG-IP 21.1.0.3, 17.5.1.10, and 17.1.3.6, and the company recommends a high-availability setup to reduce the impact.
CVE-2026-121812 (APM and SSL Orchestrator, 7.5): A per-request policy with the tmm.access.policytrace database key turned on lets an attacker crash TMM. The key is off by default. APM is fixed in the same engineering hotfixes, and for SSL Orchestrator the advisory lists fixes on the 21.1 and 17.1 branches only.
from The Hacker News https://ift.tt/ljZUiDw
via IFTTT
A critical security flaw in Apache Roller, an open-source, Java-based blogging platform, has come under active exploitation in the wild, according to the Apache Software Foundation (ASF)
The vulnerability, tracked as CVE-2026-129448 (CVSS score: 9.8), is a case of unauthenticated deserialization in the XML-RPC endpoint that could lead to remote code execution.
"Deserialization of Untrusted Data in Apache Roller versions 4.0.0 through 6.1.4 allows an unauthenticated remote attacker to execute arbitrary code," project maintainers said. "The XML-RPC endpoint accepts vendor extension types and deserializes them before authenticating the requester."
ASF also noted that the vulnerability is the same as CVE-2026-82384 (CVSS score: 9.8), which was patched in September 2026 and listed only Apache Roller 6.1.5 as affected.
"This issue is being actively exploited," it added. ASF did not share any details on how the vulnerability is being exploited, or who is being targeted as part of these efforts.
A security researcher named n0mi1k has been credited with finding the flaw, and Matt Raible has been acknowledged for reporting it.
Users are advised to upgrade to Apache Roller 6.1.6 or later, which disables the extension types and rejects XML-RPC requests when the XML-RPC feature is disabled.
If immediate patching is not an option, it's recommended to set "enabledForExtensions" to "false" in WEB-INF/web.xml, or remove the "/roller-services/xmlrpc" servlet mapping, and then restart Roller.
"Disabling XML-RPC in the administration UI is not enough, because older versions deserialize the request before checking that setting," ASF noted.
from The Hacker News https://ift.tt/W2q4SkT
via IFTTT
The suspected Chinese advanced persistent threat (APT) group behind the sophisticated EggStreme malware has rebuilt its toolkit as it continues to target government organizations in the Philippines.
"When attackers are exposed, the cheap response is to rotate," Bitdefender said in a technical report shared with The Hacker News. "A file hash changes with every recompile, a domain costs a few dollars, and a new IP address costs less."
"The EggStreme operators did more than rotate – the agent we now see uses a different network protocol, has an enhanced command set, and comes in a passive variant that never beacons out. The infrastructure appears to be moving away from the one certificate authority that tied its older servers together."
The end result is that the changes allow it to bypass static signatures and heuristic detections built around the EggStreme malware framework when it was first exposed in September 2025.
Delivered via an as-yet-unknown initial access vector, EggStreme's defining characteristic is the use of DLL sideloading to execute payloads. It features multiple components as follows -
EggStremeFuel (aka RawCookie), which conducts system profiling and deploys EggStremeLoader
EggStremeLoader, which sets up persistence and decrypts and executes EggStremeReflectiveLoader
EggStremeReflectiveLoader, which executes EggStremeAgent
EggStremeAgent (aka Gorem RAT), the core component and a full-featured backdoor that enables system reconnaissance, lateral movement, data theft via an injected keylogger called EggStremeKeylogger, and reverse shell and file upload/download capabilities via a secondary backdoor called EggStremeWizard
It's worth noting that some components of the framework, such as EggStremeFuel and EggStremeLoader, have been put to use by another cluster tracked by Palo Alto Networks as CL-STA-1048 between March and September 2025.
The latest findings from Bitdefender show a significant retooling of EggStreme's capabilities, including removing the keylogger from every agent build observed since then. Within two weeks after public disclosure, the threat actors are also said to have made other changes -
The method EggStremeFuel uses to protect its configuration
EggStremeLoader's cryptography and payload format, moving from RC4 to RC5 and to a custom cipher by the end of October 2025
Added commands in EggStremeAgent that facilitate Active Directory reconnaissance, Windows Management Instrumentation (WMI) querying, TCP traffic forwarding, and execution of PowerShell, Portable Executable (PE), .NET assembly payloads
Moving from a single certificate authority to campaign-specific certificate authorities
In addition, where lateral movement previously relied on Impacket-like tooling and on EggStremeAgent itself, newer incidents make use of an unmanaged system that sits outside of the organization's endpoint management but is still reachable by other workstations to stage the payloads and launch them via DLL sideloading using a Visual Basic Script (VBScript) file remotely run over Server Message Block (SMB).
Some of the newer builds have been found to run in passive mode by opening a listening port and waiting for the operator to connect in as opposed to contacting an external command-and-control (C2) server.
There is also some evidence that the attackers have also targeted Taiwan, but it has been treated with low to medium confidence.
"The speed of the loader changes says as much about the operators' maturity as about the cost of exposure," Bitdefender concluded. "The build-time design appears to be what makes rebuilds this fast. What they did not change is how they operate: sideloaded DLLs under system library names, staging through file shares, running from memory, and requiring mutual TLS."
Mustang Panda Targets Philippine Government Using ASEAN Summit Lures
As of late October 2026, Philippine government officials have also been targeted by Mustang Panda, a prolific China-aligned cyber espionage group, using ASEAN Summit lures to deliver PlugX using established tactics like DLL sideloading.
Mustang Panda attack chain
"The package impersonated a Laos–Philippines bilateral meeting agenda from the Lao Ministry of Foreign Affairs," Dream Research Labs said in a report published last week.
"It named five officials and referenced plausible diplomatic priorities, requesting that the reader provide confirmation before the summit. Behind it was a delivery chain that installed PlugX remote-access malware while displaying the decoy agenda."
Earth Alux Uses Stealthy Tradecraft to Strike Southeast Asia
The disclosure comes as a China-nexus threat actor tracked as Earth Alux (aka Ink Dragon, Jewelbug, REF7707, and UAT-11587) has been attributed to a fresh set of attacks targeting Southeast Asian government entities since at least July 2025. Palo Alto Networks Unit 42 has assigned the activity the designation TGR-STA-0049 (formerly CL-STA-0049).
"The defining signature of the threat actor behind the activity is the targeting of government entities, combined with the use of advanced custom payloads that are designed for high-stealth intelligence collection operations, with an emphasis on evading security detection tools," Unit 42 researcher Tom Fakterman said.
Attacks mounted by the group have historically deployed an advanced backdoor known as FINALDRAFT (aka Squidoor) since 2023. However, it has since expanded its malware arsenal to include two previously undocumented remote access trojans (RATs) called PerfectPioneer RAT (in July 2025) and KUKURAT (in March 2026).
Initial access to target networks is achieved via exploitation of vulnerable, unpatched Microsoft Exchange servers to deploy web shells like ASPXSpy and Godzilla, which are then used to deploy the RAT payloads. Alternatively, Earth Alux has leveraged phishing emails using decoy PDFs and lookalike domains to compromise victim hosts.
PerfectPioneer RAT is a Go-based malware that's launched via three different methods -
DLL sideloading to launch a malicious DLL that reads, decrypts and executes XOR-encrypted shellcode containing the RAT
Decoy installers for Palo Alto Networks GlobalProtect that installs the legitimate program but also writes the malware to disk and executes it in the background
Disguising executable files as PDF documents in phishing emails that, once launched, opens a decoy PDF document while the malware is launched in the background
The malware supports a number of features that enable the operator to gain remote control of the infected host. It facilitates file operations, shell execution, process management, keylogging, SOCKS5 proxy, screenshot capture, Window enumeration and manipulation, and CPU and memory utilization monitoring.
PerfectPioneer RAT execution chain
It also ensures a connection to the C2 server remains active at all times and systematically cleans up temporary files and runs garbage collection if memory usage exceeds 100 MB to minimize forensic traces.
Furthermore, select variants of the malware come with an "isDangerousCommand" feature to avoid running administrative commands that would be highly destructive or noisy, thereby allowing it to be detected by security programs installed on the host. These include rm, curl | bash, wget | bash, and powershell -e, among others.
KUKURAT, in contrast, functions as a modular implant that's executed in networks already compromised by PerfectPioneer RAT. Written in C++, the backdoor implements its functionality as a separate DLL module that's loaded dynamically at runtime directly from the C2 server.
This allows the malware to be highly evasive and adapt its capabilities on the fly in response to shifting operational objectives. It supports the following features -
Send system information and receive a configuration from the C2 server
Take screenshots
Log keystrokes
Enumerate and terminate processes
Perform file operations
Execute shell commands via cmd.exe and PowerShell
Conduct lateral movement via PsExec
Carry out SMB credential brute-forcing
Run Beacon Object Files (BOF)
Facilitate local privilege elevation
Ensure the malware remains active by means of a standalone watchdog executable
What's more, KUKURAT initiates bogus, legitimate-looking activity on the endpoint to camouflage and cover up its tracks based on a command issued by the threat actor. This includes -
Generate 10 decoy HTTP requests per operational cycle to randomly selected domains that are extracted from a hard-coded list of 15 popular websites using randomly generated URL paths with an aim to blend C2 communications
Mimic legitimate Google Chrome browser behavior by writing random data to the registry path HKCU\Software\Google\Chrome\BrowserCrashRecovery, reading the data back, and deleting the key
Create temporary files with random names and randomized content inside the system %temp% directory, and delete them
"Both PerfectPioneer RAT and KUKURAT use HTTP/3 as the primary method for communicating with C2 infrastructure," Unit 42 said. "While the adoption of HTTP/3 is rare across the broader malware landscape, its deployment in this campaign reflects an emerging trend among advanced threat actors."
The attacks have also been found to leverage established tools like PsExec, WMI, and Windows Remote Management (WinRM) to move laterally across compromised enterprise networks; collect credentials using Mimikatz, ProcDump, and SharpDPAPI; compromise Domain Controllers to deploy KUKURAT on local endpoints; and exfiltrate sensitive data such as files and emails.
"Through the deployment of KUKURAT and the PerfectPioneer RAT, the attackers behind this activity are actively evolving to stay ahead of traditional network defenses by implementing protocol-level evasion via HTTP/3 and QUIC over UDP," Unit 42 concluded.
"What makes this group particularly evasive is the extensive effort invested in maintaining operational security and remaining hidden on compromised endpoints. The group demonstrates a mature understanding of modern defensive ecosystems. They have even gone so far as to embed hard-coded administrative safety switches within their binaries to prevent their own operators from running loud or destructive commands that might trigger security alerts."
from The Hacker News https://ift.tt/nMXZ5e8
via IFTTT
The security problem changes once an AI agent can do more than answer a prompt. It can execute code, access files, connect to services, and call external tools. That creates a new security question for enterprises: how do you give an agent enough freedom to be useful without giving it more access than it actually needs?
A model decision is not automatically an authorized action. That distinction becomes important the moment an agent can turn a model output into an action in a real system.
The answer can’t rely only on the model. Agent behavior can vary, while security controls need to be clear and enforceable. That means putting controls around the environment where the agent runs, what it can access, which tools it can use, and what happens when a policy allows or blocks an action. For a CISO, this creates a trust gap. Approving the use of AI agents means being able to answer more than whether the model is capable: what access does the agent have, where are those boundaries enforced, and what evidence is available afterward? The goal is to let teams adopt agents without making model behavior itself the security boundary.
Docker AI Governance approaches this through three areas: Sandbox Policies, MCP Tool Governance, and Audit + Visibility.
Together, they address three practical questions security teams need answered: Where can the agent operate? What can it do? And can we see what happened?
In this article, I use “trust layer” as shorthand for the infrastructure between what an agent wants to do and what the organization actually allows it to do.
There is a related trust question too: what software artifacts are these agentic workflows building and using? Docker Hardened Images address that software supply-chain side of the problem, alongside the runtime controls discussed below.
Figure 1: The three layers of Docker AI Governance: Sandbox Policies, MCP Tool Governance, and Audit + Visibility.
Sandbox Policies: Where Can the Agent Operate?
An agent needs enough access to get real work done. A coding agent may need to install packages, build containers, edit project files, or connect to external services. The security challenge is deciding where those actions are allowed before the agent starts taking them.
Docker Sandboxes give each agent an isolated microVM environment a lightweight virtual machine with its own Docker Engine, filesystem, and network. Docker AI Governance adds policy around that environment so security teams can control network and filesystem access centrally.
Network policies can allow or block specific domains, IP ranges, and ports. Filesystem policies control which host paths can be mounted into a sandbox and whether that access is read-only or read-write. These controls are enforced at the network proxy and filesystem mount layers rather than depending on the agent to follow an instruction.
For an organization, that means the same boundaries can follow developers across their sandboxes instead of being configured differently on every machine. Teams still get the access they need for their work, but an individual agent cannot simply expand those boundaries on its own.
A developer can check the effective boundary before starting the agent:
The important part is that the result comes from the active policy, not from an instruction the agent is expected to follow.
This answers the first governance question: Where can the agent operate?
MCP Tool Governance: What Can the Agent Do?
Once an agent has a controlled place to run, the next question is what it should be allowed to do through external tools.
MCP (Model Context Protocol) gives agents a common way to connect to external tools, services, and capabilities, but that also expands what an agent can act on. For enterprise use, making a tool available should not automatically mean every agent can use it.
Docker AI Governance puts policy around MCP activity handled through Docker’s MCP Gateway. Administrators can control which MCP servers may be registered and what agents can do through them, including tool calls, resources, prompts, and approval requirements. These organization policies are written in Cedar, a policy language used to express authorization rules. When MCP policy enforcement is active, governed requests are denied unless a matching policy permits them. For example, a policy can permit read-only tool calls for a specific registered MCP server:
permit (principal, action == MCP::Action::"invokeTool", resource)
when {
resource in MCP::Server::"example" &&
resource.readOnly == true
};
Here, readOnly comes from the MCP tool’s annotations. Those annotations are supplied by the server and are advisory, so this example relies on metadata provided by that server.
This makes tool access an explicit policy decision rather than something left to each agent or developer to configure independently. A team can be given access to the tools it needs, while other servers or actions remain unavailable. Policies can also require confirmation for specific tool calls when an action needs an additional checkpoint.
One boundary is worth making clear: MCP policies apply to activity handled by Docker’s MCP Gateway. If an agent connects directly to a remote MCP server from inside a sandbox, that connection falls under the sandbox’s network policy instead.
With the environment constrained and tool access governed, we can answer the second question: What can the agent do?
Audit + Visibility: Can We See What Happened?
Setting a policy is only part of the job. Security teams also need to know when that policy was applied, what action triggered it, and whether the action was allowed or denied.
Docker AI Governance records sandbox policy decisions and sandbox session events as structured audit records. Each record captures details such as the principal, action, target, decision, and time. The records contain governance metadata rather than the contents of prompts or agent responses.
Audit records can be kept locally or delivered to the cloud. With cloud delivery enabled, teams can search the organization-wide record, export it for further analysis, or forward events into existing SIEM (security information and event management) workflows.
Denied actions are especially useful. A team can see not only that an action failed, but that a governance rule blocked it and why. Allowed decisions matter too: they provide a record of how policy was applied while the agent was working.
Current audit coverage includes Docker Sandboxes policy decisions and sandbox session events. The same schema can support additional Docker AI sources as they become available.
That closes the third part of the governance loop: Can we see what happened?
A Trusted Software Supply Chain: Docker Hardened Images
AI Governance controls access around the agent at runtime. There is a separate question that matters to the workflows those agents participate in: what container images and software artifacts are they building, testing, or deploying?
Docker Hardened Images provide minimal, secure, and production-ready container images, Helm charts, and system packages maintained by Docker.
In practical terms, this gives teams evidence about what is inside an image and how that image was produced. Docker Hardened Images include signed SBOMs, VEX information, cryptographic signatures, and SLSA Build Level 3 provenance. Instead of simply trusting where an image came from, teams can inspect what is inside it and verify information about how it was built.
For organizations with additional compliance requirements, Docker also provides FIPS-enabled and STIG-ready variants through relevant DHI offerings. These capabilities sit alongside the broader DHI security and supply-chain controls rather than making any single standard the foundation by itself.
AI Governance and Docker Hardened Images solve different parts of the trust problem. Governance controls the authority an agent has while it works; DHI helps establish trust in the container artifacts that the workflow depends on.
Figure 2: Docker Hardened Images combine minimal container images with signed supply-chain metadata and verifiable build provenance.
Putting the Three Layers Together
Consider a developer using a coding agent to investigate an issue, update a service, and use an approved internal tool along the way.
The agent begins inside a Docker Sandbox. It can work with the project and run the commands needed for the task, but its access is still bounded by policy. If it tries to reach a network destination or mount a host path that the organization has not allowed, the applicable sandbox policy can block that access.
Now suppose the agent needs an MCP tool to look up information from another service. The request goes through Docker’s MCP Gateway, where organization policy determines whether that server and tool are permitted. A routine lookup might be allowed, while a more sensitive tool call could require confirmation or remain unavailable altogether.
For governance activity currently covered by AI Governance Audit Logs, Docker records the policy decision and relevant session metadata. Security teams can see who initiated the activity, what policy-controlled action was evaluated, and whether it was allowed or denied. Those records can then feed the organization’s existing monitoring and SIEM workflow.
If that same agent builds or tests a containerized application, the software entering the workflow matters too. Docker Hardened Images provide a more verifiable software foundation for that workflow, while AI Governance controls what the agent is authorized to do at runtime.
The model is still making decisions about how to complete the task. What changes is the authority around those decisions. The agent can work autonomously inside the boundaries the organization has defined, while access outside those boundaries remains a policy decision.
That is the practical value of the three layers working together:
Sandbox Policies define where the agent can operate.
MCP Tool Governance defines what tools it can use.
Audit + Visibility shows how governed activity was handled.
Taken together, the pattern is straightforward: define the boundary, check it before the agent starts working, enforce it while the agent is running, and use the resulting audit trail to understand what happened. If a boundary needs to change, the policy changes, not the expectation that the model will simply behave differently.
Autonomy Without Unbounded Authority
The challenge with agentic AI is not simply that agents can make decisions. It is that those decisions can now lead directly to actions.
That makes the boundary around the agent just as important as the model itself. Docker AI Governance addresses that boundary through Sandbox Policies, MCP Tool Governance, and Audit + Visibility: controlling where agents can operate, what tools they can use, and how governed activity is recorded.
Docker Hardened Images address a related supply-chain concern by helping teams work with smaller, verifiable container artifacts.
The goal is not to remove autonomy from agents. It is to make sure autonomy does not automatically come with unlimited authority.
As agents take on more real work, that distinction will matter more and more.
On AMD-based PCs and some Intel PCs, the TPM lockout for Windows Hello and BitLocker PINs can be reset by someone who opens the PC's case, researchers at Technische Universität Berlin say.
That leaves short PINs open to guessing. In lab tests, the researchers found a four-digit Hello PIN on an AMD laptop and a 6-digit BitLocker PIN on an Intel laptop this way.
Both PINs were set by the researchers and found within 236 tries. From the speeds they measured, they calculate a worst-case of 40 hours for a four-digit Hello PIN, compared to 69 days with the lockout working as documented. For a default six-digit BitLocker PIN, the worst-case time drops from 19 years to 20 days.
AMD confirmed yesterday that its processor firmware has a flaw that allows the attack on some PCs with its chips. It plans fixes for most of those chips between November and February 2027. For now, the researchers advise adding at least two digits to Hello and BitLocker PINs.
The TPM in these PCs is a firmware TPM, built into the processor. Unlike a separate TPM chip, it has no secure storage of its own, according to the research paper the researchers posted late last week. So it keeps its saved state, including the count of wrong guesses, encrypted on the mainboard's flash chip.
If someone copies that saved state and later writes the old copy back, the count goes back too, unless the PC detects it. Newer PCs try to catch this with counters inside the flash chip, called RPMC, that can only go up.
On AMD PCs that use these counters, the processor's firmware never verifies that a counter actually increased. A small board placed between the processor and the flash chip can block the update and report success, causing the PC to accept the old state.
RPMC chips from flash maker Winbond have a different weakness, the researchers found. A brief drop in the chip's power supply, called a voltage glitch, can cause the chip to reveal the secret key that signs its counter values. With that key, which took about a second to extract with their best settings, the board can forge any counter value.
On the Intel laptop they tested, one glitch was enough: the laptop's firmware feeds the chip the same value at every boot, so the leaked key kept working after each restart.
For the Hello test, the researchers attacked a locked HP OmniBook 3 with an AMD Ryzen AI 5 330 processor and a BitLocker-encrypted drive. Their setup typed PINs from 1000 upward and reached the correct one, 1235, after 236 tries in 57 minutes.
Windows still forced a restart after every 5 incorrect PIN attempts on that laptop, but no lockout delay was applied. Microsoft's lockout defaults lock the TPM after 32 wrong tries and forget one failure every 10 minutes.
The BitLocker test ran on a Framework Laptop 13 with an Intel Core Ultra 5 125H processor and Winbond flash. BitLocker's startup prompt adds no limit of its own, so each reset gave a fresh 32 tries. The setup found the PIN, 123457, after 236 tries in 6 minutes and 55 seconds.
In both tests, the researchers took the flash chip off the mainboard and wired in their own board. A script read the screen, typed PINs, and restarted the laptop through a KVM switch. They also changed firmware settings to slow each laptop's link to the flash chip, because their board could not keep up at full speed.
The researchers make two further claims that their tests did not cover. Either method could be used against either PIN. A recovered Hello PIN can also unlock keys tied to the device and enable Hello-based single sign-on at work, and, in some configurations, pass a multi-factor check.
The researchers have published their attack firmware, board designs, and scripts. They say reproducing the RPMC attacks is not plug-and-play and needs one of their boards. Neither the paper nor the vendor notices published so far describe attacks outside the lab.
Which PCs the Attack Works On and What Vendors Say
Whether the attack works depends on the processor and the flash chip:
AMD-based PCs with RPMC flash: open to the board that blocks counter updates. The chipmaker has confirmed the firmware flaw behind this and plans to fix it.
AMD-based PCs without RPMC flash: on two AMD desktops in the researchers' tests, writing an old copy back with an ordinary flash programmer reset the count, requiring no board. They conclude that AMD processors likely have no other protection against this, though two desktops may not be representative of all AMD systems.
PCs that rely on Winbond RPMC flash: the researchers say these are open to the leaked-key method whatever the processor, and that only a new chip design can fix it.
Intel PCs without RPMC-like flash: three Intel systems detected the same write-back in those tests.
The researchers expect the AMD firmware flaw to affect AMD PCs that use the Microsoft Pluton security core as their TPM, but did not show this.
On an AMD PC, the owner can boot Linux, for example from a live USB stick, and run the command grep . /sys/bus/pci/drivers/ccp/*/rpmc_* from the researchers' exposure check. The output indicates whether RPMC flash is present and enabled, which tells the owner which of the two methods applies. Missing files do not mean the PC lacks RPMC.
For Intel PCs, the researchers know of no such check. Owners would have to open the PC and look for a Winbond chip marked 25R or 74M.
AMD tracks the flaw as CVE-2026-43613 and assigns it a CVSS score of 5.1 in a security bulletin published yesterday.
The chipmaker says attacks requiring physical access fall outside its product security threat model, but that "RPMC is intended to stop this type of interposer attack." The researchers first told it about the flaw in February.
The chipmaker's fix targets run from November to February 2027 across Ryzen, Ryzen AI, Ryzen Threadripper, Athlon and EPYC chips, and one unnamed product has no date yet. These are planned dates for its own firmware, not updates already out for PCs.
The bulletin does not cover AMD PCs without RPMC flash. It also does not say whether the update will prevent an attacker from installing older, unfixed firmware on the PC, which the researchers say a fix must prevent.
Intel, whose processor was in the BitLocker test laptop, said in a security announcement earlier this week that the research "did not demonstrate a vulnerability in an Intel component". That matches the tests, in which the attack on the Intel laptop needed the Winbond chip's flaw.
According to the researchers, Intel's security team called the reused value a weakness rather than a vulnerability.
The researchers told Microsoft in April. According to them, the company rated the Windows Hello report as "moderate severity" and below its bar for an immediate fix, issued no CVE or bounty, and committed to raising its recommended minimum Hello PIN length to six digits.
At the company's request, the researchers filed the BitLocker finding as a separate report for a different team. The company declined to give them any further written statement for the paper.
Separately, a Windows 11 test build released late last week makes six digits the minimum for personal-account Hello PINs, with an option to use four. The release notes give no reason, and features in that test channel may never reach regular releases.
According to the researchers, Winbond was first told about its chips' weakness to voltage glitches in January 2025 and received a second report in April showing that a glitch also leaks the key. The flash maker is studying the issue, possibly including a new chip design, but has not committed to a fix or a date.
What Owners and Admins Can Do
Two extra digits make a large difference in the researchers' figures:
Worst-case time to find a numeric PIN
PIN length
With the documented lockout
Hello attack (AMD laptop)
BitLocker attack (Intel laptop)
4 digits
69 days
40 hours
5 hours*
6 digits
19 years
168 days
20 days
8 digits
1,903 years
46 years
6 years
* BitLocker accepts a four-digit PIN only if an admin lowers the six-digit minimum. The times are worst cases calculated from speeds measured on one laptop each.
In May, Microsoft advised moving BitLocker from TPM-only to TPM+PIN to block the YellowKey bypass, as part of its YellowKey mitigation. The same TPM lockout guards that PIN.
Steps for each setup:
Windows Hello for Business: raise the Minimum PIN length policy, under Computer Configuration > Administrative Templates > System > PIN Complexity. If it is not set, Windows requires six digits, a worst case of 168 days in the table above, and admins can set it as low as four. The PIN policy settings page lists it on the PIN settings tab.
BitLocker: raise the Configure minimum PIN length for startup policy, which allows 4 to 20 digits and requires six by default. Turning on "Allow enhanced PINs for startup" lets letters and symbols, which the BitLocker PIN guidance recommends for older hardware.
AMD-based PCs: install the firmware update with the chipmaker's fix when one is available for your PC. Until then, the chipmaker advises keeping PCs under physical control and watching for signs of tampering.
PCs that rely on Winbond RPMC flash: the flash maker has not committed to a fix, according to the researchers. Intel advises its customers to ask their PC maker about updates.
from The Hacker News https://ift.tt/5YNVzfg
via IFTTT
Attackers move first. On average, exploitation now starts before a patch exists (Mandiant M-Trends 2026). In 1H 2026, 23% of vulnerabilities VulnCheck added to its exploited list were hit on or before disclosure day.
AI pentesting vendors aren't interchangeable. Most look convincing in a demo. The gaps show up in your logged-in flows, your coverage, and your production safety.
Make them prove it on your own web apps. Score each vendor on context, reach, validated findings, guardrails, and retests.
Choosing an AI pentesting vendor? Get 15 questions, red flags, and a scorecard to test what vendors deliver, not just what they demo. Download the free checklist →
AI is speeding attackers up
For the first time, Google's Threat Intelligence Group identified a threat actor using a zero-day exploit it believes was developed with AI: a 2FA bypass rooted in a logic flaw that conventional fuzzing and static analysis can easily miss (GTIG).
Agentic pentesting can close that gap, and 87% of US security leaders surveyed are planning, piloting, or using it. Choosing the agent is the hard part.
Every Demo Looks Good. Your App Is the Real Test.
Picture three agents that all demo well. The first finds real flaws but stops at your login page. The second navigates your app but can't answer a basic question: coverage of what? The third exploits real issues but has no hard limits for production.
Each looks impressive on the vendor's target. The difference shows up on yours. A structured bake-off surfaces it before you sign.
Ask What the Agent Knows Before It Attacks
Every tester has to learn your site before the first payload. That recon is real attack work. The cost is redoing it from scratch on every engagement, when most of the map hasn't changed. In CyCognito's model, recon and analysis take 20 to 30 of a manual pentest's 63 to 95 hours.
Agents differ here. Some start from a blank URL and rebuild the map on every run. Others start from an existing model of your site and keep it current between runs. Ask which one you're buying, what carries over between runs, and whether the agent keeps discovering beyond its starting map. A starting map should be a head start, not a boundary.
Without context, an AI agent behaves like a smart scanner. With context, it can reason about your application. That changes what it finds, not just how fast. When a security researcher hunted for flaws in Apache Airflow, their AI assistant called the search a dead end. Testing how the deployment’s parts trust each other, instead of reading the code, turned up an unauthenticated RCE (CVE-2026-68982).
Ask for Proof, Not Suspicion
A suspicious pattern is not an exploitable vulnerability. Ask whether the agent exploits what it suspects, reproduces its findings, and hands over evidence your team can verify. A list of suspected issues is not a validated pentest.
Here is what proof looks like. During an authorized assessment of a major insurer's production website, an AI pentesting agent found that the one-time passcode request could send login codes to any email address. It proved the flaw by logging in with a code sent to its own inbox, and guardrails then stopped the test. The insurer said it had pentested the site about six months earlier (Reflectiz case study on The Hacker News).
Three Questions That Expose a Weak AI Pentesting Vendor
A demo can look convincing without proving that the agent reaches your logged-in workflows, validates what it finds, or confirms your fixes. Here are three of the 15 checks to run before you choose.
The other 12, covering starting context, coverage proof, attack chaining, access across roles, data handling, and guardrails, are in the full checklist.
Run a Bake-Off, Not a Demo
Demos run on the vendor's target. Bake-offs run on yours.
Same target, same week. Same app, test accounts, and scope for every vendor.
Log three timestamps. Access granted, discovery complete, first test.
Score every check. The checklist's scoring sheet weights what matters and gates on safety.
What's Inside the Checklist
15 checks, each with the question to ask and the red flag
Checks for attack chaining, roles, guardrails, and retesting
A 36-point scorecard and a per-check scoring sheet
The best AI pentesting agent isn't the one with the best demo. It's the one that can show what it tested, prove what it found, and run safely on your application. Use these 15 questions to find it.
Found this article interesting? This article is a contributed piece from one of our valued partners. Follow us on Google News, Twitter and LinkedIn to read more exclusive content we post.
from The Hacker News https://ift.tt/XoqP4tK
via IFTTT
AI is speeding up how software is built, which means more code, more changes, and more chances for vulnerabilities to reach production. It's speeding up how attackers find and exploit them too, with time-to-exploit now down to a single day. Security testing has to keep up with both.
AI pentesting has emerged as a way to run in-depth tests whenever teams need them, instead of waiting for the next scheduled pentest. To see how far adoption has come and what security teams need from it, Intruder surveyed 500 security and engineering leaders across the US and UK. Read on for the top findings.
Only 4% of security leaders believe their current testing frequency gives them sufficient coverage
68% of organizations deploy code to production at least daily, and 37% deploy multiple times a day. Understandably, pentesting runs on a much slower cycle. Nearly half (47%) go more than a month between full pentests on their web applications and APIs. Those figures are for each organization's most frequently tested application, so the rest of their estate is tested less often still.
Running a human-led pentest as often as code ships has never been realistic, largely because of the cost. But it means a vulnerability introduced in one release can go weeks or months without a pentest, and only 4% of security leaders believe their current testing frequency gives them sufficient coverage.
42% say they accept the risk and ship code without additional security checks between pentests
Most teams cover the gap between pentests with a mix of approaches, but 42% accept the risk and ship code without additional security checks in between. Automated scanning in the build pipeline, more frequent manual pentests, internal AppSec teams, and AI-driven pentesting are each used by around half.
Concern about the gap is widespread. 88% of leaders running scheduled pentests are worried about unmapped risk introduced between tests, and they split almost evenly on how serious it is. Half call it one of their largest unmanaged cyber risks, while the other half describe it as a known gap they're covering with basic perimeter controls.
Fewer than 1% have no plans to try AI pentesting
55% of organizations already use AI pentesting across their environment, a further 36% have tried it but not yet adopted it at scale, and fewer than 1% have no plans to try it. For a category that has only emerged in the past two years, that's fast uptake.
The largest organizations surveyed (5,000 to 10,000 employees) are furthest along, with 71% using AI pentesting across their environment. Midmarket organizations have tried it at a similar rate but scaled it less so far, at 54%.
Only a quarter see AI testing quality as a top concern
Security leaders need confidence that AI pentesting is safe to run on sensitive systems, and a way to check its work. The quality of AI pentesting isn't the main concern, with only a quarter naming it as one of their biggest barriers to adoption. The top barriers relate to how AI tools operate inside sensitive environments: data privacy (40%), safety on production systems (36%), and whether auditors and regulators will accept AI pentest reports (28%).
Asked what would most damage their trust in AI pentesting, nearly half (46%) point to a lack of visibility into what was tested (25%) or a lack of reproducible proof of exploitability (21%).
DevSecOps leads, who work most directly with the findings security tools produce, are the most skeptical — only 5% say nothing would damage their trust, compared with 19% of CTOs.
56% of teams spend six or more hours a week triaging false positives
More than half of teams (56%) spend six hours or more a week validating findings from their security tooling. Working out whether a finding is real is the biggest remediation bottleneck, named by 44% of leaders, and one in five teams spend 11 hours or more a week on it, more than a full working day.
Confirming fixes takes time too. Fewer than two in five organizations independently retest a fix in production as soon as it ships, and nearly half take up to two weeks. Until then, there's no way to know the vulnerability has actually been closed.
This is the work AI-enabled validation is designed to cut, by confirming findings are exploitable before they reach the team and retesting a fix as soon as it ships.
90% agree the traditional annual pentest is dead
Nine in ten security and engineering leaders agree that the traditional annual pentest is dead and that continuous AI pentesting is now required to keep pace. For most, it already is. Only 6% still rely on a single annual pentest.
Looking three to five years ahead, most (54%) expect AI to handle the bulk of testing, and only one in six expect manual pentests to remain a primary method of security validation. 28% expect to keep manual pentests mainly to satisfy auditors, regardless of their technical value.
What this means for security teams
Until now, teams have relied on two kinds of testing, each with a trade-off. Scanning and DAST run often but are generic by design, so they miss flaws specific to how an application works. A pentest goes deep, but it's a snapshot of how the application looked weeks or months ago. AI pentesting brings the depth of a pentest, on demand.
That changes what's possible across the testing cycle. Releases can be tested as they ship, instead of waiting for the next scheduled pentest. With findings validated before they're reported, teams spend their time on issues that are real, and fixes can be retested straight away.
For teams looking to adopt it with confidence, a few steps help. Start in a staging environment that mirrors production. Run an AI pentest alongside your next manual pentest and compare the results. Look for findings that come with proof-of-concept code and a record of what was tested. And check how your code and data will be handled before you give it access.
With AI speeding up how software is built and how it's attacked, AI pentesting makes it possible to keep pace with both. Get the full report or learn more about Intruder’s AI pentesting.
Found this article interesting? This article is a contributed piece from one of our valued partners. Follow us on Google News, Twitter and LinkedIn to read more exclusive content we post.
from The Hacker News https://ift.tt/3oT8PeM
via IFTTT
Cisco Talos discovered malicious infrastructure associated with a financially motivated threat group we are tracking as UAT-12643.
The actor’s arsenal has several payloads including the Go-based Overlord remote access trojan (RAT), a Python-based infostealer internally labelled “Good Game,” and a multi-cryptocurrency clipboard hijacker.
The threat actor is likely operating a campaign targeting cryptocurrency holders, gaming platform account owners, and VoIP software users based on the lure file names of the initial vectors and the payloads.
The Overlord RAT implements a command-and-control (C2) resilience technique in which encrypted server URLs are embedded in Solana blockchain transaction memos.
Victimology
The threat actor is potentially targeting victims in Europe, according to the payload’s keyword-based file harvesting capability, which specifically targeted documents that had file names in English, French, Spanish, and Portuguese.
Based on the lure themes and payload file names, the potential victim pool spans across multiple verticals. A lure financial statement decoy PDF — launched when the Good Game stealer is executed — indicates targeting finance and accounting staff. The Viber trojanized installer lure targets messaging platform users, while additional payload variants of files named microsip indicate targeting VoIP softphone operators, consistent with call-center or business telephone environments. Cryptocurrency and gaming users are also targeted by both the clipboard hijacker and the infostealer.
Potential links to North Korea-aligned actors
Talos assesses with low confidence that UAT-12643 is a North Korea-aligned advanced persistent threat (APT) actor based on overlaps in tactics, techniques, and procedures (TTPs) with those of the other known North Korean APT actors.
In the current campaign, Talos observed that the actor is using the Overlord RAT as one of their payloads. The threat cluster called UNK_DeadDrop, likely a North Korean threat actor, had employed the Overlord RAT in their earlier campaigns as reported by the security researchers in June 2026.
The Overlord RAT variant observed in this campaign implements a blockchain C2 resilience technique with Solana blockchain transactions. This technique was first reported in March 2026, employed by the Lazarus APT group. Although the implementation methodology differs (earlier, it was through Node.js), the technique of leveraging Solana transaction memo stayed consistent.
Talos is aware that Overlord RAT and Solana blockchain hosting technique is also leveraged by other threat actors in their campaigns, as reported by external security researchers in October 2026.
Threat actor infrastructure
Talos observed that the actor hosted the malicious files on a server with IP address “41[.]216[.]188[.]11”, running a Flask-based file delivery service on port 8000 with resumable byte-range download support, and serving the payload staging directory. Due to the actor’s operational security failure, the server’s root folder was exposed to the internet, and Talos’ analysis of the exposed folder showed us actor’s tool sets, and the port numbers configured on the C2 server for different services.
Portnumber
Service
Payload file name
8000
Flask file-drop (HTTP)
Payload.exe, MyApp2.exe, HTA files
5173
Overlord RAT WebSocket C2
Ovl.exe, Client.exe
5656
Python stealer TCP C2
Ova.exe, MyApp2.exe
5959
Python stealer TCP C2
Microsip-config.exe, microsip-config1.exe
The actor does not use the traditional data exfiltration approach of transferring the data to the C2 server; instead, the stolen data is exfiltrated using two different services. The actor used the discord webhook, which receives an immediate notification that contains a victim’s fingerprint and a single click download link. The stolen data archive is uploaded to “gofile[.]io” and is later accessed by the actor through the download link.
We also observed the actor’s LNK generation script among the samples of the staging directory, indicating the actor’s lure creation workflow. The script accepts a payload URL and icon type (PDF, Word, or Windows Update) and generates a COM-based LNK with the spoofed and hidden execution.
Figure 1. Sample Windows shortcut generation script.
Initial access vectors
Talos observed that the actor uses three different methods to gain initial access to victims’ environments. They have instrumented Windows shortcuts, HTA files, and XML files, so the embedded malicious instructions execute and grant initial access. In this campaign, we have not observed how the actor delivers these malicious initial vector files to victims’ machines.
Weaponized LNK
One of the initial access vectors is the usage of the weaponized LNK files paired with the icons spoofed from legitimate system binaries to appear as a legitimate file in the Windows Explorer.
The shortcut file impersonates a PDF using the standard Windows document icon and abuses MpCmdRun.exe, Windows Defender's command line utility and the argument -DownloadFile to get the payload. Since MpCmdRun.exe is a signed Microsoft binary, the download passes application allowlisting controls transparently. The downloaded payload will be saved as RuntimeBroker.exe to blend into process inventories, and the console window is minimized with no visible trace.
Figure 2. Embedded command line in a sample LNK.
Another shortcut file applies the same PDF disguise through a double-extension file name and the Microsoft Edge PDF icon and uses certutil -urlcache –f, a one-liner download command that operates under the guise of a certificate cache update. Both shortcuts were built on the same machine (win-8oa3ccqae4d).
Figure 3. Embedded command line in a sample LNK.
HTA dropper
Talos observed that the actor has weaponized the JavaScript HTML Application (HTA) file to gain initial access. The weaponized HTA is executed by mshta.exe and the JavaScript in the HTA uses “MSXML2.ServerXMLHTTP” to fetch the payload as raw binary and “ADODB.Stream” to write it to %TEMP%\s.exe, then executes it stealthily by hiding the execution window.
Figure 4. Sample HTA file.
MSBuild living-off-the-land binary (LOLBin)
The actor has also weaponized a standard MSBuild XML project file “dl.xml” by including an inline C# CodeTaskFactory task. When the XML file is executed via msbuild.exe, it compiles and executes the C# code in memory, and no intermediate executable is written to disk for the downloader stage. The download uses a spoofed Microsoft BITS/7.8 User-Agent string, impersonating the Windows Background Intelligent Transfer Service (BITS) used by Windows Update, Microsoft Defender and many third-party updaters, so the request blends in with routine background download traffic.
Figure 5. Sample malicious MSBuild project XML file.
Analysis of Overlord RAT
The Overlord RAT variant utilized by UAT-12643 in this campaign is a modular Windows RAT compiled from Go source code.
The defense evasion and anti-analysis techniques implemented include the detection of in-memory execution to suppress forensic artifacts when running in sandboxes and a “kill flag” mechanism that triggers a kernel-level Blue Screen of Death (BSoD), making the process effectively unremovable without triggering a full system crash.
The RAT first verifies that the current process is running with administrative privilege. It then acquires SeDebugPrivilege for the current process. With that privilege held, it calls a native NT kernel API (NtSetInformationProcess) directly, bypassing the documented Win32 API layer entirely, to set the ProcessBreakOnTermination information class on the current process handle to value 1, which indicates the kernel will handle the process as critical to system operation. With these settings, the operating system treats the process the same way as the core Windows system processes. When a user or a security tool attempt to forcibly terminate the process, the kernel does not allow it to exit cleanly. Instead, it immediately halts the entire operating system and triggers a BSoD with the stop code CRITICAL_PROCESS_DIED.
Figure 6. Snippet of Overlord RAT function that triggers BSoD.
For persistence, the RAT employs two approaches. The primary approach is through a registry autorun entry under the current user's hive, with a randomized value name pointing to the RAT binary located in the Network folder of the local user profile application data folder. The secondary approach is a pre-boot persistence via the Windows Recovery Environment OEM script path. It first removes any previous version of itself and then sets up the OEM environment directly under %TARGETOSDRIVE%\Recovery\OEM\. This folder is the location that the Windows Recovery Environment accesses when performing a "Reset this PC" operation. By placing files here, anything registered in this directory gets executed inside WinRE before the operating system is restored.
Once the directory is set, the RAT generates a random 20-character file name for its payload file. Each character is picked individually at random from a fixed character set, meaning every installation produces a uniquely named file. With a random name chosen, it writes the RAT's own executable binary into the OEM directory as that payload file. It then constructs the shell command that WinRE will use to launch the payload and wraps it into Windows batch script with the .bat extension.
The use of %TARGETOSDRIVE% is significant, as this environment variable only exists and resolves correctly inside the WinRE pre-boot environment, not in normal Windows. This means the command is specifically crafted to work at recovery time, not during a regular session.
Before modifying any system configuration, it backs up the existing WinRE reset configuration file. Finally, it modifies the ResetConfig.xml file that governs what WinRE does during a reset. If no config file exists yet, it creates one from scratch; if one already exists, it patches it to append the malicious batch scripts as registered OEM tasks. From this point forward, whenever the victim triggers "Reset this PC" whether from within Windows Settings or from the recovery boot menu, Windows Recovery Environment will execute the RAT's payload before restoring the operating system, ensuring the implant survives a full system reset.
Figure 7. Snippet of Overlord RAT function configuring the malicious script in WinRE location.
Analysis of the RAT’s binary showed a complete command surface with 35 commands, each corresponding to a distinct capability delivered over the C2 channel. These commands belong to several remote administration capability categories as described in the table below:
Category
Capabilities
Surveillance
Captures keystroke using GetAsyncKeyState, Webcam streaming, microphone and desktop audio capture and desktop screen capture.
File system
Directory listing and creation, file read, write, delete, copy, move, perform recursive search, upload, download, and compression tasks.
Process control
Process enumeration and termination.
Script execution
Execute arbitrary command and script with real-time console output streaming back to C2.
Lateral Movement
Establishes Reverse SOCKS proxy tunnel that routes operator TCP traffic through the victim network, enabling access to internal hosts unreachable from the public internet.
Plugin delivery
HTTP-based plugin downloads with reflective DLL injection at runtime where new capabilities are loaded entirely in memory with no binary update or written to the disk.
Overlord’s Solana blockchain C2 URL hosting
The RAT implements a resilient C2 server discovery mechanism by using the Solana blockchain. The actor embeds encrypted C2 URLs into the Solana blockchain using the Solana Memo Program, a native Solana program that validates and permanently records arbitrary text strings in the blockchain ledger as part of a transaction. Any Solana wallet can include a memo instruction in a transaction of up to 566 bytes of arbitrary data to the permanent, globally replicated transaction record.
Figure 8. The Snippet of Overlord RAT function queries the Solana Memo address.
A threat actor can post one such transaction from a controlled wallet address whenever the C2 server address needs to be updated. Every deployed RAT picks up the update on its next discovery cycle without any redeployment or reconfiguration.
This is achieved by first retrieving the transaction history for the actor-controlled wallet using the Solana getSignatures JSON-RPC method which receives a chronologically ordered list of transaction signatures with the newest transaction first. For each signature it fetches the full transaction via getTransaction with jsonParsed encoding, which instructs the RPC node to decode every instruction data field into structured JSON response. The RAT module then walks every instruction in the parsed transaction looking for one whose data string is exactly 43 characters in length. The 43-character length is the fixed string length produced when a Base58-encoded WebSocket URL is AES-256 encrypted. Any instruction whose data field is a different length will be skipped, including legitimate Memo transactions from other users and all other Solana program instructions. Only instructions matching this precise length signature are treated as C2 memos.
Figure 9. RPC response format for the getTransaction request.
Good Game stealer
The Good Game stealer payload Talos observed in the arsenal of UAT-12643 is a publicly available Python-based infostealer developed under the label "Good Game (version 1.1.2)” by CirqueiraDev. The actor of this campaign is not the developer, and the malware is distributed as a self-contained Windows executable produced by packaging a Python 3.12.0 code with PyInstaller. Its architecture is split between two cooperating bytecode modules. The “final_build.pyc” acts as the launcher, decoy interface, and reverse-shell client, while “kora.pyc” contains the full data-harvesting stealer logic.
Good Game’s anti-analysis and evasion
The malware employs evasion techniques at every stage of execution, beginning the moment the process starts. The launcher immediately retrieves the console window handle via GetConsoleWindow() and calls ShowWindow() to hide the terminal window. A fully functional Notepad-style graphical user interface (GUI) is rendered in the foreground via tkinter, a Python’s standard, built-in library used for creating GUIs while all malicious threads run as daemon threads behind it.
Before the stealer module begins with any data collection, it runs three sequential execution checks. First, it confirms the host operating system is Windows by checking platform.system(); the stealer aborts silently on Linux or macOS. Second, it verifies network connectivity by performing an HTTP GET request to Google, and if the request fails, the stealer exits and records the failure reason in a file named “skipped" in the temporary directory. Third, and most significantly, it runs sandbox detection checks in five steps.
It checks for the presence of libraries including sbiedll.dll, api_log.dll, vmcheck.dll, wpespy.dll, cmdvrt64.dll, avghookx.dll, snxhk.dll, and guard32.dll.
The MAC address check extracts the host's network adapter hardware address via the getmac module and compares it against known OUI prefixes assigned to virtualization vendors: VMware (00:05:69, 00:0c:29, 00:50:56), VirtualBox (08:00:27), Hyper-V (00:15:5d), Xen (00:16:3e), and Parallels (00:1c:42).
The hardware memory check queries GlobalMemoryStatusEx through a ctypes MEMORYSTATUS structure and flags machines with less than two gigabytes of physical RAM as sandbox environments.
The boot-time check uses psutil.boot_time() to compute system uptime and treats an uptime of fewer than five minutes as indicative of a freshly provisioned analysis VM.
Finally, the Wine emulation check probes for the presence of “C:\windows\system32\wineboot.exe” to detect Windows API compatibility layers.
If any single check triggers, the stealer exits silently, leaving no harvested data and minimal trace.
The decoy URL mechanism of the stealer adds a further layer of camouflage. It opens a PDF-hosted document in the victim's default browser exactly once per machine and computes an MD5 hash of the URL and stores a flag file named “url_opened_<hash>.flag” in the temporary directory of the victim machine. On all subsequent executions, the lure URL is not re-opened, preventing repeated suspicious browser launches that would alert the victim.
Figure 10. Decoy PDF opened by Good Game stealer in victim’s browser.
Persistence established by Good Game
The malware establishes persistence through two independent mechanisms on Windows, ensuring the implant survives reboots regardless of which pathway is disrupted. The primary method is a registry autorun by opening the key HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run using winreg.KEY_SET_VALUE” and writes the absolute filesystem path of the running executable under the value name Zoipers, causing the binary to be launched automatically at every subsequent user logon without requiring elevated privileges. The secondary persistence mechanism is executed from within the stealer module of kora.pyc. The stealer copies the running executable into the Windows Startup folder at %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\ using shutil.copy().
Beyond simple re-execution persistence, the stealer also temporarily disables the Windows Task Manager during its active operation. It calls advapi32.RegCreateKeyExW directly through ctypes against the key HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System and sets a DWORD value DisableTaskMgr=1 via RegSetValueExW. After the data exfiltration completes successfully, the stealer restores the value to zero (DisableTaskMgr=0), reducing the probability that the victim will notice the restriction.
Good Game stealer functionalities
The stealer's most extensive capability targets 23 Chromium-family and Firefox-based browser variants, covering Google Chrome across all distribution channels, Microsoft Edge, Opera, Opera GX, Brave, Vivaldi, Yandex Browser and all its regional variants, Amigo, Torch, Kometa, Orbitum, CentBrowser, 7Star, Sputnik, Epic Privacy Browser, Uran, and Iridium.
The stealer scans LevelDB stores across Discord clients and over 19 Chromium-based browsers for authentication tokens using two regex patterns one for plain-text tokens and one for tokens encrypted with the “dQw4w9WgXcQ:” prefix introduced in newer Discord versions. It decrypts the stolen token via the browser's extracted master key, then validates each recovered token against the Discord API to build a complete account profile covering username, display name, user ID, email, phone number, Nitro subscription tier, linked payment methods, gift codes, and multi-factor authentication (MFA) status.
The stealer additionally extracts ROBLOSECURITY cookies from browser databases, validating each against the Roblox authentication API to confirm active sessions and retrieve the associated account details. A full system profile is assembled covering hostname, username, hardware specifications, OS details, network interfaces, and public IP geolocation metadata queried from ipwhois.app, serialized to system_infos.txt in the archive root.
The stealer also captures a full-monitor screenshot and a single webcam frame, both saved as PNGs and added to the archive before the temporary files are deleted and terminated. The stealer then harvests session data from 21 cryptocurrency wallets including Exodus, Electrum, Ledger Live, Trezor Suite, Atomic Wallet, Trust Wallet, Coinbase, and Binance, as well as four gaming platform launchers (Steam, Riot Games, Epic Games, and Rockstar Games).
Beyond structured credential databases, the stealer conducts a targeted sweep of the victim's personal file system across the folders Desktop, Downloads, Documents, Pictures, Videos, OneDrive root, and the Windows Recent Items folder at %APPDATA%\Microsoft\Windows\Recent. The sweep applies to two independent filters that a file must satisfy simultaneously before it is collected.
The first filter is an extension allowlist covering 45 file types spanning different categories mentioned in the table below:
The second filter is a keyword allowlist of four languages English, French, Spanish, and Portuguese that must match the file's base name exactly. The keyword list is designed to maximize overlap with the types of sensitive documents that cryptocurrency users, online gamers, and financially active individuals are likely to store on their desktops or in their documents folders. It covers two-factor authentication backup codes, mnemonic seed phrases, cryptocurrency wallet application names, generic password file naming conventions, banking and payment terms, private key and recovery phrase labels, Discord authentication tokens, Telegram session identifiers, and generic high-value labels such as secret, vault, backup, admin, and root.
Files that satisfy both the extension and keyword filters are written into the archive in the temporary directory, with each file name suffixed by a randomly generated four-digit number before the extension.
Figure 11. Targeted files search and exfiltration program for Good Game stealer.
Data exfiltration mechanism of Good Game stealer
All harvested data is written progressively into a single ZIP file. The ZIP file object is opened with ZIP_DEFLATED compression in the system temporary directory. The archive file name uses the prefix “SK_”, followed by eight randomly generated characters, creating a unique identifier per victim and making the archive harder to identify by name alone.
The ZIP is structured into named subdirectories such as Screenshot/, Webcam/, Session Files/Wallets/, Session Files/Game Launchers/, Session Files/Apps/Telegram/, and Interesting Files/ alongside flat files in the root for system information and antivirus enumeration results. Browser-derived outputs are labelled with a count suffix such as Passwords (N).txt, where N reflects the number of credentials recovered from that browser, enabling the actor to prioritize.
Once all stealer modules have been completed, the closed archive is uploaded to hxxps[:]//upload[.]gofile[.]io/uploadFile using an HTTP POST request. The server returns a JSON response containing a direct download link to the uploaded archive.
Figure 12. Snippet of Good Game stealer exfiltration function.
With the GoFile download URL in hand, the stealer constructs a Discord webhook notification and POSTs it to the hardcoded webhook endpoint. The notification takes the form of a Discord message containing the victim's hostname, username, machine architecture, operating system version, and OS release label providing the operator with an immediate preview of the victim's machine profile without needing to download the archive first. After the webhook POST completes, the stealer calls its cleanup routine to delete the local ZIP archive and all temporary intermediate files including the screenshot PNG and webcam PNG from the temporary directory.
Figure 13. Snippet of Good Game that POSTs reconnaissance data to Discord Webhook.
The clipboard hijacker Talos identified in the actor’s toolset is a compact Windows x64 executable written in C++. It has no network component or C2 communication protocol; instead, the actor configuration is compiled directly into the binary as XOR-encrypted wallet addresses in the binary data section.
Upon execution, the binary dynamically resolves the API function addresses and creates a global mutex “UuuRjinBZPBMIjnc”. Then it retrieves the machine name and searches for the substrings including VBOX, VMWARE, QEMU, and SANDBOX. Persistence is established by copying the binary to %APPDATA%\MsgEdgeUpdate.exe with FILE_ATTRIBUTE_HIDDEN and FILE_ATTRIBUTE_SYSTEM attributes applied, then adding it under user hive’s Run registry key with value named “MsgEdgeUpdate”, spoofing the appearance of a legitimate Microsoft Edge updater process.
The hijacker polls the Windows clipboard every 500 milliseconds in an infinite loop, applying address-format fingerprinting to detect the copied cryptocurrency. All clipboard APIs are resolved dynamically through user32.dll. On detection, the corresponding attacker wallet address is XOR-decrypted from the data section and overwrites the original wallet address in the victim machine clipboard.
Coverage
The following ClamAV signatures detect and block this threat:
Win.Trojan.OverlordRAT-10060615-0
Ps1.Trojan.LNKBuilder-10060627-0
Win.Trojan.OverlordRAT2-10060616-0
Win.Infostealer.GoodGame-10060617-0
Win.Infostealer.PyStealerDeps-10060618-0
Py.Infostealer.GoodGame-10060619-0
Py.Trojan.GoodGameLoader-10060620-0
Win.Trojan.WalletClipper-10060621-0
Win.Downloader.LNKMpCmdRun-10060622-0
Win.Downloader.LNKCertutil-10060623-0
Win.Trojan.LNKVideosExe-10060624-0
Html.Downloader.HTAStager-10060656-1
Xml.Downloader.MSBuildInline2-10060657-0
The following Snort2 and Snort3 Snort Rules (SIDs) detect and block this threat:
Snort2: 1:67491, 1:67490
Snort3: 7:75, 7:74
Indicators of compromise (IOCs)
IOCs for this research can be found at our GitHub repository here.
from Cisco Talos Blog https://ift.tt/1YUF7vG
via IFTTT