Skip to main content

web.py CVE-2026-79311

| EUVDEUVD-2026-84551 MEDIUM
Cross-site Scripting (XSS) (CWE-79)
2026-09-22 mitre GHSA-w73w-5qq6-73c8
6.1
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft malicious script payload
  2. Delivery
    Deliver link to victim user
  3. Exploit
    Reflected via render_jinja output
  4. Execution
    Script executes in victim browser
  5. Impact
    Steal session/perform actions in origin

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the target to be running a web.py 0.76 application that uses the Jinja template renderer (render_jinja) and reflects user-controlled input into rendered output without adequate output encoding - the flaw is anchored in render_jinja's initialization, implying template escaping behavior is the relevant setting. Exploitation is LIMITED by mandatory victim interaction (UI:R: the user must open an attacker-crafted link or submit attacker-influenced input) and by the fact that impact is confined to the victim's browser session within the site origin (no server-side read/write or availability loss). Realistic risk therefore depends on whether the deployed application actually passes untrusted data into Jinja-rendered responses.

Impact

This is a textbook reflected Cross-Site Scripting (CWE-79) issue in the web.py Python framework (version 0.76) tied to the render_jinja.__init__() code path. The signals are internally consistent and point to a genuine-but-moderate concern rather than an emergency. The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, base 6.1) indicates remote, low-complexity, unauthenticated reach, but the mandatory UI:R (user interaction) and the limited, browser-context-only Confidentiality/Integrity impacts cap the severity at Medium - no availability impact. EPSS strongly agrees it is not a mass-exploitation target: 0.19% probability at the 9th percentile, i.e., very low near-term exploitation likelihood. There is NO CISA KEV listing and no vendor-confirmed active exploitation. A third-party technical writeup exists (lichoin/TraceLoom) which may contain reproduction detail, but no weaponized, self-contained public exploit is confirmed from the input. Net: a legitimate client-side vulnerability worth patching in web.py 0.76 deployments, but low real-world urgency - not a high-CVSS-but-illusory issue, and equally not a drop-everything priority. Note that render_jinja.__init__() suggests the defect sits in how the Jinja renderer is initialized (e.g., autoescape handling), so impact depends on how the application passes user-controlled data into rendered templates - verify with the application's template usage.

Exploit ScenarioDerived

An attacker crafts a URL or input that, when processed by a web.py 0.76 application using the Jinja renderer, reflects unescaped attacker-controlled markup into an HTTP response. The attacker lures a victim into clicking the link (UI:R), causing their browser to execute attacker-supplied JavaScript in the site's origin, enabling session/cookie theft or UI redress. A third-party technical writeup describing the flaw exists, but no fully weaponized public exploit is confirmed.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 06, 2026

Reflected cross-site scripting in web.py 0.76 allows remote, unauthenticated attackers to inject and execute arbitrary JavaScript in a victim's browser session, because the framework's render_jinja.__init__() code path does not adequately constrain output escaping for user-controlled input that reaches Jinja-rendered templates. Exploitation requires the target application to actually route untrusted input into a render_jinja-generated response and requires victim interaction (UI:R) - the user must open an attacker-crafted link or supply attacker-influenced data - and the resulting impact is confined to the victim's browser within the site's origin (scope-changed, low confidentiality and integrity impact, no availability loss). No confirmed active exploitation (not in CISA KEV), no public exploit code identified at time of analysis, and EPSS is low at 0.19% (9th percentile), so real-world risk is governed primarily by whether a deployment passes untrusted data into Jinja-rendered output.

RemediationAI

No vendor-released patch identified at time of analysis, and no fixed version number is provided in the available intelligence; the upstream project at https://github.com/webpy/webpy is the place to monitor for a patched release, and the technical write-up at https://github.com/lichoin/TraceLoom/blob/main/CVEs/CVE-2026-79311.md plus the NVD entry at https://nvd.nist.gov/vuln/detail/CVE-2026-79311 should be checked for updated remediation guidance. Because the flaw is anchored in the render_jinja initialization, the most direct compensating control is to force Jinja's autoescaping on for the environment used by the renderer, or, if that is not configurable in 0.76, to explicitly HTML-escape every untrusted value with markupsafe/Jinja's escape filter before it is handed to the template - the trade-off is that escaping must be applied consistently at every sink, and sites that intentionally render user-supplied HTML will lose that capability or must adopt sanitization (e.g. an allowlist HTML sanitizer) instead. Avoid passing raw request parameters (query strings, form fields, path segments, headers reflected into pages) into render_jinja output; where reflection is unavoidable, constrain or reject input containing HTML metacharacters, accepting that this may break legitimate use cases. Add a Content-Security-Policy header that disallows inline and untrusted script sources as defense-in-depth, understanding that CSP only reduces exploitability and does not fix the missing encoding; set session cookies with HttpOnly and SameSite to limit the value of any successful script execution, though this does not prevent script from acting within the page as the user. Finally, since exploitation requires victim interaction, avoid distributing attacker-controllable links and ensure that any future web.py upgrade is validated for regressions in template escaping behavior.

Affected VersionsENISA

n/a n/a

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 affected component is web.py, a long-standing minimalist Python web framework, and specifically its Jinja templating integration layer reached through render_jinja.__init__() in version 0.76. Jinja2 by itself provides context-aware autoescaping for HTML contexts when an application uses the Environment with autoescape enabled; the defect here sits in how web.py initializes that renderer, meaning the escaping behavior configured at renderer construction time is the relevant setting rather than a flaw in Jinja itself. The vulnerability class is CWE-79 (Improper Neutralization of Input During Web Page Generation, i.e. cross-site scripting): user-controlled data that is placed into a Jinja template is emitted into an HTML response without adequate encoding, allowing injected script markup to be interpreted by the browser. The assessed CVSS:3.1 vector AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N describes a network-reachable, low-complexity, unauthenticated attack that nevertheless requires the victim to interact with the malicious input, and whose consequences are limited to script execution in the victim's session within the site origin - scope is changed because the injected content alters how the page is processed in the browser, while confidentiality and integrity impacts remain low and there is no availability impact. The supplied CPE string is unpopulated (n/a), so the authoritative product identification is the description plus the upstream project repository reference, not a versioned CPE.

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

Vendor (mitre) PRIMARY 6.1 MEDIUM
AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N
vuln.today AI 6.1 MEDIUM

Standard reflected XSS: network-reachable and low-complexity, no auth (PR:N), but requires victim interaction (UI:R); scope change (S:C) with low browser-context confidentiality/integrity impact and no availability loss.

3.1 AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N
Red Hat 6.1 MEDIUM

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Changed
Confidentiality
Low
Integrity
Low
Availability
None

Lifecycle Timeline

2
CVSS changed
Oct 06, 2026 - 18:22 NVD
6.1 (MEDIUM)
CVE Published
Sep 22, 2026 - 00:00 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

webpy web.py 0.76 is vulnerable to Cross Site Scripting (XSS) via render_jinja.__init__().

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Low
web.py is a niche, legacy Python web framework; limited production footprint
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy