Python

SSRF protection in IBM ContextForge MCP Gateway (mcp-contextforge-gateway) is bypassable via DNS rebinding against the `/admin/gateways/test` endpoint, allowing an attacker with a database-backed `gateways.read` role to reach cloud instance metadata services (including 169.254.169.254) and internal network resources. The root cause is a TOCTOU race between the hostname validation step - which resolves DNS via `socket.getaddrinfo()` and checks the result against blocked private ranges - and the `httpx`-based HTTP client's fully independent DNS re-resolution at connection time, with no IP-pinning or validated-address forwarding bridging the two operations. A detailed proof-of-concept is published in GitHub Security Advisory GHSA-9hgc-g3w5-67cm; the vendor confirmed the fix in release v1.0.3 (2026-06-10); no CISA KEV listing is present at time of analysis.

Unauthenticated remote code execution in MindsDB Minds Platform (version 26.1.0 and earlier) lets any network-reachable attacker run arbitrary OS commands on the host by chaining two unprotected API endpoints. The attacker first sets a controlled LLM API key via the unauthenticated PUT /api/v1/settings/ endpoint, then submits a crafted prompt to POST /api/v1/responses/ that steers the Anton agent into calling its scratchpad tool, which passes attacker-influenced Python directly into exec() with no sandbox. Reported by VulnCheck with a maximum CVSS 4.0 score of 10.0 and CWE-94; no public exploit identified at time of analysis, but the trivial attack complexity and lack of authentication make it high priority.

Stored XSS in django-helpdesk before 2.3.3 enables unauthenticated external attackers to inject arbitrary JavaScript into the authenticated staff interface by submitting HTML-formatted ticket email bodies or uploading .html/.htm file attachments through the public-facing ticket submission channel. The payload persists in the helpdesk database and executes in the browser session of any staff member who opens the attachment during routine triage, enabling session hijacking, credential exfiltration, or unauthorized actions performed under the staff member's identity. No public exploit has been identified at time of analysis and the vulnerability is not listed in the CISA KEV catalog.

Uncontrolled resource consumption in py-libp2p's yamux stream multiplexer allows any remote peer that completes a standard Noise handshake to permanently stall a connection using a single 12-byte frame. Affected versions 0.7.0 and earlier accept an attacker-controlled 32-bit DATA frame length before validating it against the receive window, so a frame claiming a 4 GB body with no body bytes delivered causes the sequential read loop to block indefinitely, freezing every stream on the connection. No patched release exists at time of analysis; a remediation commit is available upstream, and a proof-of-concept demonstrating the stall is documented in the GHSA advisory.

Information disclosure in vLLM prior to version 0.26.0 leaks server filesystem internals - including OS usernames, home and virtual-environment directory paths, Python version, internal package structure, line numbers, and endpoint handler names - through HTTP error responses. Any unauthenticated network attacker can trigger this by sending malformed JSON to the OpenAI-compatible API endpoints, requiring zero privileges and no special configuration beyond a default vLLM deployment. No public exploit code has been identified at time of analysis, and no CISA KEV listing exists; however, the trivial exploitation bar (a single malformed HTTP request) and the reconnaissance value of the leaked data elevate real-world risk above the CVSS 5.3 score alone implies.

Remote code execution and SSRF in FlowiseAI Flowise before 3.1.3 stems from a bypassable regex-based Python code validator in the CSV and Airtable Agent nodes, letting attackers smuggle malicious pandas calls through the unauthenticated prediction API via prompt injection. Because the validator blocklists rather than sandboxes, unblocked functions such as pd.read_json() can be abused to exfiltrate local datasets, reach internal services (SSRF), or execute arbitrary code. No public exploit identified at time of analysis, and it is not listed in CISA KEV; the reporting vendor VulnCheck and a GitHub Security Advisory (GHSA-w7x8-q2gp-5cgg) document the issue.

Authenticated arbitrary Python code execution in FlowiseAI Flowise before 3.1.3 arises from the CSV Agent node's customReadCSV parameter, whose regex-based validator can be defeated with obfuscation to run attacker-supplied code inside an unsandboxed pyodide runtime with full host access. Any user able to build or edit a chatflow can escalate from application-level access to code execution on the server. No public exploit has been identified at time of analysis, and the issue is not listed in CISA KEV; a vendor patch exists in version 3.1.3.

Remote code execution in Flowise before 3.1.3 lets attackers run arbitrary Python on the host by abusing the Airtable Agent node. Crafted chatflow prompts carry obfuscated Python that slips past the pythonCodeValidator blocklist and executes inside an unsandboxed pyodide runtime with full access to the underlying OS. Reported by VulnCheck with a published GHSA advisory; no public exploit code is identified at time of analysis, and it is not listed in CISA KEV.

Command injection in stata-mcp (pip:stata-mcp < 1.19.0) enables full OS-level remote code execution against any principal that can invoke the `ado_package_install` MCP tool. The `package` argument is concatenated unsanitized into a Stata command string delivered via pexpect.sendline(), allowing embedded newline characters to inject arbitrary Stata commands - including the `shell` escape - that execute under the account running the MCP server. Because the tool is registered in the default `all` profile and `all` is the active default, no misconfiguration by the victim is required; a detailed proof-of-concept confirmed via Docker reproduction is publicly available in the GitHub advisory, and a vendor-released patch exists in v1.19.0.

Arbitrary code execution in Fujitsu Research's OneCompression (onecomp) Python library 1.2.0 is triggered when a victim loads a crafted PyTorch checkpoint file via the library's QuantizedModelLoader API, which unconditionally invokes Python's pickle machinery. The root cause is the hardcoded use of torch.load with weights_only=False in load_quantized_model_pt(), allowing an attacker-supplied checkpoint to embed malicious __reduce__ methods that execute arbitrary Python - including OS commands - in the context of the loading process. No public exploit code has been identified at time of analysis, though a patched version (1.2.1) is available on PyPI per the VulnCheck advisory.

URLSecurityValidator SSRF bypass in compliance-trestle <= 4.0.3 allows a network-positioned attacker to reach cloud metadata services, loopback admin interfaces, and RFC 1918 internal networks by embedding IPv4-mapped IPv6 literals (e.g., [::ffff:169.254.169.254]) or the unspecified address 0.0.0.0 in OSCAL artifact import references processed by HTTPSFetcher or SFTPFetcher. Python's ipaddress module silently returns False - rather than raising TypeError - when comparing IPv6Address objects against IPv4Network ranges, so the validator's membership checks pass these forms through to requests.get unchanged. A publicly available proof-of-concept reproduces end-to-end IMDS credential exfiltration; no active exploitation is listed in CISA KEV and EPSS stands at 0.42%.

