Skip to main content

libconfini CVE-2026-95124

| EUVDEUVD-2026-98804 HIGH
Classic Buffer Overflow (CWE-120)
2026-10-13 mitre GHSA-m7m8-wx6c-7cmw
7.5
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted INI buffer to load_ini_buffer
  2. Exploit
    Trigger allocation-size mismatch (malloc(ini_length))
  3. Execution
    NUL write past heap buffer in strip_ini_cache
  4. Impact
    Crash application (denial of service)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer copy size validation
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 that the consuming software actually incorporates libconfini's bundled example utility load_ini_buffer (examples/utilities/load_ini_buffer.h) - this is NOT reachable through the core library API alone. The affected code path allocates malloc(ini_length) but strip_ini_cache() writes a NUL terminator at ini_source[ini_length], one byte beyond the buffer, so an attacker must supply an INI buffer that reaches the cache-stripping path with a length that triggers the off-by-one. LIMITING FACTORS: impact is availability-only (process crash, no code execution or data disclosure indicated); the vulnerable example code must be shipped and fed attacker-influenced input; reliability of converting a single-byte heap NUL overflow into a consistent crash is allocator- and layout-dependent. Affected release is v1.16.4.

Impact

Signals are mostly aligned toward a LOW-to-MODERATE real-world priority despite the 7.5 'High' CVSS. The NVD vector (AV:N/AC:L/PR:N/UI:N) technically describes unauthenticated remote exploitation, but the impact metrics are availability-only (C:N/I:N/A:H) - there is no confidentiality or integrity loss, and the root cause is a single off-by-one heap write (malloc(ini_length) vs. the ini_length+1 bytes strip_ini_cache() needs for its NUL terminator). EPSS is low (0.29%, 20th percentile), there is no CISA KEV listing, and no vendor-confirmed active exploitation, so this is a high-CVSS-but-low-real-risk issue rather than an urgent threat. A key caveat: the flaw lives in a BUNDLED EXAMPLE utility (examples/utilities/load_ini_buffer.h), NOT the core libconfini parsing API, so the AV:N 'remote' framing is optimistic - it only applies if a consuming application actually ships that example code AND feeds it attacker-controlled, specifically-sized INI data. For most deployments the practical reachability and the reliability of turning a 1-byte NUL overflow into a crash are both uncertain, so treat the network/unauthenticated characterization with caution and verify whether the example utility is actually in use.

Exploit ScenarioDerived

An application that reuses libconfini's bundled load_ini_buffer example utility parses an INI buffer sourced from an untrusted input of a specific length; strip_ini_cache() then writes a NUL terminator one byte past the under-sized heap allocation, corrupting adjacent heap state and potentially crashing the process (denial of service). A reproducer/write-up appears to exist in the referenced GitHub gist, but no weaponized remote exploit is confirmed.

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

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

Alert me

AnalysisAIv1 – Oct 15, 2026

An off-by-one heap buffer overflow in libconfini 1.16.4's bundled example utility load_ini_buffer (examples/utilities/load_ini_buffer.h) can crash the process that embeds it, producing a denial of service. The flaw is only reachable when consuming software actually compiles and feeds attacker-influenced input to that example utility; it is not reachable through the core libconfini parsing API alone, and impact is availability-only with no code execution or data disclosure indicated. Exploitation requires an unauthenticated network-reachable path into the affected utility (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L per independent assessment, versus the submitter's N/A:H rating), and no public exploit has been identified; EPSS is 0.29% (20th percentile), consistent with a low-to-moderate real-world priority.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed - the correction is the one-line change in load_ini_buffer.h from malloc(ini_length) to malloc(ini_length + 1), captured in commit a87afab391b309692ac30bed8eecbdbcdc5fd96f on PR https://github.com/madmurphy/libconfini/pull/21, so integrators should either pick up a libconfini release that incorporates that commit or patch the utility locally; because no tagged release containing the fix is confirmed in this data, pinning to a specific patched version number is not possible, and NVD (https://nvd.nist.gov/vuln/detail/CVE-2026-95124) plus issue https://github.com/madmurphy/libconfini/issues/20 should be monitored for an official version. If updating is not immediately feasible, the most effective compensating control is to stop building and shipping the example utility entirely: load_ini_buffer is demonstration code, not a library API, so removing it from the build eliminates exposure with the only trade-off being loss of a sample convenience function in downstream test tooling. If the utility must remain, enforce a hard cap and strict validation on any attacker-influenced INI buffer length before it reaches load_ini_buffer (the overflow is only triggered when the cache-stripping path is entered with the mismatched length), and run the consuming service under memory-safety hardening and restart supervision (ASAN builds in staging, allocator hardening, aggressive restart) so that a single-byte heap NUL overflow degrades to a crash rather than a persistent outage - noting that these are containment measures, not root-cause fixes, and that full input validation carries the side effect of rejecting oversized but otherwise legitimate INI payloads.

Affected VersionsENISA

n/a n/a

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

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

Technical ContextAI · show details

libconfini is a C library for parsing INI files. The vulnerable code is not part of the core parser but of a bundled example utility, load_ini_buffer(), which allocates a scratch buffer with malloc(ini_length) and passes it as the cache argument to strip_ini_cache(). strip_ini_cache() documents that it writes a NUL terminator at ini_source[ini_length] - that is, one byte past the end of the caller's allocation - so the cache buffer must be ini_length + 1 bytes. The allocation-size mismatch yields a single-byte heap overflow (CWE-120/classic off-by-one) that lands in heap metadata or an adjacent chunk. The upstream fix in PR #21 (commit a87afab391b309692ac30bed8eecbdbcdc5fd96f) changes the allocation to malloc(ini_length + 1) with an explanatory comment. Because the fault is confined to the example utility rather than a library entry point, reachability depends entirely on the downstream integrator shipping and invoking load_ini_buffer; CPE data for this CVE is recorded as n/a and EUVD lists the affected version as "n/a n/a", so no authoritative CPE-to-version mapping is available and the affected release must be taken as libconfini v1.16.4 per the description.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (mitre) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 5.3 MEDIUM

Single-byte NUL overflow past a heap buffer yields at most an unreliable crash with no code execution or data impact, so availability is Low (A:L), confidentiality/integrity None.

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

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

Lifecycle Timeline

3
CVSS changed
Oct 15, 2026 - 15:22 NVD
7.5 (HIGH)
CVE Published
Oct 13, 2026 - 00:00 cve.org
HIGH 7.5
CVE Published
Oct 13, 2026 - 00:00 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

Buffer Overflow vulnerability in madmurphy libconfini v.1.16.4 allows a remote attacker to cause a denial of service via an allocation-size mismatch between its bundled load_ini_buffer utility and strip_ini_cache()

Executive ViewAI

Why It Matters

A denial-of-service flaw in libconfini 1.16.4 is confined to a bundled example utility (load_ini_buffer) rather than the library's core parsing API, so exposure is limited to applications that explicitly compile and feed untrusted input into that sample code. Organizations shipping or embedding that utility in a network-reachable service face process crashes, but there is no evidence of data disclosure or code execution and no vendor patch is currently available. Because the affected component is non-core sample code, most enterprises can eliminate exposure through build-time removal rather than emergency patching.

Business Impact: Low
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: exclude or delete the bundled example utility (examples/utilities/load_ini_buffer.h) from all production builds; use the core libconfini parsing API instead; enforce strict size limits and validation on any INI input reaching the utility; remove network reachability to the affected process and apply rate limiting or restart-on-crash supervision to bound denial-of-service window; monitor for anomalous process termination patterns.

Threat Intelligence Overview

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Low
niche INI-parsing C library; flaw sits in a bundled example utility
Data Quality
5 sources
Confidence: Medium

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

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Low

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

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