Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply crafted INI buffer to load_ini_buffer
-
ExploitTrigger allocation-size mismatch (malloc(ini_length))
-
ExecutionNUL write past heap buffer in strip_ini_cache
-
ImpactCrash 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
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.
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
Lifecycle Timeline
3DescriptionCVE.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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
EUVD-2026-98804
GHSA-m7m8-wx6c-7cmw
NVD
CVE.org
EPSS
Exploit-DB