Skip to main content

dataclasses-avroschema CVE-2026-108384

| EUVDEUVD-2026-98981 HIGH
Code Injection (CWE-94)
2026-10-13 GitHub_M
8.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted Avro schema to victim
  2. Delivery
    Victim runs schema-to-code generation
  3. Exploit
    Bare-string alias emitted as unquoted annotation
  4. Execution
    Generated module imported
  5. Impact
    Expression evaluated, arbitrary code executed

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 that the victim use the library's Avro-schema-to-Python model generation (ModelGenerator/BaseGenerator.parse_fixed) - not merely the schema-generation direction - on an attacker-influenced schema, and then import the generated module. The specific trigger is a fixed-type definition whose 'aliases' field is supplied as a bare string containing a Python expression instead of a JSON list; only then is the value emitted unquoted into the types.confixed annotation and evaluated at import time. Limiting factors: affects only versions 0.38.0 through 0.70.5; requires active developer interaction (running codegen plus importing the output, hence UI:R); and requires the schema source to be untrusted/attacker-controlled. Environments that only generate schemas from trusted local dataclasses/Pydantic models, or that never run the code-generation path, are not exposed.

Impact

This is a genuine high-severity code-execution flaw (CWE-94) rather than an inflated-CVSS paper risk, but its real-world exploitability is narrower than the 8.8 AV:N score alone suggests. The provided CVSS vector (AV:N/AC:L/PR:N/UI:R) correctly captures the two decisive facts: no authentication is needed and the attacker only supplies a crafted Avro schema, but the UI:R flag is doing heavy lifting - a developer must actively run the schema-to-Python code-generation feature on the attacker's schema AND import the resulting module for code to execute. No EPSS score, KEV listing, or POC is present in the supplied data; exploitation status is therefore 'no public exploit identified at time of analysis.' The AV:N rating is defensible but borderline - exploitation hinges on untrusted schema content reaching a build/codegen step rather than on a listening network service, so treat AV:N as 'attacker-controlled schema delivered to victim' rather than a directly reachable remote endpoint. Priority should be driven by whether an organization actually uses this library's code-generation path on externally sourced schemas; where that pipeline exists the impact is full RCE and patching to 0.70.6 is urgent, but blanket-critical treatment is not warranted given the required developer interaction and the absence of any active-exploitation or exploit-availability signal.

Exploit ScenarioDerived

An attacker publishes or submits a malicious Avro schema containing a fixed-type whose 'aliases' value is a bare string (e.g. embedding a Python expression) instead of a list. A developer feeds that schema into dataclasses-avroschema's model-generation feature; the bare string is emitted unquoted into a types.confixed annotation, and when the generated module is imported the embedded expression is evaluated, yielding arbitrary code execution in the developer's/build environment. No public exploit code is identified in the provided data.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 13, 2026

Arbitrary code execution in dataclasses-avroschema versions 0.38.0 through 0.70.5, where BaseGenerator.parse_fixed writes a fixed type's 'aliases' value straight into the generated types.confixed annotation: a bare string alias (instead of a JSON list) is emitted as an unquoted Python expression and evaluated the moment the generated module is imported. Exploitation is not automatic - it requires a developer to run the library's Avro-schema-to-Python code generation over an attacker-influenced schema and then import the resulting module, which is why the vector carries UI:R despite PR:N and network-level delivery of the malicious schema. The flaw is a genuine CWE-94 code-injection issue with high confidentiality, integrity and availability impact under our assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H; no public exploit code has been identified at time of analysis and it is not in CISA KEV. Version 0.70.6 fixes it by rejecting any 'aliases' value that is not a list.

RemediationAI

Upgrade to dataclasses-avroschema 0.70.6 or later, the first release that rejects non-list 'aliases' values and stops interpolating schema-controlled data as code; the fix is commit 429f3d705d2d04c0c65e2ef832daed5ff91318fc and release details are at https://github.com/marcosschroh/dataclasses-avroschema/releases/tag/0.70.6 (advisory: https://github.com/marcosschroh/dataclasses-avroschema/security/advisories/GHSA-8j5c-xq6f-2c43). If you cannot upgrade immediately, stop running the Avro-schema-to-Python code generation path against untrusted or third-party schemas (treat schemas like executable input, since they are), and never import generated modules whose source schemas came from outside your trust boundary - the trade-off is that you lose the convenience of schema-driven model generation entirely for untrusted sources. Pre-validate any schema before code generation by enforcing that a fixed type's 'aliases' is a JSON array of strings and rejecting bare-string aliases, which blocks the specific injection vector but does not address the broader pattern of unescaped values the 0.70.6 commit also fixed (metadata fields, enum defaults, docstrings, pydantic class names), so it should be seen as a partial mitigation only. Note the side effect of the fix: schemas that relied on a bare-string 'aliases' value will now raise InvalidSchemaValue and must be corrected to a list, and generated code from untrusted schemas should be reviewed and sandboxed (for example generated and imported inside a restricted container or CI job with no credentials or network access) until the upgrade is complete.

Affected VersionsENISA

dataclasses-avroschema 0.38.0, < 0.70.6

Affected Packages

euvd dataclasses_avroschema fix: 0.70.6

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

dataclasses-avroschema is a Python library that bridges Avro schemas and Python models in both directions: it generates Avro schemas from dataclasses, Pydantic models and Faust Records, and it also generates Python source from Avro schemas via ModelGenerator/BaseGenerator. The vulnerable path is the code-generation direction, specifically BaseGenerator.parse_fixed, which renders a fixed type into a types.confixed annotation. Aliases for a fixed type are expected to be a JSON list, which the generator represents as quoted entries; when the schema instead supplies a bare string, that string is interpolated unquoted and therefore becomes executable Python in the annotation position. Because annotations are evaluated when the generated module is imported, an attacker-controlled schema such as {"type": "fixed", "name": "X", "size": 1, "aliases": "__import__('os').system('...')"} achieves arbitrary code execution in the developer's environment (CWE-94, Improper Control of Generation of Code). The upstream fix in commit 429f3d705d2d04c0c65e2ef832daed5ff91318fc hardens the whole template-rendering surface: it introduces an InvalidSchemaValue exception for values that land in generated source as code rather than as string literals, adds validate_aliases/validate_name/validate_type_expression checks, and applies escape_string and escape_docstring to metadata, defaults, enum members and docstrings, so only list-valued aliases are accepted. Affected code is the Python package published under CPE cpe:2.3:a:marcosschroh:dataclasses-avroschema:*:*:*:*:*:*:*:*.

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 (GitHub_M) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

Crafted schema needs no auth or special config (PR:N, AC:L) but a developer must run codegen and import the output (UI:R); import-time evaluation yields full host RCE (C/I/A:H, S:U).

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Oct 13, 2026 - 19:19 EUVD
CVE Published
Oct 13, 2026 - 17:53 cve.org
HIGH 8.8

DescriptionCVE.org

dataclasses-avroschema generates Avro schemas from Python dataclasses, Pydantic models, and Faust Records and generates Python code from Avro schemas. From version 0.38.0 through 0.70.5, BaseGenerator.parse_fixed interpolates a fixed type's aliases value directly into a generated types.confixed annotation. A list is represented with quoted entries, but a bare string is emitted as an unquoted Python expression and evaluated when the generated module is imported, allowing arbitrary code execution from a crafted schema. Version 0.70.6 fixes the vulnerability by rejecting aliases values that are not lists.

Technical POC Analysis

CWE-94 (Improper Control of Generation of Code / Code Injection) in BaseGenerator.parsefixed, dataclassesavroschema/modelgenerator/lang/python/base.py: if aliases is not None: # line 704 properties +…

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A code-injection flaw in the Python library dataclasses-avroschema (versions 0.38.0 through 0.70.5) allows an attacker-supplied Avro schema to inject executable code into Python modules generated by the library's schema-to-class tooling, which then runs when a developer imports the generated file. The practical exposure sits with engineering teams and CI/CD pipelines that generate Python from schemas they do not fully control - for example schemas pulled from third-party registries, vendor feeds, or untrusted repositories - where a successful compromise could expose source code, credentials and build secrets, or allow tampering with released artifacts. Because exploitation requires a developer to run the generator and import the result, this is a targeted supply-chain risk rather than a self-propagating one, but the blast radius inside build environments is significant.

Business Impact: Medium
Compensating Controls

Vendor-released patch: 0.70.6 (upgrade and regenerate derived modules; validate against the vendor advisory, as our patch flag currently reads 'not available'). Where immediate upgrade is not possible, the following interim mitigations apply: do not run Avro-schema-to-Python code generation against schemas from untrusted or unverified sources; restrict schema ingestion to an allow-listed, integrity-verified source; review or statically analyse generated modules for unquoted alias expressions before import; and execute code generation and any import of generated modules inside an isolated, least-privilege container or sandbox without access to production credentials, secrets, or write access to release artifacts.

Threat Intelligence Overview

EPSS Score
0.3%
Top 74% exploitable
Prevalence
Low
niche Python data-engineering library for Avro codegen, developer-tool footprint
Social Media
1
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 HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
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
Medium
Technical Impact
Total

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
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