An AI security model found a critical bug in a widely-used file server. Researchers disclosed it responsibly. The vendor patched it. Then someone released a proof-of-concept — and now hackers are scanning for vulnerable servers in the wild.

CVE-2026-61500 is a CVSS 9.3 critical vulnerability in Rejetto HTTP File Server (HFS). It’s not a garden-variety memory corruption or SQL injection. The root cause is a cryptographic failure buried in how HFS generates and manages session cookies — and it took an AI reasoning model to spot both the weakness and the leak that makes it exploitable as a chain.

Here’s the full breakdown: what it is, how it works, who found it and how, what active exploitation looks like, and what you need to do.


The Vulnerability at a Glance

DetailValue
CVE IDCVE-2026-61500
CVSS Score9.3 (Critical)
Affected SoftwareRejetto HFS 3.0.0 through 3.2.0
Fixed InVersion 3.2.1 (July 13, 2026), latest stable: 3.3.4
Vulnerability TypeWeak PRNG / Session-cookie signing key leakage
ImpactUnauthenticated admin takeover + RCE
Auth RequiredNone
DiscoveryHorizon3.ai using Anthropic’s Mythos AI model
PoC PublishedSeptember 30, 2026
CISA KEV AddedOctober 2026
Active ExploitationOctober 2, 2026 (scanning confirmed)

Rejetto HFS is a free, open-source HTTP file server for Windows, Linux, and macOS. It’s used for self-hosted file sharing — small businesses, home labs, developers, internal tooling. Tens of thousands of deployments are reachable on the public internet.


The Root Cause: Math.random() Shouldn’t Run Security Infrastructure

The technical heart of CVE-2026-61500 is a bad choice made somewhere deep in the HFS codebase: the session-cookie signing key was derived from JavaScript’s Math.random().

That sounds innocuous until you understand two things:

1. Math.random() is not cryptographically secure.

Browsers and Node.js implement Math.random() using the xorshift128+ algorithm — a fast pseudo-random number generator designed for performance, not unpredictability. Its output sequence is entirely deterministic. If you know the internal state (128 bits), you can predict every past and future output.

In most applications, that’s fine. For generating session signing keys? It’s a catastrophic design error.

2. HFS leaked Math.random() outputs to unauthenticated clients.

Here’s where the chain forms. Rejetto HFS’s login flow exposed raw outputs from the same Math.random() generator to anyone who hit the server — no credentials required. These values weren’t labeled as “here is my PRNG output,” but they were derived from it in a recoverable way.

The attack path, fully described in NIST’s NVD advisory:

“A remote attacker can collect a small number of login responses, reconstruct the generator’s state, recover the signing key, and forge a valid administrator session cookie, leading to full administrative access and remote code execution via the server_code configuration feature.”

In practice: an attacker sends a handful of unauthenticated login requests, collects the exposed values, runs the xorshift128+ state reconstruction algorithm against them, recovers the signing key, and mints themselves a valid admin session cookie. The entire attack happens before they’ve ever entered a username or password.


How Horizon3.ai Found It — With AI

This is the part that makes CVE-2026-61500 different from most vulnerabilities on the KEV list.

Horizon3.ai researchers didn’t find this through manual code review or fuzzing. They used Anthropic’s Mythos AI model — Anthropic’s reasoning-focused security research model — to analyze the Rejetto HFS codebase. Mythos didn’t just flag the insecure PRNG use in isolation. It identified both the weak signing-key generation and the separate code path leaking generator outputs, recognized them as a chain, and determined that the leaked values provided exactly the observations needed for state recovery.

From Horizon3’s write-up, published September 30:

“Mythos didn’t just flag the insecure PRNG in isolation — it simultaneously identified that the application leaked raw Math.random() outputs through a separate code path, recognized those two facts as a chain, and determined the leak produced exactly the observations needed to make state recovery feasible.”

This is a meaningful data point in the ongoing debate about AI-assisted vulnerability research. Finding either issue alone would have been interesting. Finding both and reasoning about their interaction as an exploitable chain — that’s the kind of cross-file, cross-layer reasoning that has historically required experienced human security researchers with significant time investment.

Mythos cut that timeline to hours.

The broader context: Google GTIG reported in September that from January to August 2026 alone, 141 distinct vulnerabilities were disclosed and exploited — surpassing the full-year totals from prior years. AI-assisted discovery is accelerating the pace, and defenders are being compressed on both ends.


Timeline: From Discovery to Active Exploitation

DateEvent
June 2026Horizon3.ai discovers the vulnerability using Mythos AI model
July 13, 2026Rejetto HFS 3.2.1 released; CVE-2026-61500 published on NIST NVD
September 30, 2026Horizon3.ai publishes full technical write-up + PoC exploit
October 2, 2026VulnCheck Canary Intelligence honeypots detect active scanning
October 2026CISA adds CVE-2026-61500 to Known Exploited Vulnerabilities catalog

The gap between PoC release and active scanning was approximately 72 hours. That’s the new normal for high-severity, publicly weaponized vulnerabilities — expect threat actors to move within days, sometimes hours, of a working exploit becoming public.


The Exploit Chain in Detail

Horizon3’s PoC demonstrates the full attack path against a vulnerable HFS instance.

Step 1: PRNG State Collection

The attacker sends repeated unauthenticated requests to the HFS login endpoint. Each response contains values derived from the server’s Math.random() call. After collecting a small number of these (the exact count depends on implementation specifics, but Horizon3 achieved reliable recovery in their demo), the attacker has enough observations to work with.

Step 2: xorshift128+ State Reconstruction

The xorshift128+ algorithm maintains a 128-bit internal state across two 64-bit words (s[0] and s[1]). Its output is reversible — given a sequence of outputs, you can algebraically solve for the state. Tools for this exist publicly; the math isn’t novel. What’s novel is recognizing that HFS was inadvertently providing the inputs needed to run this attack.

Step 3: Signing Key Recovery

With the PRNG state reconstructed, the attacker can compute the session-cookie signing key — since it was derived from the same Math.random() sequence during server initialization. The key is now in the attacker’s hands.

Step 4: Session Cookie Forgery

The attacker mints a valid administrator session cookie signed with the recovered key. From HFS’s perspective, this cookie looks completely legitimate. No brute force. No password spray. No exploit in the traditional sense — just math.

Step 5: Remote Code Execution via server_code

Authenticated admin access to Rejetto HFS includes access to the server_code configuration feature — which allows execution of custom server-side JavaScript. With a forged admin session, an attacker can inject and execute arbitrary code on the server with the privileges of the HFS process.

Possible post-exploitation paths:

  • Exfiltrating all files hosted on the server
  • Deploying a web shell or reverse shell for persistence
  • Using the compromised host as a pivot into internal network segments
  • Dropping malware or cryptominers (HFS servers have historically been targeted for Monero mining campaigns )

Who’s Scanning — and What They’re After

VulnCheck VP of Security Research Caitlin Condon disclosed on October 2 that the company’s Canary Intelligence honeypots had observed active probes targeting CVE-2026-61500. The activity was characterized as small-scale reconnaissance from a single China Telecom IP address targeting HFS deployments in Japan and the United States.

“Small-scale reconnaissance” is honeypot language for “someone is checking which servers are vulnerable.” It doesn’t mean a destructive campaign is already in progress — but it means the targeting phase is active. Large-scale exploitation typically follows once threat actors have mapped exposed, unpatched instances.

At the time of writing, VulnCheck hasn’t confirmed successful exploitation or shared post-exploitation payloads. That picture may change quickly.


Red Team Perspective

CVE-2026-61500 is a good case study in a vulnerability class that shows up regularly in red team assessments: cryptographic assumptions about “random” values in security-sensitive paths.

A few things worth noting:

Math.random() abuse isn’t new. JavaScript’s non-cryptographic PRNG has caused security issues before — in web tokens, in session identifiers, in nonces. The fix has been standardized for years: use crypto.getRandomValues() for anything security-sensitive. HFS’s failure here isn’t a novel mistake; it’s a known anti-pattern in an application that should have known better.

Session forgery without credential compromise. This attack doesn’t touch passwords. It doesn’t trigger authentication failure logs. From a SIEM perspective, a forged session cookie that passes server-side signature validation looks indistinguishable from a legitimate admin session. Detection requires either anomaly-based analysis (admin session from a new IP? admin session appearing before any login page load?) or network-layer monitoring of the initial reconnaissance phase.

The server_code RCE surface. Admin-level JavaScript execution as a built-in feature is a dangerous design choice for a file server that might be internet-facing. On a real engagement, if you reach admin on HFS, you have full code execution — the server_code feature removes any additional exploitation step.

AI-assisted discovery is closing the gap. The fact that Mythos found a two-component exploit chain that required recognizing an interaction between two separate code paths is a signal. Automated tools are getting better at this. The time between “vulnerability exists” and “working exploit is public” will continue to compress. Patch cycles that assume 30-day remediation windows are increasingly misaligned with operational reality.


Detection and Hunting

If you’re a defender, here’s where to look:

Exposure check: Rejetto HFS is typically deployed on high ports (8080, 8000) or port 443 with a custom cert. Shodan and Censys queries for product:"HFS" or http.title:"HFS" will surface public-facing instances. Check your external attack surface management tooling for any HFS deployments.

Log review: Review HFS access logs for:

  • High volumes of unauthenticated login requests from a single IP (PRNG state collection phase)
  • Admin session activity from IPs that never accessed the login page
  • Changes to the server_code configuration

Network anomalies: Outbound connections from the HFS server process to external IPs (post-exploitation C2 or exfiltration) are worth hunting in your NSM data.

Version confirmation: Check your HFS instances. About page in the HFS UI shows the version. Anything 3.0.0 through 3.2.0 is vulnerable.


What to Do Now

  1. Patch immediately. Upgrade to Rejetto HFS 3.3.4 (the current latest stable). Minimum acceptable: 3.2.1, which contains the fix. The patch replaces Math.random() with crypto.randomBytes() for all session security operations.

  2. Check for compromise. If your HFS server was internet-facing and running 3.0.0 through 3.2.0 any time after September 30 (PoC release), treat it as potentially compromised. Review logs, check for unauthorized file access, look for any installed scripts or modified configuration.

  3. Restrict access. If HFS must remain exposed externally, put it behind a VPN or IP allowlist. A file server with unauthenticated access to the login endpoint should not be on the open internet.

  4. Monitor. Add CVE-2026-61500 to your vulnerability tracking. The CISA KEV addition means this carries mandatory remediation deadlines for federal agencies — but the risk exists regardless of compliance scope.


Bottom Line

CVE-2026-61500 is a textbook example of how a seemingly minor cryptographic shortcut — using a non-secure PRNG for a security-critical key — becomes a full authentication bypass when combined with an application that also leaks its own PRNG outputs. Neither issue alone might have been exploitable. Together, they hand attackers the keys.

What makes this notable in October 2026 is the discovery story. An AI model found a two-step exploit chain requiring multi-file, cross-layer reasoning faster than any human team would have. That’s not a one-off curiosity — it’s a pattern that’s accelerating. The defense-side implication is clear: if AI models are finding and weaponizing vulnerabilities faster, the assumed time-to-exploit after PoC release is shrinking. Patch windows don’t exist the way they used to.

Active scanning is already happening. If you’re running Rejetto HFS, update now.


Related: Citrix NetScaler Zero-Days 2026: How Attackers Exploited CVE-2026-88771, 88772 and 88779

Related: Red Team OPSEC Guide 2026


Need a Professional Red Team Assessment?

CipherWrite delivers expert cybersecurity content and red team documentation — from technical write-ups to executive threat briefings. If your team needs to communicate risk clearly to leadership, we can help.