Authenticated command injection in Prowler (Cloud/API) before 5.36.0 lets a low-privileged user with provider-management access run arbitrary shell commands on the shared backend worker. The Kubernetes provider's connection test accepted a kubeconfig containing a legacy GCP auth-provider with cmd-path/cmd-args, which the kubernetes-python client executed via subprocess when POST /api/v1/providers/{id}/connection loaded it. No public exploit is identified at time of analysis, but the flaw is fixed in 5.36.0 and carries a critical 9.9 CVSS.

Confused-deputy privilege escalation in snowflake.core (Snowflake Python API) prior to version 1.13.0 enables attackers with low-privileged access to a downstream application to perform unauthorized Snowflake operations under the application's higher-privileged session. Two related input-sanitization weaknesses make this possible: path traversal via unencoded `..` segments in REST URL paths (CWE-22), and HTTP parameter pollution via injected `&`, `#`, or `=` characters in query strings (CWE-141), either of which can subvert swap, clone, or rename operations against unintended resources. No public exploit code has been identified at time of analysis and no CISA KEV listing is confirmed; the vendor-released fix is snowflake.core 1.13.0, available on PyPI and requiring manual upgrade.

Arbitrary Python code execution in calibre's template engine affects all versions prior to 9.12.0, triggered when a user opens or imports a crafted EPUB, OPF, PDF, or OPF file containing malicious composite_template metadata. The root cause is a sandbox policy inheritance failure: nested formatter invocations via template(), eval(), re_group(), and list_re_group() instantiated fresh formatter objects without propagating allow_python_templates=False from the parent, allowing an embedded python: sub-template to bypass the restriction and reach compile_python_template. No public exploit has been identified at time of analysis, though the full patch diff is publicly visible on GitHub and makes the attack straightforward to reproduce.

Python code injection in FreeCAD's FEM Displacement Constraint dialog (all versions prior to 1.1.2) enables arbitrary code execution at the FreeCAD process's privilege level when a victim opens and accepts a weaponized project file. The root cause is an incomplete sanitization routine in TaskFemConstraintDisplacement.cpp that strips double-quotes from user-supplied formula fields but leaves backslash characters unhandled, allowing crafted input to escape the Python string boundary constructed by Gui::Command::doCommand(). SSVC rates technical impact as total and confirms a proof-of-concept exists; no CISA KEV listing is present, indicating no confirmed active exploitation campaigns at time of analysis.

AdminRenderer in Django REST Framework prior to 3.17.2 discloses unauthorized GET resource data to authenticated users who hold write-but-not-read permissions on a DRF view. When a POST request fails validation and returns a 400 Bad Request, the renderer internally calls view.get() without first invoking view.check_permissions(), embedding the full GET representation in the HTML error response visible to the requester. No public exploit is confirmed in CISA KEV, but SSVC rates exploitation as POC-level; risk is targeted rather than widespread.

Terminal escape sequence injection in Bash-it's barbuk theme (versions through 3.2.0) permits a local attacker to execute arbitrary OSC and CSI terminal control sequences in the context of a victim user's terminal emulator simply by placing a crafted pyproject.toml in any directory the victim navigates into. The root cause is that the barbuk theme's __python_venv_prompt function reads the requires-python field via awk without stripping control characters, then concatenates the raw value into PS1 through __prompt-command, causing injected sequences to render on every prompt refresh. No public exploit code has been identified at time of analysis and the vulnerability is not listed in the CISA KEV catalog, though the attack is low-complexity given the vendor-confirmed fix commit.

Unauthenticated arbitrary file write in DB-GPT v0.8.1 lets remote attackers achieve remote code execution by smuggling directory-traversal sequences (../) through the user_id HTTP header of the Python file-upload endpoint. Because the header value is used unsanitized as a path component of the upload directory, an attacker can escape the intended python_uploads directory and drop attacker-controlled files into code-execution-sensitive locations such as Python startup hooks, cron directories, or agent scripts. Rated CVSS 4.0 9.3 (Critical); no public exploit identified at time of analysis, though a VulnCheck advisory and an upstream fix commit confirm the flaw.

Uncontrolled resource consumption in Django REST Framework prior to 3.17.2 allows unauthenticated remote attackers to exhaust server memory and CPU by sending arbitrarily large request bodies via application/json or application/x-www-form-urlencoded content types. The framework's Request._parse() method passes the raw HttpRequest stream directly to JSONParser and FormParser, silently bypassing Django's built-in DATA_UPLOAD_MAX_MEMORY_SIZE guard. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis, but the attack requires no authentication and no special configuration, making any exposed DRF API endpoint a viable target.

ORM injection in NetBox 4.5.8's WritableNestedSerializer allows any authenticated user - including those holding only read-only API tokens - to extract sensitive field values across all application modules via boolean-based blind data leakage. By supplying crafted Django ORM lookup expressions as JSON dictionary keys in REST API write requests, attackers bypass object-level permission controls across dcim, ipam, tenancy, virtualization, circuits, and extras. No CISA KEV listing exists, but VulnCheck reported the issue and an upstream fix commit is available; no confirmed public exploit code has been identified at time of analysis.

Sandbox escape in Cursor IDE for macOS prior to version 3.1.2 allows an AI agent operating in Auto-Run Sandbox mode to replace a Python virtual environment executable with a malicious wrapper, which the Microsoft Python extension then invokes outside the sandbox boundary - granting arbitrary host command execution with the user's full macOS privileges, including modifying files outside the workspace and launching applications. The vulnerability exploits a privileged trust relationship between the sandboxed agent and an unsandboxed host-level extension. No active exploitation has been confirmed (not in CISA KEV), and no public exploit code has been identified at time of analysis; a vendor-released patch is available in version 3.1.2.

Security feature bypass in the Python extension for Visual Studio Code (versions prior to 1.132.1) allows a local attacker to load functionality from an untrusted control sphere, achieving full compromise of confidentiality, integrity, and availability. The attack requires user interaction - specifically opening a malicious workspace or project directory - making it highly relevant in developer supply-chain and social engineering scenarios such as cloning a weaponized repository. No public exploit code or CISA KEV listing has been identified at the time of analysis, but the full CIA impact and low attack complexity elevate real-world concern for development environments.

Remote code execution in NASA fprime-gds through version 3.4.3 lets an unauthenticated remote attacker fully compromise the ground data system and inject arbitrary commands to any connected spacecraft. The Flask ground station exposes every endpoint without authentication (CWE-306), while a path traversal in the upload/download handler permits reading and writing arbitrary files, and a hardcoded Flask secret key (CWE-321) enables session forgery; chained, they yield code execution on the ground station host. No public exploit is identified at time of analysis, but the CVSS 9.8 rating and unauthenticated network vector make this a high-priority, real-world risk for anyone running F Prime ground software.

Server-Side Request Forgery in NLTK 3.9.4 and the develop branch enables network-level probing of RFC 6598 shared-address-space hosts (100.64.0.0/10) by exploiting an incomplete block-list in the `validate_network_url()` guard function. The function correctly rejects private and loopback ranges but omits the shared address space defined by RFC 6598, which Python's `ipaddress` module does not classify as either `is_private` or `is_global`, allowing crafted URLs to pass the filter unchallenged. Impact is confined to confidentiality - internal infrastructure reachable through shared carrier-grade NAT space may be probed - and no code execution is achievable through this path; no public exploit or CISA KEV listing has been identified at time of analysis.

Path traversal in parisneo/lollms 2.1.0 exposes arbitrary server files to unauthenticated remote attackers via the SPA catch-all route in `backend/routers/ui.py`. URL-encoded dot-dot sequences (`%2e%2e`) bypass Starlette's built-in path normalization and are decoded by Python's `pathlib.resolve()`, allowing directory escape from the static file root with no privileges or user interaction required. No public exploit has been independently confirmed at time of analysis, though the public fix commit at GitHub fully documents the vulnerable code pattern and the bypass technique, substantially lowering the bar for exploit development.

Catastrophic regex backtracking in pymdown-extensions 11.0 and earlier enables unauthenticated remote denial of service via crafted Markdown input under 50 bytes. The betterem, caret, tilde, and magiclink inline processors use ambiguous alternation groups that allow exponentially many partition paths for delimiter runs, causing the Python regex engine to spin without bound. Any web application rendering user-supplied Markdown with these extensions — including those using the pymdownx.extra bundle — is exposed to rendering-thread freeze with no authentication required, as confirmed by the CVSS PR:N/UI:N vector and GitHub security advisory GHSA-gm37-52c6-37mw. No public exploit or CISA KEV listing has been identified at time of analysis.

Cross-tenant namespace disclosure in LangGraph's PostgreSQL and SQLite checkpoint stores allows an authenticated low-privileged user to read stored items belonging to other namespaces without any crafted input. The flaw arises from translating hierarchical namespaces into dot-joined strings and scoping reads with SQL LIKE patterns that have no understanding of the segment separator, so a query scoped to 'foo' also returns data from 'foobar' or 'foo2'. Exploitation requires the specific precondition of prefix-overlapping or wildcard-containing namespace labels; no public exploit code exists and the vendor confirms no evidence of in-the-wild exploitation.

Traefik's BasicAuth middleware in versions 3.6.11-3.6.24 and 3.7.0-3.7.9 permits an authenticated low-privilege user to forge arbitrary backend identities via a singleflight key collision race condition. By concatenating their known valid password with a retrieved stored bcrypt hash, an attacker crafts a singleflight deduplication key identical to a legitimate in-flight request's key; the middleware returns the legitimate request's successful authentication result to the attacker's request, then propagates the attacker's chosen unconfigured username to the backend as a trusted identity. A fully working proof-of-concept achieving 25-of-25 successful identity forgeries under default bcrypt cost is publicly available in the GitHub security advisory; no CISA KEV listing has been identified at time of analysis.

Cross-user HTTP response poisoning in Traefik's default reverse proxy allows an unauthenticated remote attacker using HTTP/2 or HTTP/3 to smuggle responses into other clients' backend connections, potentially delivering authenticated or private content from one user to another. All supported Traefik branches through v2.11.52, v3.6.23, and v3.7.8 are affected in default configuration when fronting Go net/http or gunicorn/Flask backends, which are confirmed 'armed' (respond to CONNECT with keep-alive non-2xx without draining the body). A proof-of-concept is publicly available demonstrating reliable cross-user poisoning including a cascade scenario where 8 of 8 sequential victims read responses that were not their own; no CISA KEV listing was present at time of analysis.

Path traversal in rclone's `serve restic` REST API allows any attacker with network access to the endpoint to read, create, overwrite, or delete objects outside the operator-configured backend directory. The flaw spans rclone v1.40 through v1.74.4 and affects WebDAV, FTP, SFTP, HTTP, and Memory backends - but not S3-compatible or local filesystem backends, which encode `..` as literal filename characters. A fully functional, step-by-step proof of concept has been publicly released; no CISA KEV listing exists at time of analysis.

Arbitrary Python code execution in PraisonAI's workflow include feature allows an attacker who controls a local recipe directory to execute arbitrary code as the PraisonAI process user. Affected are praisonai 3.9.26-4.6.57 and praisonaiagents 0.12.12-1.6.57. This is a hardening bypass: the vulnerable sink in Workflow._execute_include() skips the PRAISONAI_ALLOW_TEMPLATE_TOOLS/PRAISONAI_ALLOW_LOCAL_TOOLS opt-in gates and the centralized safe loader that protect all other tools.py autoload paths, making it a distinct variant within an established advisory family. No public exploit or CISA KEV listing has been identified at time of analysis.

Remote code execution in IBM Langflow OSS 1.0.0-1.10.3 allows authenticated remote attackers to inject and execute arbitrary Python code by crafting payloads that evade the platform's AST-based security scanning mechanism. The flaw (CWE-94, Code Injection) is particularly insidious because the defensive AST validation layer gives a false sense of protection while silently passing malicious constructs to the Python runtime. No public exploit or CISA KEV listing exists at time of analysis, but the low-complexity, fully network-accessible attack path with complete confidentiality, integrity, and availability impact warrants urgent patching - especially for any internet-exposed or multi-tenant deployments.

Remote code execution in IBM Langflow OSS 1.0.0-1.10.3 allows authenticated low-privilege users to trigger arbitrary Python execution on the backend server by submitting crafted Agentic Assistant workflows containing malicious LLM-generated components that are evaluated server-side during validation before user approval is granted. The flaw (CWE-94, Code Injection) arises because the validation pipeline eagerly executes model-generated Python without sandboxing or deferral, giving attackers backend process-level privileges to exfiltrate data, interact with the file system, or initiate outbound network connections. No public exploit code or CISA KEV listing has been identified at time of analysis; EPSS places exploitation probability at 0.22% (13th percentile), but SSVC rates technical impact as total, making this a high-priority patch target for multi-user or internet-exposed deployments.

Remote code execution in IBM Langflow OSS (versions 1.0.0 through 1.10.3) allows authenticated attackers to execute arbitrary Python code by exploiting a cryptographic weakness (CWE-326) in the custom component validation mechanism. When the optional hardening mode is enabled - the feature intended to restrict execution to trusted component templates - the application validates submitted component code against a truncated SHA-256 digest, making it computationally feasible for an attacker to craft a malicious Python file that collides with a trusted template's hash and bypasses the validation gate entirely. No public exploit code has been identified at time of analysis; a vendor patch is available per IBM advisory, though the exact fixed version is not stated in available data.

Predictable Fernet encryption keys in IBM Langflow OSS 1.0.0 through 1.10.3 allow attackers to decrypt stored API keys and authentication tokens, because when a user secret is shorter than 32 characters the platform derives keys with Python's non-cryptographic `random` (Mersenne Twister) module. Because the Mersenne Twister PRNG is deterministic, identical seeds reproduce identical keys, so an adversary who can reconstruct the seeding conditions can regenerate the key and read every secret Langflow encrypted with it. No public exploit identified at time of analysis; EPSS is low (0.11%) and CISA SSVC records no known exploitation.

Command injection in Fledge's backup-restore upload handler allows an authenticated administrator to execute arbitrary OS commands on the underlying host by uploading a crafted tar archive. The vulnerable function upload_backup() in python/fledge/services/core/api/backup_restore.py constructs a shell command via unsanitized string formatting and passes it directly to os.system(), while filename validation only checks prefix and suffix - a filename such as fledge_backup_$(id>/tmp/pwn).db satisfies both checks while embedding a shell command substitution. CVSS 7.2 (PR:H) reflects the admin privilege prerequisite; no public exploit or CISA KEV listing has been identified at time of analysis, but the technique is trivially reproducible given access.

Arbitrary file write via tar path traversal in Fledge's backup-restore API allows an authenticated admin to overwrite files anywhere on the host filesystem reachable by the Fledge process. The upload_backup() handler in backup_restore.py calls Python's tarfile.extractall() without a filter argument or member-path sanitization, enabling a classic 'tar slip' attack. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but the attack is mechanically trivial for any actor holding admin credentials.

Remote code execution in ESPHome through 2026.7.0-dev allows any attacker who can supply a crafted YAML configuration to execute arbitrary Python code on the machine that processes it. The vulnerability is an operator-precedence bug in the cv.url() validator: Python's 'and' binding tighter than 'or' causes any file:// URI to unconditionally pass validation, bypassing the intended network-URI-only restriction on the external_components git source URL field. ESPHome then invokes git clone against the attacker-supplied local path and loads the resulting repository into Python's import machinery, yielding full code execution with the privileges of the esphome process; no public exploit has been identified at time of analysis.

Five Flask API endpoints in Book-Management-System (/student, /record, /books, /find_stu_book, /find_not_return_book) are missing authentication controls, exposing student PII and borrowing history to any unauthenticated remote caller. Because the card_id parameter is a sequential integer, a trivial enumeration loop can drain the entire student database without credentials. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack requires no sophistication and is fully network-accessible.

Server-side template injection in DjangoCRM's massmail module allows authenticated users with mass-mail edit rights to execute arbitrary Django Template Language expressions by injecting syntax into EmlMessage subject and content fields, which are passed unsanitized to Django's Template() constructor across three separate code locations. Successful exploitation can disclose other users' account data and password hashes from Django request context variables, exfiltrate CSRF tokens enabling cross-site request forgery, and include arbitrary registered templates. No KEV listing or public exploit code has been identified at time of analysis, but the low attack complexity and high-confidence CVSS 8.1 rating indicate meaningful risk for deployments where mass-mail edit rights are granted to non-administrator users.

Full account takeover in DjangoCRM stems from a hardcoded Django SECRET_KEY committed in webcrm/settings.py, letting anyone who reads the public GitHub repository forge session cookies (including the superadmin), CSRF tokens, and password reset tokens. The default DEBUG=True setting compounds this by exposing database, email, and OAuth credentials plus internal paths on error pages. No public exploit is identified at time of analysis, but exploitation is trivial and requires no authentication (CVSS 9.1, PR:N).

Authorization bypass in the TicketDetailView component of Ehco1996 django-sspanel allows authenticated remote users to access support tickets belonging to other users by manipulating a user-controlled key in requests to apps/sspanel/views.py. All releases through 2023.12.26 are affected per ENISA EUVD-2026-52981. No patch will be issued - the maintainer has abandoned the project and did not respond to disclosure - leaving operators with no vendor remediation path. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

Catastrophic regex backtracking in Open WebUI 0.9.6-0.10.x allows any authenticated user to permanently stall a Uvicorn event-loop worker by supplying a crafted pattern to the built-in knowledge-search tool. The vulnerable `grep_knowledge_files` tool compiles attacker-supplied patterns with Python's unbounded `re` engine against attacker-uploaded file content, with no timeout anywhere on the execution path; a 30-character subject string measured at 74 seconds of CPU and a 40-character string extrapolates to roughly one day. No CISA KEV listing exists, but a complete proof-of-concept procedure is published in the GitHub security advisory GHSA-2f54-p244-32q6, making exploitation straightforward for any credential holder.

Tool source code disclosure in Open WebUI (≤ 0.10.2) allows any authenticated non-admin user who holds a read grant on a shared workspace tool to retrieve the full Python source of that tool via three unguarded API endpoints. The root cause is a Pydantic response-model inheritance defect where the `ToolUserResponse` subclass re-admitted the `content` field that the parent `ToolResponse` schema deliberately excluded, combined with a separate query-level defect in the list path. Because tool source commonly embeds hard-coded API keys, credentials, and internal service URLs, the practical confidentiality loss frequently exceeds the code itself; a detailed proof-of-concept is published in the GitHub security advisory, and the vendor-confirmed fix is available in 0.11.0 with no active exploitation (CISA KEV) recorded at time of analysis.

Remote code execution in Flowise (npm flowise / flowise-components <= 3.1.2) lets an unauthenticated attacker who can query a chatflow built on the CSV Agent node coerce the backing LLM, via prompt injection, into returning a Python payload that slips past the regex blocklist validator and runs in an unsandboxed pyodide runtime, yielding arbitrary code execution as the Flowise service account. Trend Micro ZDI (Dre Cura, TrendAI Research) demonstrated eight distinct validator-bypass techniques and shipped a working proof of concept; this is scored CVSS 4.0 9.5 (CWE-94). Publicly available exploit code exists, but there is no CISA KEV listing or evidence of active exploitation at time of analysis.

Remote code execution in Flowise before 3.1.3 arises because its Pyodide Python-code validator (validatePythonCodeForDataFrame) can be defeated with Unicode homoglyph identifiers, letting an attacker run arbitrary Python that escapes the Pyodide sandbox and executes OS commands on the Flowise host with the process's privileges. The affected CSV Agent and Airtable Agent nodes gate LLM-generated (and config-supplied) Python through an ASCII word-boundary regex blacklist, which Python's NFKC identifier normalization silently rewrites back into the forbidden dunders. There is no public exploit identified at time of analysis and it is not in CISA KEV, but the GitHub advisory documents a complete, reproducible bypass technique, so weaponization is straightforward; the vendor rates it 9.5 (CVSS 4.0).

Remote code execution in FlowiseAI Flowise before 3.1.3 lets an attacker execute arbitrary OS commands as the Flowise process by abusing the CSVAgent node, which interpolates an attacker-controlled base64 segment of the csvFile data URI directly into a Python template run by Pyodide. Because Pyodide's default js bridge exposes globalThis (including eval and dynamic import on Node.js), the injected code can break out of the Python string, call js.eval, import fs and child_process, and run host commands; the surrounding validators are never applied to this bootstrap template. A low-privileged workspace user plants the malicious node, after which any unauthenticated request to the public POST /api/v1/prediction/:id endpoint triggers the RCE. No public exploit is identified at time of analysis (no KEV, no POC signal in the provided data), but the fix is confirmed in version 3.1.3.

Denial-of-service via recursive GEOMETRYCOLLECTION parsing crashes Django processes through a segmentation fault in the underlying GEOS library. Django's GEOSGeometry class, GeometryField form field, and spatial field lookups in versions 5.2, 6.0, 6.1 (RC), and main are all affected when processing WKT or WKB input containing deeply nested or excessively numerous GEOMETRYCOLLECTION objects. No public exploit code or active exploitation has been identified at time of analysis; the Django team rated this 'moderate' severity and issued fixed releases Django 5.2.17 and 6.0.8 on August 4, 2026.

Stored cross-site scripting in Django admin's URLField rendering allows a malicious URL value (e.g., using a `javascript:` scheme) to be displayed as a clickable link on changelist views and read-only admin fields without scheme validation. Any application that accepts URLField input via public-facing forms and exposes those records in the Django admin is affected, covering Django 5.2 through the 6.1 release candidate. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis; patches were released August 4, 2026 as Django 5.2.17 and 6.0.8.

Memory exhaustion in Django's `check_for_language()` function allows denial-of-service via the `set_language` view when it is explicitly enabled in URL configuration. Attackers can submit many distinct, very long language codes via POST requests, causing each code to be cached as an in-memory key and progressively consuming process memory. Django rates this severity 'low' because built-in guards - `DATA_UPLOAD_MAX_MEMORY_SIZE` and the cache's maximum entry count - bound the total exploitable memory; no public exploit identified at time of analysis.

Server-side file-write and server-side request forgery (SSRF) in Django's GeoDjango spatial lookups expose authenticated staff users as an attack surface capable of writing arbitrary files to disk or issuing outbound network requests as the Django process user. Affected are Django 5.2 (before 5.2.17) and 6.0 (before 6.0.8), where the Django admin changelist's standard filter mechanism made the flaw reachable by any staff account holding view permissions on a model with a spatial field. Depending on the GDAL raster driver available on the server, file writes can escalate to remote code execution. No public exploit is identified at time of analysis; patched releases Django 5.2.17 and 6.0.8 were issued August 4, 2026.

Remote code execution in Flowise (flowise and flowise-components <= 3.1.2) is possible through the CSVAgent node, which executes user-supplied Python in a pyodide runtime. A regex denylist blocks imports and dangerous builtins, but attackers bypass it entirely by calling the pre-imported pandas library's read_pickle() to deserialize an attacker-controlled base64 pickle, achieving arbitrary command execution. A detailed working proof-of-concept (pickle __reduce__ gadget plus a custom file-like reader class to feed the payload) is published in the vendor GHSA advisory; publicly available exploit code exists, but there is no public exploit identified as being used in the wild and it is not in CISA KEV.

Remote code execution in FlowiseAI Flowise (npm packages flowise and flowise-components) versions 3.1.2 and earlier lets an authenticated user achieve root command execution on the host by injecting Python into the CSV Agent's Pyodide sandbox, which bridges back to the host Node.js process. Attackers reach OS command execution, credential theft, arbitrary file read, and server crash. A working Metasploit module and root Meterpreter session are documented, so publicly available exploit code exists, though the flaw is not listed in CISA KEV.

Remote code execution in kotaemon (Cinnamon) versions through 0.12.0 allows unauthenticated attackers to run arbitrary commands via the check_connection endpoint, which insecurely deserializes attacker-supplied YAML/JSON. By setting the __type__ field to subprocess.check_output with chosen arguments, an attacker instantiates arbitrary Python objects and executes OS commands with the application's process privileges. Publicly available exploit code exists (VulnCheck advisory and upstream issue), and the CVSS 4.0 base score is 9.3, though there is no public exploit identified as actively exploited.

Code injection in VibeSurf's Python Validation Handler enables remote unauthenticated attackers to inject and execute arbitrary Python code by manipulating the /code endpoint. All versions up to commit cd6e519d507cdd4d63061300bf60fb176e1f57e0 are confirmed affected per EUVD-2026-52704. No patch is available - the vendor did not respond to disclosure - and a public proof-of-concept exists (CVSS 4.0 E:P, corroborated by an asciinema recording in the references), making exploitation accessible to low-skilled attackers.

Remote code execution in Perspective 5.0.0 exposes any network-reachable PolarsVirtualServer backend to arbitrary OS command execution via Python eval() injection. The server passes client-supplied expression strings to eval() with only __builtins__={} cleared - a well-known insufficient sandbox - enabling attackers to traverse Python's loaded class hierarchy to reach subprocess.Popen through crafted TableValidateExprReq or TableMakeViewReq protobuf messages. A public exploit is confirmed by VulnCheck, and five vulnerabilities were disclosed simultaneously in the researcher's blog post, suggesting a broader attack surface in this release. No KEV listing is identified, but the published PoC substantially lowers the exploitation barrier.

Certificate path building in python-cryptography before 49.0.0 is exploitable as a denial-of-service vector by attackers who can supply crafted X.509 chains containing duplicate self-signed intermediate certificates. The Rust-based `build_chain_inner` function explores issuer candidates recursively without deduplicating previously analyzed entries, causing computational work to grow exponentially with the number of duplicates present - empirically exceeding 5 seconds per rejection in testing. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified; the fix shipped in 49.0.0 bounds path-building via a global signature-check budget.

Wildcard DNS SAN matching in python-cryptography's X.509 chain verifier prior to 49.0.0 allows a leaf certificate bearing *.example.com to satisfy a constrained intermediate CA's permittedSubtrees restriction of foo.example.com, enabling scope escape to sibling domains such as bar.example.com. Applications relying on the PolicyBuilder/Store verification API are exposed to acceptance of invalid certificate chains that should be rejected per RFC 5280 §4.2.1.10. A public proof-of-concept is confirmed in the GHSA advisory; the vulnerability is not in the CISA KEV catalog, but the CVSS 4.0 E:P modifier reflects the POC's availability.

PKCS#7 EnvelopedData decryption in the Python cryptography library (versions 44.0.0-49.x) leaks a Bleichenbacher oracle through four distinguishable error messages and timing side-channels during RSA PKCS#1 v1.5 key unwrapping, exposing the exact recovered plaintext length in one case. An attacker who can submit crafted EnvelopedData to an auto-decrypting service - such as an S/MIME gateway or mail filter that reflects outcomes at high volume - can adaptively recover the content-encryption key and decrypt intercepted messages. No public exploit has been identified at time of analysis, and exploitation requires very specific deployment conditions; the fix in version 50.0.0 applies RFC 3218 indistinguishability by substituting a random key on any failure.

Out-of-bounds heap read in aiohttp's C HTTP response parser (versions ≤ 3.14.2) allows an attacker-controlled server to crash the client application via a malformed chunked HTTP response, causing denial of service. The flaw exists only when the compiled C extension is active - the default installation mode - and is triggered during error-message construction in aiohttp/_http_parser.pyx when the llhttp error-position pointer is materialized as a raw pointer rather than a bounded offset into the Python bytes buffer. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in CISA KEV.

HTTP request smuggling in aiohttp's server-side parser allows unauthenticated remote attackers to inject and misdirect HTTP traffic by exploiting a protocol-switch race in the WebSocket upgrade path. Versions 3.14.1 and earlier prematurely mark the connection as upgraded before the full request body is consumed, causing trailing bytes - potentially an attacker-controlled HTTP request - to be interpreted as WebSocket or pipelined data by the server or any upstream proxy. No public exploit code exists and the vulnerability is not listed in CISA KEV, but CVSS 4.0 AC:H reflects the edge-case nature of the trigger condition.

Channel lifecycle enforcement failure in russh (Rust SSH library, versions <= 0.62.4) allows authenticated clients to invoke server-side handler callbacks - including exec_request, shell_request, subsystem_request, data, channel_eof, and channel_close - for SSH channel IDs that were never opened or confirmed by the transport layer. An authenticated peer can send crafted SSH_MSG_CHANNEL_REQUEST packets without ever issuing SSH_MSG_CHANNEL_OPEN, or after having a channel_open_session request explicitly denied by the application, and still trigger all channel-scoped callbacks. A working Python PoC is publicly available demonstrating 32 exec_request invocations with zero channels ever opened; no active exploitation is confirmed (not in CISA KEV) and a vendor patch exists in v0.62.5.

Arbitrary code execution in the Hugging Face sentence-transformers Python library allows attackers who control the contents of a model directory to run code even when the caller explicitly passes trust_remote_code=False. The import_module_class helper in sentence_transformers/util/misc.py short-circuits its trust gate with an 'or os.path.exists(model_name_or_path)' clause, so any local path that exists satisfies the check and triggers dynamic loading of custom Python (e.g. modeling_*.py referenced in modules.json) at model-load time. This is classic CWE-94 code injection with no public exploit identified at time of analysis; the vendor commit deprecates rather than removes the behavior, deferring the actual fix to v6.0.

Remote code execution in ComfyUI v0.23.0 (and all prior 0.x releases) lets unauthenticated attackers run arbitrary Python by abandoning the LoadTrainingDataset node to torch.load a malicious pickle. Because the upload and prompt-queue endpoints require no authentication, an attacker who can reach the web interface can upload a crafted shard_*.pkl file and trigger deserialization to execute commands as the ComfyUI process user. VulnCheck reported the flaw and a vendor fix exists; there is no public exploit identified at time of analysis, though the technique (pickle __reduce__ abuse) is trivial to reproduce.

Null byte injection in the free5GC Authentication Server Function (AUSF) v4.2.1 and earlier allows unauthenticated remote attackers to crash Go's URL parser and force HTTP 500 responses on the authentication endpoint, denying authentication service to all legitimate 5G subscribers sharing that AUSF instance. A publicly available Python PoC is included in the vendor's own security advisory, and fuzzing demonstrated a 4.1% trigger rate across nearly 100,000 requests - confirming reliable, scalable exploitation against the default deployment with no special configuration required. No public exploit or CISA KEV listing is confirmed at time of analysis, but the trivially automatable nature of the attack makes it a material risk for 5G core operators.

Remote denial of service in Thumbor's convolution filter (versions <= 7.7.7) allows an attacker to crash the Thumbor worker process with a single crafted HTTP request by passing columns=0 to the filters:convolution() URL parameter. The Python-layer input validation accepts zero via an overly permissive regex (PositiveNumber matches '0'), which propagates to a C extension that performs integer division by zero, triggering SIGFPE and killing the process on x86_64 Linux and macOS Intel. No public exploit identified at time of analysis per KEV, but a fully functional proof-of-concept is documented in the vendor's own GHSA advisory, making exploitation trivially reproducible.

HMAC-SHA1 URL signature bypass in Thumbor (pip/thumbor ≤ 7.7.7) allows unauthenticated remote attackers to defeat the signed URL security mechanism by injecting duplicate signature strings into the request path. Python's global `str.replace()` removes all occurrences of the signature during pre-validation stripping, causing the validated URL to differ from the actual requested resource. No public exploit code is identified at time of analysis, though the detailed disclosure and fix commit make independent exploitation straightforward; this is not listed in CISA KEV.

DNS rebinding defeats `nltk.pathsec.urlopen()`'s SSRF filter in NLTK 3.9.4 and earlier, allowing unauthenticated remote attackers to reach loopback addresses, private networks, and cloud instance metadata endpoints - even with `ENFORCE = True` - and receive full, non-blind HTTP responses. The root cause is a TOCTOU gap: validation resolves the hostname once, but `urllib` independently re-resolves it at connect time via a separate `getaddrinfo` call, connecting to whatever the attacker's TTL-0 rebinding record returns on the second lookup. A working proof-of-concept is publicly available in the GHSA advisory, and the `lru_cache` annotation on `_resolve_hostname` creates a false assurance that rebinding is already mitigated, meaning operators who adopted this boundary believe themselves protected when they are not.

Path traversal in NLTK's NKJPCorpusReader component (versions ≤ 3.9.4) allows attackers who control the `fileids` argument to read arbitrary files outside the configured corpus root, fully defeating the `nltk.pathsec` sandbox even when `ENFORCE=True` is active. The root cause is that `add_root()` builds file paths via plain string concatenation - not the hardened `FileSystemPathPointer` - and downstream code calls the Python builtin `open()` directly, bypassing the `validate_path()` check that NLTK's own SECURITY.md explicitly promises will block unauthorized access. A detailed public PoC is confirmed against nltk 3.9.4; no active exploitation is listed in CISA KEV at time of analysis.

Path traversal in NLTK's FramenetCorpusReader (versions ≤3.9.4) allows a caller-supplied frame name containing ../ sequences to escape the corpus root and read arbitrary XML files accessible to the process, silently bypassing the nltk.pathsec sandbox even when ENFORCE=True is explicitly enabled. Any web service or pipeline that routes user-controlled input into FramenetCorpusReader.frame() is directly exposed, with full parsed content of frame-shaped XML files returned to the caller and a file-existence oracle for all other XML paths. A working proof-of-concept is publicly available in the GitHub security advisory; the vulnerability is not listed in CISA KEV at time of analysis.

pgAdmin 4 SERVER mode (versions 9.3 through 9.16) allows authenticated users to fully bypass administrator-configured per-tool role-based access controls by exploiting incomplete permission enforcement across backend routes and Socket.IO handlers. The Flask-Security `permissions_required` decorator was applied only to a single front-door route per tool, while all secondary routes and Socket.IO event handlers checked only authentication, not tool permissions - meaning a user who received a 403 on the initial gated endpoint could still drive the complete tool workflow through its other endpoints. Affected tools include Query Tool, Grant Wizard, Schema Diff, ERD, PSQL (interactive terminal), Debugger, Backup, Restore, Maintenance, and Import/Export. No dedicated public exploit has been identified, though the fix commits and GitHub issue are publicly visible; exploitation requires a valid authenticated pgAdmin session.

Uncontrolled decompression in aiohttp's WebSocket client prior to version 3.14.2 allows a malicious server to exhaust CPU and memory on connecting clients by sending RSV1-flagged compressed frames without having negotiated the permessage-deflate extension. The root cause is a missing constructor argument in `client.py:_ws_connect` that caused `WebSocketReader` to default to `compress=True`, violating RFC 6455 §5.2 which mandates failing the connection on undefined reserved bits. This is client-side exposure only - aiohttp server deployments are not affected. No active exploitation has been identified and no public exploit code exists at time of analysis.

Arbitrary code execution in the Banks Python LLM-templating library (versions prior to 2.4.3) allows an attacker who can influence Tool JSON definitions within a {% completion %} block to run any importable Python callable in the host process. Banks resolves the attacker-controlled import_path field via importlib.import_module() plus getattr() with no allowlist, so values like os.system or subprocess.getoutput become invokable when the LLM emits a matching tool_calls entry, passing decoded arguments as kwargs. No public exploit identified at time of analysis; this bug is explicitly distinct from and unfixed by the 2.4.2 SandboxedEnvironment patch (GHSA-gphh-9q3h-jgpp / CVE-2026-44209) because the malicious payload is plain text in the rendered body and never touches Jinja attribute access.

Arbitrary file disclosure in the Banks Python prompt-templating library (masci/banks) before 2.4.4 lets attackers who control template variables read any file the Python process can access. All four media filters (image, audio, video, document) wrap untrusted input in Path(value) and feed it straight to open(file_path, "rb") with no sanitization, so path traversal (../) reads files like .env, SSH keys, cloud credentials, source, /etc/passwd and /etc/shadow, returning them base64-encoded in the rendered prompt for trivial exfiltration. No public exploit identified at time of analysis and it is not in CISA KEV, but the fix in 2.4.4 is straightforward to reverse-engineer.

Server-side request forgery in the Eclipse CSI PIA `POST /v1/upload/sbom` endpoint lets remote attackers coerce the server into connecting to an arbitrary host, port, and scheme of their choosing. By exploiting a parser-differential between Python's `urlparse` (used for the issuer allowlist check) and `requests`/`urllib3`/`urllib` (used for OIDC discovery and JWKS retrieval), an attacker crafts a JWT `iss` claim containing a backslash that passes validation but resolves to a different host during the actual fetch. The `iss` claim is only checked in its unverified form, so no legitimate token is needed; no public exploit has been identified at time of analysis and the issue is not listed in CISA KEV.

Server-Side Request Forgery in Pydantic AI's UI adapter layer (versions 1.65.0-1.105.0 and 2.0.0b1-2.0.0b5) allows unauthenticated network clients to redirect the application server into fetching arbitrary cloud-storage objects using the server's own credentials. UploadedFile references - carrying provider file IDs or cloud-storage URIs such as s3:// or gs:// - submitted via client message history bypass the scheme allowlist applied to ordinary file URLs and are resolved server-side using the application's IAM role, service account, or API key. No public exploit has been identified at time of analysis, and no CISA KEV listing exists, but the scope-changing confidentiality impact (CVSS S:C/C:H) warrants prompt patching for any deployment exposing the Vercel AI adapter or similar UI adapters to untrusted clients.

Tool call injection in Pydantic AI's UI adapters (AG-UI via Agent.to_ag_ui()/AGUIAdapter, and Vercel AI via VercelAIAdapter) enables remote unauthenticated clients to force execution of registered server-side tools with attacker-supplied arguments, bypassing the framework's message-sanitization defense. The flaw affects pydantic-ai and pydantic-ai-slim versions 1.88.0-1.107.0 and 2.0.0b1-2.4.x. No public exploit code or CISA KEV listing exists at time of analysis, but the attack is low-complexity and exploitable against default configurations of applications using either UI adapter.

Credential and authentication-token disclosure in Linuxfabrik monitoring-plugins (versions 6.0.0 and earlier) affects the redfish-* check plugins used with Icinga, Nagios, and compatible systems. The plugins build Redfish request URLs by blindly concatenating the operator-supplied base URL with @odata.id links returned in the BMC response, so a malicious or compromised BMC can redirect the plugin's authenticated follow-up requests to an attacker-controlled host and harvest the X-Auth-Token session token or HTTP Basic credentials sent with them. There is no public exploit identified at time of analysis and it is not listed in CISA KEV; the CVSS 4.0 base score is 8.3.

Cross-origin credential header leakage in linuxfabrik-lib prior to v6.0.0 exposes API tokens from authenticated monitoring requests to attacker-controlled redirect targets. The lib.url.fetch() function relied on httpx's default redirect behavior, which strips only Authorization and Cookie on cross-origin hops - leaving custom credential headers like X-Auth-Token and X-Api-Key forwarded verbatim to whatever host the redirect points to. This is particularly severe for Redfish/BMC monitoring workflows where X-Auth-Token grants privileged hardware management access. No public exploit has been identified at time of analysis, and active exploitation is not confirmed in CISA KEV.

Symlink-following in Linuxfabrik monitoring-plugins 6.0.0 allows a local low-privileged user sharing the plugin account to overwrite or corrupt arbitrary root-owned files. The logfile check's legacy database migration resolved a predictable /tmp path via os.rename() without guarding against symlink substitution, and sqlite3.connect() would then follow the attacker-planted link during a root-executed check run. No public exploit has been identified, and exploitation is additionally constrained by the non-default kernel setting fs.protected_symlinks=0, meaningfully reducing real-world risk on hardened systems.

JWT malleability in joserfc versions 1.7.1 and prior allows a low-privileged user holding a valid token to craft alternate byte-distinct representations by exploiting the library's acceptance of non-conforming trailing Base64 padding (==), which violates the JOSE specification. Applications using deny-list-based token revocation or anti-replay protection are at risk of bypass, since a padding-modified token hashes to a different value that will not match the stored revoked-token record. No public exploit code has been identified and this vulnerability is not listed in CISA KEV; the vendor-released fix is joserfc 1.7.2.

Cross-container isolation bypass in proot-distro 5.1.5 and earlier (Termux) lets a crafted backup archive read and write files across otherwise isolated containers when a victim runs 'proot-distro restore'. Because the restore logic trusts the archive's hardlink 'linkname' to name the source container without verifying it matches the container being restored, an attacker who convinces a user to restore a malicious .tar can exfiltrate secrets (SSH keys, API credentials, databases) from one container into an attacker-controlled one, or inject attacker data into a different container. Publicly available exploit code exists (full PoCs are embedded in the GHSA advisory); no public active exploitation is known.

Unsafe tar extraction in Penelope Shell Handler (pip package penelope-shell-handler, versions prior to 0.19.3) enables a malicious or compromised remote session to write arbitrary files on the penetration tester's (operator's) machine by returning a crafted tar archive containing path-traversal entries such as `../`. The vulnerability is exclusively triggered by the Unix `download` command path and can be chained to operator-side code execution by overwriting `~/.penelope/peneloperc`, which Penelope `exec()`s on startup and on `reload`. A fully working proof-of-concept is included in the GitHub Security Advisory, demonstrating the complete file-write-to-RCE chain. No public record of active exploitation (CISA KEV) has been identified at time of analysis.

Code injection in datamodel-code-generator 0.17.0–0.60.1 allows attackers who control a schema’s default_factory value to inject arbitrary Python expressions into generated models, achieving remote code execution when the target imports the poisoned module. The vulnerability affects all supported input types (JSON Schema, OpenAPI, YAML, JSON, Avro, Protobuf, XSD) and output model types (Pydantic v2, dataclass, msgspec). Public exploit code exists; the issue is fixed in version 0.60.2.

Code injection via unescaped validator entries in datamodel-code-generator's --extra-template-data feature allows arbitrary Python code execution when a generated Pydantic v2 model is imported. Affects versions 0.52.1 through 0.60.1, with a fix in 0.60.2. Publicly available exploit code exists, though no active exploitation has been reported to CISA KEV.

Code injection via unsanitized schema extensions in datamodel-code-generator allows arbitrary Python code execution when the generated model is imported. Affects versions from 0.11.6 to 0.63.0. Public exploit code exists, but no active exploitation has been confirmed by CISA KEV.

Code injection in datamodel-code-generator versions before 0.60.1 allows an attacker who provides a malicious GraphQL schema to execute arbitrary Python code when a developer generates and imports the resulting model. The flaw exists because carriage return (\r) characters in Union type descriptions are not neutralized before being placed inside Python line comments, letting the rest of the description escape the comment and run as module‑level code upon import. A fix is available in version 0.60.1; no active exploitation is reported, and no public exploit is known.

Code injection in datamodel-code-generator allows an attacker who controls a JSON Schema to embed arbitrary Python code in generated model files, leading to arbitrary command execution when the module is imported. Affected versions 0.51.0 through 0.60.1 lack proper validation of the `x-python-type` extension, making the attack possible with default tool settings. No public exploit is identified at time of analysis, but the vulnerability is patched in version 0.60.2.

Sensitive header disclosure in datamodel-code-generator allows Authorization, Cookie, and Proxy-Authorization headers to be leaked to cross-origin redirect targets when fetching remote schemas. Affects versions prior to 0.63.0. A public proof-of-concept exploit exists, but no active exploitation has been reported and the CVSS score is low (3.7).

We need to produce a JSON object with all fields as plain text strings. We have extensive data: CVE description, CVSS vector 3.1, CWE-918 (SSRF), EPSS not provided but we need to estimate? The prompt says "synthesize data from multiple intelligence sources about a CVE into a comprehensive analysis". The sources include references, EPSS, KEV status, patch availability, CPE strings, and tags. In the provided data, I see no EPSS or KEV. So we should note that EPSS is unknown/missing, KEV status not present. Patch is available: fixed in 0.61.0. CPE is pkg:pip/datamodel-code-generator. Tags: Python, SSRF. We need to produce a JSON object. Let's map each required field. 1. **product_name**: "1-3 words ONLY. The specific product or service name affected." It's a Python package: datamodel-code-generator. So product_name = "datamodel-code-generator". 2. **summary**: "2-3 sentence plain-language summary... Do NOT copy or paraphrase the Description... Start with the specific impact verb and product". So: "Server-side request forgery (SSRF) in datamodel-code-generator allows unauthenticated remote attackers to reach internal services via the --url CLI option, exfiltrating responses into generated Python code. The vulnerability affects versions 0.9.1 through 0.60.2 when the [http] extra is installed, and can be triggered by following redirects to private networks. No public exploit activity is confirmed, but a proof-of-concept exists and the vulnerability has been patched in version 0.61.0." We need to mention EPSS and KEV: none. So "no public exploit identified at time of analysis" (since KEV is not true). But we have PoC, so "publicly available exploit code exists". The summary should incorporate that. 3. **technical_context**: Explain underlying technology, CWE-918 (SSRF), how httpx is used, http.get_body implementation, etc. Include CPE data: pip/datamodel-code-generator. Mention that the vulnerability arises from insufficient validation of URLs in the HTTP fetcher, wit