Skip to main content

DragonFly BSD EUVDEUVD-2026-101819

| CVE-2026-110912 HIGH
Improper Handling of Length Parameter Inconsistency (CWE-130)
2026-10-15 mitre GHSA-r2jj-8gwv-75pj
7.1
CVSS 4.0 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Gain access to adjacent L2 broadcast domain
  2. Exploit
    Craft ARP request with oversized ar_hln/ar_pln
  3. Execution
    Trigger OOB read in in_arpreply() memcpy
  4. Impact
    Exfiltrate kernel heap/stack bytes and pointers via ARP reply

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Length parameter validation
Exploitation Conditions

No special product configuration is required: the flaw is in the default ARP input path (arpintr()/in_arpinput() calling in_arpreply()) that processes every incoming ARP request on DragonFly BSD through 6.4.2 before commit 4bb22ff. The decisive limiting factor is network position - the attacker must be unauthenticated but on the adjacent Layer-2 broadcast domain (AV:A), as ARP is not routed across subnets, so remote off-link attackers cannot reach the vulnerable handler. A single crafted ARP request suffices, with no user interaction and no authentication, but impact is confined to disclosure of roughly 250 bytes each of kernel heap and stack memory per request.

Impact

This is a genuine but bounded risk. The CVSS 4.0 vector (AV:A/AC:L/AT:N/PR:N/UI:N) confirms an adjacent-network, low-complexity, unauthenticated attack requiring no user interaction, which is a reliable and repeatable primitive. However, impact is strictly confidentiality (VC:H, VI:N, VA:N) - an out-of-bounds read of up to ~250 bytes each of kernel heap and stack memory, notably including kernel pointers that can defeat KASLR and seed a follow-on exploit. The adjacent (AV:A) requirement is the dominant limiting factor: the attacker must share the Layer-2 broadcast domain, which rules out broad internet-scale automated exploitation and makes this far lower priority than a network-reachable (AV:N) RCE despite the 7.1 base score. No EPSS score, no CISA KEV listing, and no public POC were provided in the input, so exploitation status is 'no public exploit identified at time of analysis'; the only referenced artifact is the upstream fix commit, not weaponized exploit code. Note: the input supplies only a CVSS 4.0 vector and no CVSS 3.1 vector or SSVC decision data, so the real-world exploitation-probability and automatable signals cannot be cross-referenced - the assessment rests on the vector and the source-code evidence alone.

Exploit ScenarioDerived

An attacker positioned on the same local network segment as a DragonFly BSD host sends a single crafted ARP request in which the hardware-address-length (ar_hln) and protocol-address-length (ar_pln) fields are set larger than the real 6-byte and 4-byte values. The kernel's in_arpreply() uses these attacker-controlled lengths as memcpy sizes, over-reading adjacent kernel heap and stack memory and returning it inside the ARP reply, leaking kernel pointers useful for bypassing KASLR. No public exploit code is identified at time of analysis, though the upstream fix commit publicly documents the vulnerable code path.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 15, 2026

Kernel memory disclosure in DragonFly BSD through 6.4.2 (prior to commit 4bb22ff) allows an unauthenticated attacker on the adjacent Layer-2 broadcast domain to leak roughly 250 bytes each of kernel heap and stack memory - including kernel pointers - with a single crafted ARP request. The ARP input handlers arpintr() and in_arpinput() in sys/netinet/if_ether.c fail to validate the hardware address length (ar_hln) and protocol address length (ar_pln) fields, and in_arpreply() subsequently uses those attacker-controlled values as memcpy lengths against kernel buffers that are only 6 and 4 bytes long, copying the overread bytes back to the requester in the ARP reply. No authentication or user interaction is required, but impact is confined to adjacent-network attackers because ARP is not routed across subnets, and no public exploit code has been identified at time of analysis.

RemediationAI

Apply the upstream fix commit 4bb22ffcf2e9fb44995fbfd9945194afc87fb182, which hardens sys/netinet/if_ether.c by rejecting ARP packets whose ar_hln is not ETHER_ADDR_LEN and whose ar_pln is not sizeof(struct in_addr), and by dropping ARP packets with multicast sender hardware addresses; the patch status is best described as "Upstream fix available (PR/commit); released patched version not independently confirmed," with the fix expected to appear in the DragonFly BSD 6.6 stable release - treat 6.6 or a build containing the commit as the patched version and verify the commit is present before declaring a system remediated (reference: https://github.com/DragonFlyBSD/DragonFlyBSD/commit/4bb22ffcf2e9fb44995fbfd9945194afc87fb182). DragonFly BSD has no supported mechanism to simply disable ARP, so the practical compensating controls are network-segmentation-based: confine untrusted hosts to separate VLANs or private VLANs/port-isolation so they cannot share a Layer-2 broadcast domain with sensitive servers, since ARP never crosses a router and a segmented attacker cannot reach the vulnerable handler - the trade-off is reduced host mobility and additional switch configuration. Where switches support it, enable Dynamic ARP Inspection with DHCP snooping; note that this requires correctly configured trusted ports and can break hosts using static IP addressing or non-standard ARP behavior. Port security and 802.1X/NAC limit which devices can appear on the segment at all, but do not stop an already-authorized but compromised host from triggering the leak. Because the flaw is a read-only information disclosure that can expose kernel pointers useful for defeating KASLR in a chained attack, prioritize patching on multi-tenant or guest-accessible Layer-2 segments and, until patched, monitor for unusual ARP traffic exhibiting atypical hardware/protocol address lengths.

Affected VersionsENISA

DragonFlyBSD 984263bcb83ad82313113c6ac840d99124d8f90c <4bb22ffcf2e9fb44995fbfd9945194afc87fb182

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

ARP is a Layer-2 protocol used by IPv4 hosts to resolve a protocol address (IPv4) to a hardware address (Ethernet MAC) within a broadcast domain. Every ARP packet carries ar_hln and ar_pln fields that declare the sizes of the sender/target hardware and protocol addresses; the surrounding standard (Ethernet/IPv4) constrains these to 6 and 4 bytes respectively. CWE-130 (Improper Handling of Length Parameter Inconsistency) applies here: DragonFly BSD's arpintr() and in_arpinput() accepted arbitrary ar_hln/ar_pln values and passed them into in_arpreply(), which used them as memcpy lengths when building the reply from fixed-size kernel-side sender hardware and protocol address buffers. Because the source buffers are only ETHER_ADDR_LEN (6) and sizeof(struct in_addr) (4) bytes, an oversized declared length produces an out-of-bounds read of adjacent kernel heap and stack memory, and the leaked bytes are transmitted back to the attacker inside the ARP reply. The upstream fix in commit 4bb22ffcf2e9fb44995fbfd9945194afc87fb182 adds an explicit ar->ar_hln != ETHER_ADDR_LEN rejection in arpintr(), an ah->ar_pln != sizeof(struct in_addr) rejection plus a multicast-source-hardware-address check in in_arpinput(), and introduces a drop label to free the mbuf cleanly. The CPE cpe:2.3:a:dragonflybsd:dragonflybsd:*:*:*:*:*:*:*:* identifies the DragonFly BSD operating system as the affected product but carries no explicit version granularity, so the authoritative version bound comes from the advisory text: every release through 6.4.2 prior to that commit. Leaked kernel pointers are useful to an adversary mainly as an information-disclosure primitive that can defeat kernel address-space layout randomization as part of a larger exploit chain; this defect alone does not grant write access or code execution.

Know when Dragonflybsd 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 (mitre) PRIMARY 7.1 HIGH
CVSS:4.0/AV:A/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
vuln.today AI 6.5 MEDIUM

Adjacent L2-only reach gives AV:A; unauthenticated single-packet trigger gives AC:L/PR:N/UI:N; kernel memory and pointer disclosure justify C:H with no integrity or availability impact.

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

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

Lifecycle Timeline

2
Patch available
Oct 15, 2026 - 05:01 EUVD
CVE Published
Oct 15, 2026 - 03:23 cve.org
HIGH 7.1

DescriptionCVE.org

In DragonFly BSD through 6.4.2 before 4bb22ff, the ARP input handlers arpintr() and in_arpinput() (sys/netinet/if_ether.c) do not validate the hardware address length (ar_hln) and protocol address length (ar_pln) fields of incoming ARP packets. in_arpreply() then uses these attacker-controlled values as memcpy lengths when copying from kernel buffers that are only 6 and 4 bytes long, resulting in an out-of-bounds read of kernel heap and stack memory that is copied into the ARP reply sent back to the requester. An unauthenticated attacker on the adjacent network can use a single crafted ARP request to disclose up to roughly 250 bytes of each type of kernel memory, including kernel pointers. This is expected to be fixed in the 6.6 stable release when that is available.

Executive ViewAI

Why It Matters

DragonFly BSD systems at version 6.4.2 or earlier can be tricked into leaking roughly 250 bytes of internal kernel memory, including memory addresses, to any device sharing their local network segment. This is confined to organizations that operate DragonFly BSD hosts on the same Layer-2 broadcast domain as an attacker, but for those environments the leaked addresses can undermine memory-protection defenses and serve as groundwork for follow-on attacks. Leadership should care because the affected servers may already sit on shared or semi-trusted network segments where such an attacker could plausibly appear.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: Dynamic ARP Inspection, port security, and DHCP snooping on access switches; static ARP entries for critical hosts; strict VLAN segmentation or private VLANs to keep untrusted devices off the same broadcast domain; 802.1X network access control; IDS/IPS monitoring for malformed ARP packets with abnormal hardware or protocol address lengths; and host firewalls limiting Layer-2 exposure. Upgrade to a build incorporating upstream commit 4bb22ff once released.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Rare
niche BSD operating system with very small production deployment footprint
Social Media
1
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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
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
Scheduled
Exploitation
None
System Exposure· derived
Controlled
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
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.

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