Skip to main content

hickory-resolver CVE-2026-93657

| EUVDEUVD-2026-82939 HIGH
Improper Verification of Cryptographic Signature (CWE-347)
2026-09-18 VulnCheck GHSA-884w-h442-q7ph
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Gain on-path position or control answering zone
  2. Delivery
    Serve DNS records with corrupted RRSIG
  3. Exploit
    Resolver fails to propagate Bogus proof state
  4. Execution
    lookup_ip() returns forged record as validated
  5. Impact
    Victim connects to attacker-controlled host

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V11 - Cryptography Signature verification
Exploitation Conditions

Exploitation requires that the consuming application enables DNSSEC validation (the crate's __dnssec feature) and treats validated lookups as a trust boundary, AND that the attacker either controls the authoritative zone answering the query or holds an on-path/MITM position to inject forged records with invalid RRSIGs. The bypass only manifests through the high-level Resolver::lookup() and Resolver::lookup_ip() APIs. Limiting factors: applications that do not enable DNSSEC gain no protection to bypass and are unaffected; the attacker must be able to influence answers (zone control or network position), so it is not exploitable by an arbitrary remote host with no path to the traffic; and it affects only hickory-resolver versions before 0.26.2.

Impact

This is a genuine, high-priority integrity flaw despite the absence of exploitation telemetry. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N, VI:H, all other impacts N) correctly models a network-reachable, unauthenticated, integrity-only DNSSEC validation bypass - a security control silently failing open. hickory-resolver before 0.26.2 accepts records whose DNSSEC proof state is Bogus as successful validated results because the bogus state is never propagated out through the Resolver::lookup()/lookup_ip() public APIs; the fix (PR #3871) adds a DnssecSummary::Bogus check in caching_client that returns a new DnssecBogus error. No EPSS score, no CISA KEV entry, and no public POC were provided in the input, so there is no public exploit identified at time of analysis. The signals are consistent rather than conflicting: high impact but no evidence of mass exploitation, which fits a targeted MITM/zone-control attack rather than opportunistic scanning. The realistic caveat is that impact is entirely conditional on the consuming application actually enabling DNSSEC validation and relying on it as a security boundary - a resolver that never turned DNSSEC on gets no benefit and therefore suffers no regression from this bug.

Exploit ScenarioDerived

An attacker who controls the answering authoritative zone, or who is positioned on the network path (on-path/MITM) between the resolver and upstream, returns forged DNS records with invalid or corrupted RRSIG signatures. A downstream service using hickory-resolver's lookup_ip() with DNSSEC enabled receives these forged records as a successful, apparently-validated answer and connects to an attacker-controlled IP. No public exploit code was provided, but the fix commit ships a conformance test that corrupts an RRSIG byte and demonstrates the bogus answer being accepted.

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 – Sep 18, 2026

hickory-resolver releases before 0.26.2 fail to propagate a 'bogus' DNSSEC proof state out of the high-level Resolver::lookup() and Resolver::lookup_ip() APIs, so records that fail DNSSEC signature validation are handed back to the caller as successful, apparently validated answers. This is an integrity-only bypass affecting unauthenticated remote attackers (CVSS:4.0 8.7 / assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N) who either control the authoritative zone answering the query or sit on the network path to inject forged records with invalid RRSIGs; applications that do not compile the crate's __dnssec feature are unaffected because they never expected validation in the first place. A vendor fix is available in 0.26.2 (commit 30720f4, PR 3871), and no public exploit code or confirmed active exploitation was observed at time of analysis. This is a genuine, high-priority integrity flaw despite the absence of exploitation telemetry.

RemediationAI

Upgrade hickory-resolver to 0.26.2 or later - this is the vendor-released fix, published at https://github.com/hickory-dns/hickory-dns/releases/tag/v0.26.2 and implemented in commit 30720f4fb22e5556ecbf26d2c8274ea4a9fdd238 (PR https://github.com/hickory-dns/hickory-dns/pull/3871), which surfaces a new DnssecBogus error instead of returning bogus records; see advisory GHSA-5j98-2g5x-46v6 for the coordinated disclosure. If you cannot upgrade immediately, the most effective compensating control is to stop trusting the high-level API: do not treat answers from Resolver::lookup()/lookup_ip() as DNSSEC-validated in security decisions, and instead validate out-of-band or inspect proof state through lower-level paths - the trade-off is significant application rework plus the loss of seamless validation. Where the resolver is used behind a forwarder, point it at a local validating recursive resolver (validating stub on the same host over loopback) so that forged upstream answers are rejected before hickory sees them, though this adds an operational dependency and does not fix the library itself. Because exploitation requires attacker control of the answering zone or an on-path position, tightening transport helps materially: enable DNS-over-TLS to a trusted upstream, pin/limit the configured ServerGroup to resolvers you control, and avoid clear-text UDP to untrusted parties, accepting the added latency and configuration overhead. Given the fix diff's own caveat that the CD (Checking Disabled) flag is not yet propagated through the resolver API, applications that deliberately request CD behavior should re-verify their expected semantics after upgrading rather than assuming parity. Track EUVD-2026-82939 and the Vendor advisory for updates; no exploitation telemetry currently exists, so prioritise by exposure of DNSSEC-validating code paths rather than by active-threat indicators.

Affected VersionsENISA

hickory-resolver 0 <0.26.2

Affected Packages

cargo hickory-resolver fix: 0.26.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in cargo

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

hickory-resolver is the recursive/stub resolver component of the Rust hickory-dns project (formerly trust-dns), tracked here as CPE cpe:2.3:a:hickory-dns:hickory-resolver. DNSSEC validation works by chaining RRSIG signatures back to a configured trust anchor and classifying each answer as secure, insecure, or bogus; the root cause here is CWE-347, Improper Verification of Cryptographic Signature - the library computes the bogus verdict internally but drops it before the result crosses the public resolver API boundary, so caching_client.rs returns the underlying records instead of surfacing a validation error. The upstream patch adds a DnssecBogus variant to DnsError in crates/net/src/error.rs, treats it as a retryable/terminal error in retry_dns_handle.rs, and in caching_client.rs derives a DnssecSummary from the response records (or from the Proof::Bogus carried on a NetError::Dns(Nsec{..})), short-circuiting with DnssecBogus when the summary indicates a bogus proof. Notably, the patch diff still carries a TODO stating the Checking Disabled (CD) flag is not yet plumbed from the ForwarderZoneHandler through the Resolver public API to this code path, and the included 'checking_disabled' conformance test is marked #[ignore] - evidence that CD-flag handling remains incomplete even after the fix, which is relevant to anyone relying on CD semantics. The failure mode is a trust-boundary problem: the crate reports success, so any consuming application that treats a resolved answer as DNSSEC-authenticated inherits the forged data.

Know when Hickory Resolver 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 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Network-reachable unauthenticated DNSSEC bypass returning forged-but-trusted records is a pure high-integrity impact; AC:L per zone control, no confidentiality or availability effect.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

hickory-resolver versions before 0.26.2 fail to propagate bogus DNSSEC proof states through the Resolver::lookup() and Resolver::lookup_ip() APIs, allowing invalid records to be returned as successful results. Attackers controlling the answering zone or positioned on the network path can have forged DNS records accepted as validated, bypassing DNSSEC authentication checks.

Technical POC Analysis

CWE-347, improper verification of a cryptographic signature.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Applications built on the hickory-resolver library at versions below 0.26.2 can silently accept forged or tampered DNS answers as if they had passed DNSSEC validation, so downstream systems - service discovery, DANE/TLSA certificate checks, and any policy that assumes a validated lookup - may act on attacker-supplied data while believing it is trustworthy. Exposure is limited to builds that compile the crate's DNSSEC feature, but for those, an unauthenticated attacker who controls the answering authoritative zone or sits on the network path can defeat integrity checks remotely with no credentials and no user interaction. Leadership should treat this as a high-priority supply-chain integrity issue rather than an outage risk: the flaw quietly removes a trust guarantee from a foundational lookup component embedded across internal services.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 86% exploitable
Prevalence
Medium
most popular pure-Rust DNS resolver library, but Rust-ecosystem-scoped
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub

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
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise Module for Public Cloud 15 SP7 Not-Affected
SUSE Linux Enterprise Server 15 SP7 Not-Affected
SUSE Linux Enterprise Server 16.0 Not-Affected
SUSE Linux Enterprise Server 16.1 Not-Affected

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