Skip to main content

web.py CVE-2026-79310

| EUVDEUVD-2026-85403 HIGH
Code Injection (CWE-94)
2026-09-23 mitre GHSA-8m9w-mh94-cwr6
8.5
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Obtain write access to template directory
  2. Delivery
    Plant malicious precompiled template
  3. Exploit
    Application renders via precompiled loader
  4. Execution
    Sandbox security checks bypassed
  5. Persist
    Attacker Python executes on server
  6. Impact
    OS command execution / host compromise

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

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

Exploitation Conditions

Exploitation requires a specific deployment: the web.py 0.76 application must precompile templates from a directory that the attacker can write to, and must later render those templates through the precompiled template loader - that combination is what bypasses the built-in template sandbox. Concrete prerequisites/limiters: (1) attacker must first obtain write access to the template source directory (e.g. via an upload feature, misconfigured permissions, or existing low-privilege foothold - reflected as PR:L); (2) the application must use the precompiled-template code path rather than direct sandboxed rendering; (3) exploitation is not automatic against a default install (reflected as AC:H). It is NOT a remote-unauthenticated exploit against stock configurations; the writable-template-directory and precompiled-loader conditions are the decisive gating factors defenders should confirm before prioritizing.

Impact

This is a genuine RCE-class flaw (CWE-94, code injection leading to arbitrary Python and OS command execution) but its real-world risk is materially reduced by its preconditions rather than being a broadly sprayable network exploit. The vendor CVSS vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H, 8.5 HIGH) is internally consistent with the description: AC:H and PR:L reflect that exploitation is not turnkey - the attacker must already have some access AND the application must be deployed in a specific way (precompiling templates from a directory the attacker can write to, then rendering via the precompiled loader). No EPSS score was supplied, the CVE is NOT on CISA KEV, and the only exploitation-related reference is a TraceLoom write-up that reads as vulnerability analysis rather than a packaged, weaponized exploit - so exploitation status is: no public exploit identified at time of analysis. The S:C (scope change) claim is defensible (escaping the template sandbox to run host-level code) but arguably should be S:U, as ordinary host RCE within a single security authority; this is the one metric worth verifying with the reporter. Net: a real, patch-worthy issue for anyone running web.py 0.76 with precompiled templates from writable directories, but not a mass-exploitation priority given the conditional deployment requirement, authenticated/write prerequisite, and absence of KEV/EPSS/confirmed POC signals.

Exploit ScenarioDerived

An attacker who can write files into a directory that a web.py 0.76 application uses for template precompilation drops a malicious template containing code the built-in sandbox is meant to reject. When the application later loads and renders that template through the precompiled template loader, the security checks are bypassed and the attacker's Python executes on the server, yielding OS command execution. A public exploit is not confirmed - only a third-party analysis write-up (TraceLoom) exists - and the attack chain hinges on the attacker first obtaining write access to the template directory.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.7% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 23, 2026

Server-side template injection in web.py 0.76 allows an attacker who can write to the application's template source directory to achieve arbitrary Python code and OS command execution on the server, but only when the application precompiles those templates and later renders them through the precompiled template loader; that specific deployment pattern is what defeats the template engine's built-in sandbox. The flaw is a genuine RCE-class issue (CWE-94) at CVSS 8.5, yet it is gated by real prerequisites: the CVSS vector indicates authenticated access (PR:L) and high attack complexity (AC:H), because the attacker must first obtain write access to the template directory and the application must use the precompiled code path rather than direct sandboxed rendering. It is not a remote-unauthenticated exploit against stock configurations, and no public exploit identified at time of analysis; exploitation is not confirmed actively exploited (CISA KEV) and no KEV entry is present in the source data.

RemediationAI

No vendor-released patch identified at time of analysis, so remediation must focus on eliminating the two conditions that make the flaw reachable. First, ensure the directory holding template sources is never writable by the web application or by any user or upload path an attacker can reach: set template directories to read-only for the service account, move user-supplied uploads to a separate filesystem location outside any template path, and validate or reject uploaded files that could be interpreted as templates. Second, stop using the precompiled template loading path for templates that originate from or can be influenced by a writable directory - compile templates from a trusted, immutable location through the normal sandbox-checked path instead. Taking the precompiled route off the table has a performance trade-off (precompilation exists to reduce per-request compilation cost), so if precompilation is required for throughput, restrict it to an immutable, root-owned deployment artifact directory and rebuild it only as part of a controlled release process. Additional compensating controls: run the web.py process as an unprivileged account with no write access to application code or template directories to limit post-exploitation impact, apply least privilege to any file-write or upload functionality (the CVSS vector shows PR:L, meaning only low-privilege access is needed once those write preconditions are met), and monitor for unexpected modifications to template files or the appearance of new precompiled template artifacts. Track https://github.com/webpy/webpy and https://github.com/lichoin/TraceLoom/blob/main/CVEs/CVE-2026-79310.md for an upstream fix and upgrade to the first patched release once a version is published; because no fixed version is currently identified, do not assume that upgrading alone resolves exposure until a fix is confirmed.

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

web.py's template engine works by translating template markup into Python code and executing that generated code to produce rendered output. To keep untrusted templates from reaching dangerous Python builtins, the engine applies security checks and restricts the execution environment during normal template compilation and rendering - the sandbox the description refers to. The vulnerability arises from the precompilation path: when an application precompiles templates from a directory and later loads those precompiled templates through the precompiled template loader instead of compiling the original source through the checked path, the built-in validation is bypassed and attacker-authored template code is executed directly as Python. The root cause maps to CWE-94 (Improper Control of Generation of Code / Code Injection): attacker-controlled template content is turned into executable Python without the security checks that the normal code path enforces, so the payload escalates from template expression to arbitrary Python execution and, from there, OS command execution under the web process's privileges. The CPE supplied in the source data is an uninformative placeholder (cpe:2.3:a:n/a:n/a), so product scoping must rely on the stated product/version: web.py 0.76, as reported via MITRE and cross-referenced by ENISA EUVD-2026-85403. The assessment vector (AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H) confirms a network-reachable, authenticated, complexity-limited path with high confidentiality and integrity impact, and the assessment's exploitation conditions are explicit that the writable-template-directory plus precompiled-loader combination, not a default install, is the decisive enabler.

Know when Python gets its next vulnerability

  • 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 8.5 HIGH
AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 7.5 HIGH

AC:H and PR:L because attacker needs write access to the template directory plus a precompiled-loader deployment; full triad from RCE; S:U as host RCE stays within one security authority (vendor's S:C debatable).

3.1 AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:H/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

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

Lifecycle Timeline

3
CVSS changed
Sep 23, 2026 - 19:22 NVD
8.5 (HIGH)
CVE Published
Sep 23, 2026 - 00:00 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 23, 2026 - 00:00 cve.org
HIGH 8.5

DescriptionCVE.org

webpy web.py 0.76 is vulnerable to server-side template injection (SSTI). The template engine can be tricked into executing attacker-controlled template code that built-in security checks are designed to reject. When an application precompiles templates from a directory the attacker can write to and later renders them through the precompiled template loader, the sandbox is bypassed and the attacker's code runs, resulting in arbitrary Python code execution and OS command execution on the server.

Executive ViewAI

Why It Matters

A high-severity server-side template injection vulnerability in web.py 0.76 could enable an authenticated attacker with write access to template directories to execute arbitrary code on affected servers, potentially leading to full system compromise. No public exploit identified at time of analysis, but the organizational impact may include data loss, service disruption, and lateral movement. Leadership should prioritize mitigation because no vendor-released patch is currently available and affected applications may be business-critical.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include: restrict write access to template directories to essential personnel only; disable precompilation and use direct sandboxed rendering if feasible; implement file integrity monitoring and alerting on template directory changes; audit and reduce authenticated accounts with filesystem write privileges; and isolate affected web.py 0.76 applications to limit lateral movement.

Threat Intelligence Overview

EPSS Score
0.7%
Top 48% exploitable
Prevalence
Low
web.py is an older, now-niche Python web framework; limited modern production footprint
Data Quality
6 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.7%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

More in Python

View all
CVE-2025-24016 CRITICAL POC
9.9 Feb 10

Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t

CVE-2025-27520 CRITICAL POC
9.8 Apr 04

BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser

CVE-2025-2945 CRITICAL POC
9.9 Apr 03

pgAdmin 4 contains critical remote code execution vulnerabilities in the Query Tool download and Cloud Deployment endpoi

CVE-2013-5093 MEDIUM POC
6.8 Sep 27

The renderLocalView function in render/views.py in graphite-web in Graphite 0.9.5 through 0.9.10 uses the pickle Python

CVE-2025-32375 CRITICAL POC
9.8 Apr 09

BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica

CVE-2014-0224 HIGH POC
7.4 Jun 05

OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph

CVE-2024-21644 HIGH POC
7.5 Jan 08

pyLoad download manager version prior to 0.5.0b3.dev77 exposes the Flask SECRET_KEY through an unauthenticated endpoint.

CVE-2026-33017 CRITICAL POC
9.3 Mar 17

Langflow (a visual LLM pipeline builder) contains a critical unauthenticated code execution vulnerability (CVE-2026-3301

CVE-2017-9462 HIGH POC
8.8 Jun 06

In Mercurial before 4.1.3, "hg serve --stdio" allows remote authenticated users to launch the Python debugger, and conse

CVE-2026-49869 CRITICAL POC
10.0 Jun 26

Unauthenticated remote code execution affects Kestra OSS (the open-source event-driven orchestration platform) prior to

CVE-2026-39987 CRITICAL POC
9.3 Apr 08

Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/

CVE-2024-21645 MEDIUM POC
5.3 Jan 08

pyLoad is the free and open-source Download Manager written in pure Python. Rated medium severity (CVSS 5.3), this vulne

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