Skip to main content

libtins CVE-2026-112274

| EUVDEUVD-2026-104299 MEDIUM
Out-of-bounds Read (CWE-125)
2026-10-19 VulnCheck GHSA-4c37-573g-qpf9
6.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Send crafted DNS SOA RDATA without NUL terminator
  2. Exploit
    Trigger OOB read in DNS::soa_record::init
  3. Execution
    strlen overruns heap buffer
  4. Impact
    Crash 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).

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.5% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

libtins 0 ≤4.6

Affected Packages

euvd libtins no fix

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

Vendor (VulnCheck) PRIMARY 6.3 MEDIUM
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
vuln.today AI 4.8 MEDIUM

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).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
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

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

EPSS Score
0.5%
Top 57% exploitable
Prevalence
Low
niche C++ packet-crafting library, specialized network tooling only
Social Media
1
Sightings
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.5%
Patch available No
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
Poc
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

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.

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