Skip to main content

langfun CVE-2026-75062

| EUVDEUVD-2026-66505 CRITICAL
Eval Injection (CWE-95)
2026-08-26 Google GHSA-8x83-862f-c85r
9.2
CVSS 4.0 · Vendor: Google
View

Attack ChainAIDerived

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

  1. Access
    Reach app exposing lf.query
  2. Delivery
    Submit crafted adversarial prompt
  3. Exploit
    Model emits executable Python expression
  4. Execution
    Unsandboxed eval runs the code
  5. Impact
    Arbitrary code execution as host process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Eval input sanitization
MITRE ATT&CK

1 technique across 1 tactic: 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 application to use langfun (version < 0.1.2) with its default lf.query Python protocol - the code-generating/eval path - and to route attacker-influenced content into that query. The concrete prerequisite is that untrusted prompt text reaches lf.query while the Python protocol (unsandboxed evaluation of model output) is in use, which is the default. Limiting factors: exploitation is probabilistic because it hinges on the model being steered into emitting executable Python (reflected as AT:P in the CVSS 4.0 vector), and applications that never expose lf.query to untrusted input, or that have moved to a non-eval structured output path, are not exploitable. No user interaction or authentication is required (UI:N, PR:N).

Impact

The signals are largely consistent and point to a genuine high priority, with one important nuance. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H) shows a network-reachable, low-complexity, unauthenticated path to full impact - but the AT:P (attack requirements present) metric is the key qualifier: successful exploitation depends on the LLM actually generating attacker-controlled executable Python, which is probabilistic rather than deterministic. This is why the 9.2 score, though CRITICAL, is not a clean 10. No EPSS score, KEV listing, or POC is provided, so there is no evidence of active exploitation or a published exploit; the danger is architectural (unsandboxed eval of model output) rather than demonstrated in the wild. Note a data gap: EPSS is absent, so quantitative exploitation likelihood cannot be compared against the CVSS severity. Given langfun is an emerging-technology building block for AI agents, organizations that expose lf.query to untrusted prompts - from a large cloud operator down to a small AI product team - should treat unsandboxed code evaluation as urgent and patch promptly, while recognizing that mass, automated exploitation is constrained by the probabilistic AT:P factor.

Exploit ScenarioDerived

An attacker submits a crafted prompt to an application that forwards user input into langfun's default lf.query Python protocol; the input coaxes the backing model into emitting a Python expression containing malicious code (for example an os.system or import call), which langfun evaluates without a sandbox and thereby executes on the server. No authentication is required (PR:N) and the attack is network-borne (AV:N), though success depends on the model actually producing the executable payload (AT:P). No public POC is identified at time of analysis.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 26, 2026

Remote code execution in Google langfun before 0.1.2 arises because the default lf.query Python protocol evaluates model-generated Python expressions with no sandbox, letting remote unauthenticated attackers run arbitrary code in the host application by supplying crafted prompt inputs that steer the model into emitting executable code. Because langfun embeds directly in LLM-driven Python applications, any deployment that pipes untrusted prompt content through lf.query is exposed. There is no public exploit identified at time of analysis and it is not in CISA KEV, but the CVSS 4.0 base score of 9.2 (CRITICAL) reflects full confidentiality, integrity, and availability impact.

RemediationAI

Vendor-released patch: 0.1.2 - upgrade langfun to 0.1.2 or later, which is the primary and authoritative fix (pin the dependency and rebuild any images or environments that vendored an older release). If immediate upgrade is not possible, apply compensating controls: avoid the default lf.query Python protocol for any query whose inputs are attacker-influenced, and instead use a structured/schema output path that does not eval model output; strictly separate untrusted end-user prompt content from lf.query calls so adversarial text cannot reach the evaluator; and run the host process under least privilege (dedicated low-privilege account, container with a read-only filesystem, seccomp/egress restrictions) so that a successful eval yields minimal blast radius. The trade-off of disabling the Python protocol is loss of the convenient object-reconstruction behavior, requiring code changes to consumers. Track fix details via the project repository https://github.com/google/langfun and issue https://github.com/google/langfun/issues/725.

Affected VersionsENISA

langfun 0.0.1 <0.1.2

Affected Packages

euvd langfun fix: 0.1.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

langfun is Google's open-source Python framework for building structured, object-oriented programs on top of large language models. The vulnerable component is the default lf.query Python protocol, which is designed to have the model return Python expressions that langfun then evaluates to reconstruct typed objects. Per CWE-95 (Eval Injection / Improper Neutralization of Directives in Dynamically Evaluated Code), the root cause is that this evaluation path passes model output to a Python evaluator (eval/exec-style execution) without a restricting sandbox, so any executable expression the model can be induced to produce runs with the full privileges of the host process. The single affected CPE is cpe:2.3:a:google:langfun, confirming the issue is scoped to the langfun library itself rather than a downstream product.

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 (Google) PRIMARY 9.2 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.1 HIGH

Network-reachable and unauthenticated (AV:N/PR:N), but AC:H because success depends on inducing the model to emit executable Python; unsandboxed eval yields full C/I/A with no scope change.

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

Primary rating from Vendor (Google).

CVSS VectorVendor: Google

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 26, 2026 - 16:17 EUVD
CVE Published
Aug 26, 2026 - 14:50 cve.org
CRITICAL 9.2

DescriptionCVE.org

Improper Neutralization of Directives in Dynamically Evaluated Code ('Eval Injection') in the default lf.query Python protocol in Google langfun versions prior to 0.1.2 allows remote unauthenticated attackers to execute arbitrary Python code in the context of the host application via crafted prompt inputs that cause the model to generate executable Python expressions evaluated without a sandbox.

Executive ViewAI

Why It Matters

Google langfun library before version 0.1.2 contains a critical remote code execution vulnerability that allows unauthenticated attackers to execute arbitrary Python code by injecting malicious prompts into LLM-driven applications. Organizations running production deployments that process untrusted user input face immediate risk to system integrity, confidentiality, and availability. No vendor patch is currently available, requiring urgent interim mitigation measures.

Business Impact: Severe
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) Restrict lf.query usage to trusted, pre-validated prompts only; (2) Run affected applications in isolated Python environments with filesystem and network access restrictions; (3) Implement strict input validation and sanitization to block malicious prompt injection patterns; (4) Restrict network access to affected systems and enable detailed logging for exploitation attempt detection.

Threat Intelligence Overview

EPSS Score
0.2%
Top 86% exploitable
Prevalence
Low
niche Google Python LLM-programming library, limited production footprint
Social Media
2
Sightings
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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
Very High
Technical Impact
Total

Priority Score

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

Attack Technique

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