Skip to main content

Buffa CVE-2026-55407

| EUVDEUVD-2026-44951 MEDIUM
Uncontrolled Resource Consumption (CWE-400)
2026-07-16 GitHub_M GHSA-f9qc-qg88-7pq5
6.3
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Identify network-exposed buffa protobuf endpoint
  2. Delivery
    Craft 64 MiB payload with nested StartGroup unknown fields
  3. Exploit
    Submit unauthenticated protobuf request
  4. Execution
    Decoder materializes ~22× amplified heap objects
  5. Persist
    Process exhausts available memory
  6. Impact
    Service crash (denial of service)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

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

Exploitation Conditions

Exploitation requires three conditions to be simultaneously satisfied. First, the target application must be compiled against a version of Buffa prior to 0.8.0. Second, the affected application code must have been generated with preserve_unknown_fields=true, which is the default setting for all Buffa code generation - this means the vast majority of Buffa deployments are vulnerable without any non-default configuration. Third, the application must decode untrusted network input as a protobuf message (i.e., the service must be reachable by the attacker and accept serialized protobuf). Exploitation is not limited by authentication (PR:N) or user interaction (UI:N). The primary limiting factor for exploitation is the preserve_unknown_fields condition - however, since it is the default, defenders should assume all Buffa services are affected unless code-generation settings are explicitly audited. The attack does not require knowledge of the target message schema, as unknown fields are processed regardless of the defined message type.

Impact

The CVSS 4.0 score of 6.3 with VA:L (low vulnerable-system availability impact) appears to understate real-world severity given the 22× amplification ratio described - a single moderately sized request crashing a process constitutes a complete denial of service, which typically warrants VA:H. The AT:P attack requirement (attack prerequisites present) reflects the dependency on preserve_unknown_fields=true, but since this is the default configuration for all generated code, the effective attack surface is nearly every buffa deployment. PR:N and UI:N confirm unauthenticated, interaction-free exploitation. EPSS data is not provided; however, the deterministic, low-complexity nature of crafting the exploit payload (well-formed protobuf with nested StartGroup fields) makes opportunistic scripted exploitation feasible once the vulnerability becomes broadly known. No KEV listing and no known POC constrain current observed exploitation. The primary limiting factor is prevalence - Buffa is a niche library - but organizations using it in internet-facing services should treat this as a high operational priority.

Exploit ScenarioDerived

An attacker with network access to any service that accepts serialized protobuf input sends a crafted 64 MiB message containing deeply nested StartGroup unknown fields. The buffa decoder materializes each unknown record into a ~40-byte heap struct without bound, driving allocation to approximately 1.4 GiB; the OS OOM killer or process allocator terminates the service. The attack requires no authentication and no specific prior knowledge of the target schema - unknown fields are by definition not validated against any schema - making it applicable to any exposed protobuf endpoint backed by buffa-generated code under default settings.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.6% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Jul 16, 2026

Uncontrolled heap amplification in Buffa's protobuf decoder allows an unauthenticated remote attacker to crash any network-facing Rust service that decodes untrusted protobuf input under the default code-generation settings, with no exploit code required beyond a well-formed serialized message. The amplification mechanism - roughly 22× for nested StartGroup unknown fields - means a 64 MiB payload can force approximately 1.4 GiB of heap allocation, exhausting process memory and terminating the service. No active exploitation is confirmed (not in CISA KEV), and no public proof-of-concept has been identified at time of analysis, but the attack is trivially constructible from the public advisory.

RemediationAI

The primary fix is to upgrade Buffa to version 0.8.0, available at https://github.com/anthropics/buffa/releases/tag/v0.8.0. This release introduces a per-decode unknown-field count limit (default: 1,000,000 fields, capping overhead at approximately 40 MB) enforced via a new DecodeContext that propagates through the entire decode call tree, and surfaces limit violations as DecodeError::UnknownFieldLimitExceeded. Regenerating protobuf code with the new codegen (required due to the breaking DecodeContext API change replacing bare depth: u32) is mandatory - applications using code generated by earlier releases will not benefit from the fix until regenerated. As a compensating control for services that cannot immediately upgrade, restricting the maximum accepted request body size at the network layer (reverse proxy or load balancer) reduces - but does not eliminate - amplification headroom, since the attack is bounded by input size; note this does not remove the fundamental unbounded allocation. Disabling preserve_unknown_fields via code-generation config eliminates the vulnerable path entirely but may break round-trip compatibility for applications that rely on preserving unknown fields. The tune-able limit is also configurable via DecodeOptions::with_unknown_field_limit for callers that need a tighter bound.

Affected VersionsENISA

buffa < 0.8.0

Affected Packages

cargo buffa fix: 0.8.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in cargo

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

Technical ContextAI · show details

Buffa (CPE: cpe:2.3:a:anthropics:buffa:*:*:*:*:*:*:*:*) is a pure-Rust Protocol Buffers implementation with protobuf editions support, authored by Anthropic. The root cause is CWE-400 (Uncontrolled Resource Consumption): the decode_unknown_field function materializes each unknown wire field encountered during deserialization into a heap-allocated UnknownField struct (~40 bytes per record) without tracking or bounding the cumulative allocation against a budget. The existing with_max_message_size cap governed only the byte length of the serialized input, not the number of decoded field objects produced from it. Two wire types drove amplification: StartGroup unknown fields, where nesting allowed recursive materialization producing ~22× memory expansion (e.g., 2-byte varint unknown fields inflated to ~40-byte heap objects), and length-delimited unknown fields, which were bounded only by input size. The vulnerability affected any caller using code generated with the preserve_unknown_fields=true option, which is the default for all generated messages, making the attack surface coincident with any network-exposed buffa-based service that processes untrusted serialized data.

Know when Buffa 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 6.3 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Default preserve_unknown_fields=true makes any network-exposed buffa service unauthenticated and exploitable at low complexity; process crash via OOM is high availability impact.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

1
Patch available
Jul 16, 2026 - 18:18 EUVD

DescriptionCVE.org

Buffa is a pure-Rust Protocol Buffers implementation with first-class protobuf editions support. Prior to 0.8.0, the decode_unknown_field function in buffa's protobuf decoder allocated heap memory in proportion to untrusted input (unknown fields in the serialized protobuf) without enforcing an allocation budget, affecting any message decoded from untrusted input using code generated with preserve_unknown_fields=true (the default); a small, well-formed payload of nested unknown fields inside a StartGroup could trigger roughly 22x memory amplification (for example a 64 MiB input forcing about 1.4 GB of heap allocation), and length-delimited unknown fields could be sized arbitrarily, so an unauthenticated attacker could crash a process through memory exhaustion because the top-level message size cap did not account for in-decode amplification. This issue is fixed in version 0.8.0.

Threat Intelligence Overview

EPSS Score
0.6%
Top 57% exploitable
Prevalence
Rare
niche Rust protobuf library, limited enterprise footprint
Threat Intel
1
1 sources
Social Media
4
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

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

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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