Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObserve target login response timestamp to second precision
-
DeliveryEnumerate candidate Apache worker PIDs from known OS PID range
-
ExploitConstruct candidate 64-character hex cookies from microsecond × PID space
-
ExecutionSubmit candidates in online brute-force HTTP requests
-
PersistServer accepts matching cookie
-
ImpactAccess protected application resources as authenticated victim
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V11 - Cryptography Predictable value prevention
|
| Exploitation Conditions | Exploitation requires the attacker to bound two observable values: the Unix epoch second in which the victim's session was created, and the process ID of the Apache mod_perl worker that handled the login. The creation second is often inferrable from the network-layer timestamp of the server's login response. The PID is constrained to the operating system's PID range and may be narrowed through timing attacks, predictable worker rotation patterns in a prefork MPM, or information disclosed in server headers or error pages. Critically, each candidate key must be validated through a live request to the server because the attacker lacks the server key required for offline verification; this online-oracle requirement limits automation (SSVC Automatable=no) and exposes the enumeration to server-side rate-limiting and intrusion detection. Sites that have configured the Keysource directive with externally supplied entropy are routed through an alternate code path in CreateSession and are not affected by this specific weakness. The attack requires no authentication, no network proximity, and no user interaction beyond the victim's normal login activity. |
| Impact | The NVD CVSS 3.7 (AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N) accurately characterizes the real-world risk. The high attack complexity is warranted: an attacker must independently bound both the creation second of the target session and the PID of the handling worker, then conduct online enumeration where each candidate must be validated by a live server request - a process that exposes the attack to rate-limiting, IP blocking, and anomaly detection. EPSS at 0.28% (20th percentile) and SSVC Exploitation=none both confirm no current exploitation activity; these signals are mutually consistent with the attack's high operational complexity. The SSVC Automatable=no finding is significant - the requirement for an online oracle per candidate prevents mass or opportunistic exploitation. The C:L rating may appear conservative given that successful exploitation yields authentication bypass to protected resources, but the aggregate risk remains low because the attack is targeted, complex, and niche. No data conflicts or inconsistencies are present across the available sources. |
| Exploit ScenarioDerived | An attacker monitors network traffic or application-layer signals to observe a target user's login response, bounding the session creation to a known Unix epoch second, and infers the Apache mod_perl worker PID through timing side-channels or server response headers. The attacker then iterates over approximately 10^6 microsecond values for the first Time::HiRes reading combined with candidate PIDs, constructing 64-character hex session cookies and submitting each in a crafted HTTP request to the protected application; when the server accepts a candidate, the attacker gains authenticated access as the victim without possessing valid credentials. No public proof-of-concept code has been identified, but the attack requires only standard HTTP tooling and arithmetic over a bounded key space. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 25, 2026
Session cookie forgery in Apache::AppSamurai::Util through version 1.01 is possible because CreateSessionAuthKey derives its entire entropy from observable runtime state - wall-clock microseconds and the Apache worker process ID - rather than a cryptographically secure random source. An unauthenticated remote attacker who can bound the second in which a target session was created and enumerate the small PID space can construct candidate 64-character hex cookies and recover a valid session token through online brute-force, bypassing authentication for all resources protected by the module. No public exploit code has been identified and SSVC confirms no current exploitation, though the attack is mechanically feasible given the constrained key space.
RemediationAI
No vendor-released patched CPAN version has been identified in available data at time of analysis; operators should monitor the PAULDOOM/Apache-AppSamurai release page on metacpan.org and the oss-security thread at https://seclists.org/oss-sec/2026/q3/553 for a fixed release. As a primary compensating control, populate the Keysource directive in the Apache AppSamurai configuration with a cryptographically random value of at least 128 bits; per the source code, this is the only configuration path that bypasses the vulnerable timestamp-and-PID derivation branch - operators should verify behavior of that branch in Util.pm before relying on it as a full mitigation. As secondary controls, restrict access to AppSamurai-protected resources by IP allowlist where operationally feasible, enforce aggressive session expiry to minimize the window during which a forged cookie remains valid, and configure Apache access logging to capture cookie-validation failures at sufficient granularity to detect enumeration attempts from a single source IP. These controls reduce exposure but do not eliminate the underlying weak key generation.
Affected ProductsAI
All releases of Apache::AppSamurai for Perl through version 1.01 are affected, specifically the CreateSessionAuthKey function in Apache::AppSamurai::Util. No formal NVD CPE string is present in the available data; the affected codebase is identified at https://metacpan.org/release/PAULDOOM/Apache-AppSamurai-1.01/source/lib/Apache/AppSamurai/Util.pm (lines 106-135) and https://metacpan.org/release/PAULDOOM/Apache-AppSamurai-1.01/source/lib/Apache/AppSamurai.pm (lines 1446-1533). The vulnerability applies to any Apache mod_perl deployment using this module for session authentication without the Keysource directive populated with external entropy. The oss-security advisory at https://seclists.org/oss-sec/2026/q3/553 formally establishes the version boundary.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerable code is the CreateSessionAuthKey subroutine in Apache::AppSamurai::Util (CPAN release PAULDOOM/Apache-AppSamurai-1.01, documented at metacpan.org lines 106-135 of Util.pm). The function performs five iterative SHA-256 rounds, each consuming a fresh Time::HiRes timestamp formatted to six decimal places, the running digest, and the Perl process-ID variable ($$). Because each subsequent reading follows the first within microseconds, the microsecond field of the first reading (roughly 10^6 values) dominates the entropy pool, and the PID is drawn from the kernel's historically limited process-ID range. CreateSession invokes this function with an empty key source on every login; the Keysource directive provides the only alternate code path. The resulting cookie is returned to the browser and combined with a secret server key to derive the session ID and encrypt stored session data - meaning candidates cannot be verified offline. CWE-341 (Predictable from Observable State) precisely describes the root cause: inputs that are externally observable or enumerable collapse the apparent 256-bit SHA-256 output to a far smaller effective key space.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N
Online-only candidate validation and need to infer both session second and worker PID justify AC:H; no authentication or user interaction required for the enumeration attempt itself.
Primary rating from Vendor (CPANSec).
CVSS VectorVendor: CPANSec
Lifecycle Timeline
3DescriptionCVE.org
Apache::AppSamurai::Util versions through 1.01 for Perl generate predictable session authentication keys from the clock and process id in CreateSessionAuthKey.
CreateSessionAuthKey runs five rounds of SHA-256, each over a fresh Time::HiRes reading formatted to six decimal places, the running digest, and the process id. CreateSession calls it with an empty key source on every login, and the optional Keysource directive is the only route to the other branch. The result is 64 hex characters. The microsecond field of the first reading takes one of a million values, the later readings follow it within microseconds, and the process id is drawn from a small range.
The key is returned to the browser as the session cookie, and is combined with the configured server key to compute the session id and to encrypt the stored session data. An attacker who knows the second in which a session was created and the process id of the worker that created it can enumerate candidate keys and recover the victim's cookie, bypassing authentication for the protected resources. Each candidate has to be tried against the server, which validates the cookie with a key the attacker does not hold.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
EUVD-2026-64663
GHSA-hw54-jvwm-w52c
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB