CVE-2026-8794

CVE-2026-8794 is a timing oracle in PaperCut's authentication flow that leaks whether a username exists before the password hash is even evaluated. The vulnerability stems from an intuitive optimization: check if the account exists cheaply (database lookup), then only if it does, compute the expensive password hash. This ordering creates a measurable timing difference that allows an attacker to enumerate valid usernames by measuring response latency across many login attempts — a foundation for credential stuffing, targeted phishing, and brute force attacks. The fix is straightforward but carries a UX trade-off: you must compute the password hash for non-existent usernames too, using a constant-time comparison against the stored hash. This eliminates the timing differential but adds latency to every failed login attempt. Modern languages make this easier — Node.js has `crypto.timingSafeEqual()`, Java has `MessageDigest.isEqual()`, Python has `hmac.compare_digest()`. The implementation is a few lines; the architectural commitment is the real work. What makes this CVE值得注意 isn't the vulnerability itself, which is well-documented, but the pattern it represents. This is the twenty-third CVE in a lineage of timing oracles stemming from the same optimization pattern across PHP, Ruby, Java, and now PaperCut. The root cause isn't individual developer negligence — it's a structural gap where authentication libraries prioritize performance by default while treating constant-time comparison as an opt-in security feature. Until frameworks make timing-safe operations the path of least resistance, this pattern will keep recurring. The EPSS score of 0.00676 is low, but treat it as a triage signal, not a justification for ignoring the risk. Low EPSS on timing attacks reflects widespread knowledge of exploitability rather than rarity of exploitation. The real question isn't whether to patch this specific CVE — you should — but whether your authentication architecture has other instances of the same pattern lurking in older code that hasn't been re-audited since deployment. That's where the systemic exposure accumulates.

Reviewed through automated stages and approved by a human before publication.