Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-112325 — Advisory and proof-of-concept for CVE-2026-112325, a remotely triggerable NULL-pointer dereference in OpenThread's mDNS DNS-SD Discovery Proxy causing Border Router DoS. | Kitploit
Tools/GitHubGitHub/j0xh-sec/cve-2026-112325
Embedded Systems SecurityIoT SecurityVulnerability AnalysisFuzzingNetwork SecurityLearning & Education
GitHubj0xh-sec/cve-2026-112325

CVE-2026-112325

Advisory and proof-of-concept for CVE-2026-112325, a remotely triggerable NULL-pointer dereference in OpenThread's mDNS DNS-SD Discovery Proxy causing Border Router DoS.

View Repository
27 days agoNot yet reviewed
Share

CVE-2026-112325 — NULL-Pointer Dereference in OpenThread mDNS RecordCache::Matches()

CVE GHSA Severity CWE Status

A remotely triggerable NULL-pointer dereference in OpenThread's native Multicast DNS (mDNS) / DNS-SD Discovery Proxy. Two well-formed DNS-SD query packets from a node on the Thread mesh crash a default-configuration OpenThread Border Router (OTBR), taking the whole Thread network off-network — a remotely triggerable denial of service (CWE-476).

CVECVE-2026-112325
AdvisoryGHSA-xf9m-rgrq-7vqf
CWECWE-476: NULL Pointer Dereference
SeverityMedium — CVSS 3.1 5.7 (AV:A/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H)
Componentopenthread/openthread — native mDNS / DNS-SD Discovery Proxy (src/core/net/mdns.cpp)
Affectedall revisions prior to commit b47613f1
Patchedb47613f1 (PR #13653)
ImpactRemote crash → DoS of the Border Router → Thread network loses off-network connectivity
Reporter / Fix@j0xh-sec

Summary

OpenThread ships its own Multicast DNS stack. Its DNS-SD Discovery Proxy keeps a cache of in-flight record queriers (Core::RecordCache) and compares an incoming querier against each cached entry in Core::RecordCache::Matches(). The comparison helper Core::NameMatch(const Heap::String&, const char *) validates the cached name but never checks that the incoming querier's C-string name is non-NULL.

A NULL name is a legal, documented value ("no next labels"). The matcher handles it in one direction but not the mirror direction: when a cached entry has non-NULL next-labels and the incoming querier's next-labels are NULL, the code walks into NameMatch(..., nullptr), which forwards the NULL pointer to a byte-by-byte string compare that dereferences address 0x0.

Both inputs are produced by ordinary, well-formed DNS-SD queries received over the network, so an attacker on the Thread mesh crashes the Border Router with two packets.

Affected configuration

The faulting type ot::Dns::Multicast::Core::RecordCache is compiled only when OpenThread's native mDNS stack is enabled (OT_MDNS), together with the DNS-SD server (OT_DNSSD_SERVER) and the Discovery Proxy (OT_DNSSD_DISCOVERY_PROXY).

This is the default for the shipping product: ot-br-posix defaults OTBR_MDNS=openthread, which forces all three options ON (ot-br-posix/third_party/openthread/CMakeLists.txt). So a stock-configured OpenThread Border Router has exactly the three pieces this bug needs.

Root cause

1. The unguarded helper — src/core/net/mdns.cpp:

bool Core::NameMatch(const Heap::String &aHeapString, const char *aName)
{
    // aHeapString is null-checked; aName is NOT.
    return !aHeapString.IsNull() &&
           StringMatch(aHeapString.AsCString(), aName, kStringCaseInsensitiveMatch);
}

StringMatch() → Match() (src/core/common/string.cpp:75) then does:

while (*aPrefixString != kNullChar) { ... }   // aPrefixString == nullptr → read of address 0

2. The asymmetric caller — RecordCache::Matches() in src/core/net/mdns.cpp:

if (mNextLabels.IsNull())
{
    VerifyOrExit(aQuerier.mNextLabels == nullptr);        // this direction is guarded
}
else
{
    VerifyOrExit(NameMatch(mNextLabels, aQuerier.mNextLabels)); // mirror case: NOT guarded → crash
}

3. Where the NULL comes from — src/core/net/dnssd_server.cpp StartOrStopRecordQuerier():

querier.mFirstLabel = firstLabel;
querier.mNextLabels = (StripDomainName(nextLabels) == kErrorNone) ? nextLabels : nullptr; // ← NULL

A query whose name cannot be stripped of the proxy domain yields mNextLabels == nullptr. If a previously cached entry carries non-NULL next-labels and the same first label, Matches() takes the else branch and dereferences NULL.

NULL is the documented contract for this field (include/openthread/mdns.h, include/openthread/platform/dnssd.h: "Can be NULL"), and a prior fuzzer-driven hardening pass (PR #12184) explicitly tolerated it — only this one mirror branch was missed.

Call path (reached synchronously while handling a received packet)

Match(char const*, char const*, StringMatchMode)                 common/string.cpp:75   ← SEGV, addr 0x0
Core::NameMatch(Heap::String const&, char const*)                net/mdns.cpp
Core::RecordCache::Matches(RecordQuerier const&)                 net/mdns.cpp
LinkedList<RecordCache>::FindMatching<...>                       common/linked_list.hpp
Server::DiscoveryProxy::StartOrStopRecordQuerier(...)            net/dnssd_server.cpp
Server::ProcessQuery(...) / HandleUdpReceive(...)                net/dnssd_server.cpp

The fault is reached synchronously from HandleUdpReceive() while parsing a received DNS-SD query — not from a background timer — so it is driven directly by attacker-supplied packets.

The two packets

Ordinary DNS-SD queries. Nothing malformed.

#QNAMEQTYPEEffect
1default.service.arpa.default.service.arpa0StripDomainName() leaves service.arpa → cached with non-NULL mNextLabels
2default.service.arpa0StripDomainName() fails → querier mNextLabels = nullptr → compared against #1 → SEGV

QTYPE 0 matters: it is absent from the proxy's action table, so the action defaults to kQueryingRecord — the branch that builds a raw RecordQuerier. Both packets share the QTYPE because Matches() checks the record type before the names.

Attacker model & impact

  • Position: the DNS-SD socket binds to the Thread interface by default (OPENTHREAD_CONFIG_DNSSD_SERVER_BIND_UNSPECIFIED_NETIF = 0). The attacker is therefore a device on the Thread mesh, not an off-link / internet host — hence AV:A (Adjacent).
  • Realistic scenario: a post-compromise lateral-movement primitive. A single compromised mesh device (a cheap sensor, bulb or lock) sends two DNS-looking packets and crashes the Border Router. Because the Border Router is the single point every node depends on for off-network connectivity, one $10 device can take the entire Thread network off-network.

Proof of Concept

See poc/README.md. Two independent reproductions are provided:

  1. Deterministic, single-process — poc/poc_dnssd_nullderef.cpp, an OpenThread Nexus test that seeds the cache and delivers the two packets, crashing on every run.
  2. Live, two real nodes over the simulated radio — poc/demo.py + poc/attacker.py: a separate attacker node joins the victim's network and sends the two queries from its own UDP socket. Nothing is injected into the victim.

Also included: poc/fuzz_dnssdp.cpp, the persistent-node DNS-SD fuzz harness that originally surfaced the crash.

Patch

Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    994
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    656
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    422
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer is an open-source Privileged Access Management (PAM) platform that provides DevOps and IT teams with on-demand and secure access to SSH, RDP, Kubernetes, Database and RemoteApp endpoints through a web browser.

    389
  • 5

    SafeLine

    chaitin/safeline

    Self-hosted WAF and reverse proxy that filters malicious HTTP traffic, blocks SQL injection, XSS, and bot attacks, with rate limiting and dynamic HTML/JS encryption.

    333
  • 6

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    330

Explore all tools

Browse our collection of tools

View all tools →