CVE-2026-92091 Overview
CVE-2026-92091 is a denial-of-service flaw in jwcrypto, a Python library that implements JSON Web Key (JWK), JSON Web Signature (JWS), and JSON Web Encryption (JWE) primitives. The JWK.import_key() function validates the key_ops JWK member for duplicate entries using an algorithm with O(n^2) time complexity, and the array length is not bounded. A remote, unauthenticated attacker can submit a JWK with a large key_ops array to any endpoint that imports attacker-controlled key material, consuming excessive CPU time. The issue is tracked under CWE-407: Inefficient Algorithmic Complexity.
Critical Impact
Unauthenticated attackers can exhaust CPU resources on any service that imports untrusted JWKs via ECDH-ES key agreement, OIDC dynamic client registration, DPoP, or ACME account key registration.
Affected Products
- jwcrypto Python library (upstream project maintained by latchset)
- Red Hat products consuming the jwcrypto package (see Red Hat CVE-2026-92091 Advisory)
- Applications exposing JWK import via OIDC, DPoP, ACME, or ECDH-ES key agreement flows
Discovery Timeline
- 2026-09-16 - CVE-2026-92091 published to NVD
- 2026-09-16 - Last updated in NVD database
Technical Details for CVE-2026-92091
Vulnerability Analysis
The vulnerability resides in JWK.import_key(), the entry point used by jwcrypto to parse and validate JWK objects. During validation, the function inspects the key_ops array — an optional JWK member that lists permitted key operations such as sign, verify, encrypt, or decrypt. To reject duplicate operations, the routine performs pairwise comparisons rather than using a hash-based deduplication strategy. The result is quadratic scaling with the array length.
Because jwcrypto does not enforce an upper bound on key_ops, an attacker can submit an array containing tens or hundreds of thousands of entries. Each additional element multiplies the work performed by the validator. Any protocol flow that accepts an attacker-supplied JWK inherits the flaw. That includes Elliptic Curve Diffie-Hellman Ephemeral Static (ECDH-ES) key agreement in JWE, OpenID Connect (OIDC) dynamic client registration, Demonstrating Proof-of-Possession (DPoP), and Automatic Certificate Management Environment (ACME) account key registration.
Root Cause
The root cause is an algorithmic complexity flaw in duplicate detection combined with the absence of input-size limits. Validation should complete in linear time using a set-based membership check, and the parser should reject oversized key_ops arrays before scanning them.
Attack Vector
The attack requires no authentication and no user interaction. An attacker crafts a JWK JSON document containing an oversized key_ops array and submits it to any exposed endpoint that calls JWK.import_key() on the payload. A single request can pin a worker process on CPU for an extended period. Repeated requests exhaust worker pools and degrade or halt service availability.
Refer to the GitHub Security Advisory GHSA-pwgw-f7xr-863h for upstream technical details.
Detection Methods for CVE-2026-92091
Indicators of Compromise
- Inbound HTTP requests containing JWK payloads with key_ops arrays exceeding a few dozen entries.
- Sustained high CPU on worker processes handling OIDC registration, DPoP, ACME, or JWE endpoints without a corresponding rise in successful transactions.
- Elevated request latency or timeouts on endpoints that call jwcrypto.jwk.JWK.import_key().
Detection Strategies
- Instrument the JWK import path to log the size of the key_ops array and emit an alert when it exceeds a policy threshold.
- Deploy web application firewall (WAF) rules that inspect JSON bodies for key_ops arrays above a safe length limit and drop the request.
- Baseline CPU time per request for endpoints that process JWKs and alert on statistical outliers.
Monitoring Recommendations
- Correlate slow-request telemetry with source IP addresses to identify abusive clients targeting JWK-consuming endpoints.
- Track process CPU saturation events alongside request logs for OIDC, DPoP, and ACME services to surface algorithmic DoS attempts.
- Ingest application and WAF logs into a centralized analytics platform for cross-service correlation of anomalous JWK payloads.
How to Mitigate CVE-2026-92091
Immediate Actions Required
- Upgrade jwcrypto to the fixed release identified in the GitHub Security Advisory GHSA-pwgw-f7xr-863h.
- Apply vendor updates for downstream distributions, including those tracked in the Red Hat CVE-2026-92091 Advisory and Red Hat Bug Report #2533849.
- Inventory services that expose JWK import to unauthenticated clients and prioritize those for patching.
Patch Information
The upstream jwcrypto project has released a fix that bounds the key_ops array and replaces the quadratic duplicate-detection routine. Consult the GitHub Security Advisory GHSA-pwgw-f7xr-863h for the exact fixed version and the Red Hat CVE-2026-92091 Advisory for downstream package updates.
Workarounds
- Enforce a maximum JSON request body size at the reverse proxy or WAF to cap the possible key_ops length.
- Add pre-validation that rejects JWKs whose key_ops array exceeds the small set of values defined by RFC 7517.
- Apply per-client rate limiting and CPU-time quotas on endpoints that call JWK.import_key().
- Require authentication on JWK-consuming endpoints where the protocol permits it.
# Configuration example
# Pre-validate key_ops length before calling jwcrypto
MAX_KEY_OPS=16
python - <<'PY'
import json, sys
MAX = 16
data = json.load(sys.stdin)
ops = data.get("key_ops", [])
if isinstance(ops, list) and len(ops) > MAX:
sys.exit("reject: key_ops too large")
PY
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
