Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted DNS SOA RDATA without NUL terminator
-
ExploitTrigger OOB read in DNS::soa_record::init
-
Executionstrlen overruns heap buffer
-
ImpactCrash application or leak adjacent heap data
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The target application must be built on libtins through 4.6 AND use the DNS buffer constructor to parse attacker-controlled SOA resource records; the attacker must supply raw SOA RDATA that lacks a terminating zero byte so that strlen runs past the buffer. Limiting factors: exploitation only reaches vulnerable code in applications that actually parse untrusted/network-sourced DNS SOA data via this constructor (not all libtins consumers do), and reliable crashing depends on heap layout and the absence of a nearby NUL byte (reflected as AC:H/AT:P). No authentication or user interaction is required (PR:N/UI:N), but the specific unterminated-SOA parsing path is the hard prerequisite. |
| Impact | This is a medium-severity (CVSS 6.3) issue whose real-world urgency is lower than the raw score suggests. Positive-for-attacker signals are AV:N, PR:N and UI:N - a remote, unauthenticated attacker needs no privileges or victim interaction. These are counterbalanced by AC:H plus AT:P (CVSS 4.0), meaning reliable triggering depends on specific attack requirements and heap layout, not a one-shot deterministic exploit. No CISA KEV listing and no EPSS score were provided, so there is no evidence of active or at-scale exploitation and no way to quantify exploitation probability from the input; absence of these signals plus the specialized affected product points to low practical urgency. Demonstrated impact is limited: the vendor CVSS 4.0 vector scores VC:N/VI:N/VA:L (availability-only crash), yet the input Tags and the CWE-125 over-read nature imply potential confidentiality/information disclosure - this is a genuine conflict (Information Disclosure tag vs VC:N). The over-read is consumed internally by strlen, so a crash (DoS) is the confirmed outcome while adjacent-heap disclosure is plausible but unconfirmed. Bottom line: a real but not emergency priority - patch if you run libtins through 4.6 and parse untrusted DNS SOA records, otherwise schedule normally. |
| Exploit ScenarioDerived | An attacker operating or spoofing a DNS server returns a crafted SOA resource record whose RDATA omits the trailing NUL/zero byte to an application built on libtins (≤4.6) that parses the response via the DNS buffer constructor. When soa_record::init calls strlen on the unterminated field, it reads past the heap buffer, crashing the consuming application (denial of service) and potentially incorporating adjacent heap bytes into the parsed name. A public technical write-up describes the flaw, but no weaponized exploit code is confirmed, and reliable crashing depends on heap layout (AC:H/AT:P). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Out-of-bounds read in libtins through 4.6 can crash applications that parse attacker-supplied DNS SOA records through the library's buffer constructor and may expose limited adjacent heap data. The flaw occurs in DNS::soa_record::init when SOA RDATA lacks a NUL terminator, causing strlen to run past the heap buffer; remote unauthenticated attackers can trigger it only against applications that actually feed untrusted SOA data into this constructor. No public exploit or CISA KEV entry was identified at time of analysis, and the assessed CVSS 3.1 score is 6.3 with high attack complexity due to heap-layout and NUL-byte preconditions.
RemediationAI
No vendor-released patch identified at time of analysis, so remediation currently depends on compensating controls: do not pass untrusted DNS SOA RDATA into the libtins buffer constructor, and pre-validate or reject SOA records that lack a NUL terminator before parsing, or use a length-aware DNS parser instead. Applications can also isolate DNS parsing in a separate process or sandbox to limit the effect of a crash, with the trade-off of added architectural complexity, and restrict which network sources may supply DNS data to reduce exposure. Monitor https://github.com/mfontanini/libtins and https://www.vulncheck.com/advisories/libtins-through-4.6-out-of-bounds-read-via-dns-soa-record-init for an upstream fix, then upgrade to the patched release when it is published; strict SOA validation may reject malformed records that some environments previously tolerated.
Affected VersionsENISA
Affected Packages
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
libtins is a C++ library for network packet crafting and sniffing, and its DNS parser handles SOA resource records in src/dns.cpp around lines 698-710. The vulnerable path assumes C-string semantics for SOA RDATA: DNS::soa_record::init uses strlen to measure data from a supplied buffer, but DNS wire-format domain names are length-prefixed rather than NUL-terminated, so attacker-crafted SOA RDATA without a zero byte can drive the read past the allocated heap buffer. This is CWE-125 (out-of-bounds read); the CPE cpe:2.3:a:libtins:libtins:*:*:*:*:*:*:*:* identifies the libtins product family, with the issue reported through version 4.6. The assessed CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:L reflects remote unauthenticated reachability but high attack complexity because reliable triggering depends on heap layout and the absence of a nearby NUL byte, and the impact is limited to possible adjacent-memory read and denial of service rather than guaranteed code execution or full confidentiality loss.
Know when Libtins 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
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Remote unterminated SOA data parsed without privileges or interaction (AV:N/PR:N/UI:N), but reliable triggering is heap-layout dependent (AC:H); impact is a crash (A:L) with possible minor heap over-read disclosure (C:L).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
libtins through 4.6 contains an out-of-bounds read vulnerability in DNS::soa_record::init that allows remote attackers to read past buffer bounds by supplying SOA data lacking NUL terminators. Attackers can feed raw SOA RDATA without a zero byte to applications using the buffer constructor, causing strlen to overrun the heap buffer and possibly crash.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-104299
GHSA-4c37-573g-qpf9
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB