Sep 18, 2026·5 min read·18 visits
CoreDNS alternative transports failed to enforce default message acceptance policies on DNS headers, allowing remote attackers to send unauthorized DNS UPDATE queries that are forwarded to trusting upstream resolvers.
A protocol-level validation bypass in CoreDNS versions prior to 1.14.7 allows unauthenticated remote attackers to proxy unauthorized DNS UPDATE messages (Opcode 5) using modern alternative transport layers such as DoH, DoH3, DoQ, and gRPC. If upstream authoritative servers trust the CoreDNS server's source IP and do not enforce TSIG authentication, attackers can inject, alter, or delete DNS zone records, leading to potential zone takeover or traffic redirection.
CoreDNS is a modular DNS server widely deployed in cloud-native environments, including as the default name resolution service in Kubernetes clusters.\n\nThe vulnerability tracked as CVE-2026-86003 is an architectural validation bypass affecting alternative transport implementations within CoreDNS. These alternative transport endpoints include DNS-over-HTTPS (DoH), DNS-over-HTTP/3 (DoH3), DNS-over-QUIC (DoQ), and DNS-over-gRPC.\n\nWhile traditional UDP, TCP, and DNS-over-TLS (DoT) servers enforce strict message validation policies on incoming packets, the alternative transport listeners failed to invoke the default validation framework when parsing network frames. This allows unauthenticated remote attackers to send unauthorized dynamic DNS update queries that the server subsequently processes and forwards to upstream authoritative resolvers.
In CoreDNS, incoming DNS messages processed over standard UDP or TCP transports are routed through parsing wrappers that leverage the default message acceptance logic defined by the Go DNS library ('github.com/miekg/dns'). The central function 'dns.DefaultMsgAcceptFunc' validates header opcodes and flags, rejecting administrative opcodes like 'UPDATE' (Opcode 5) by default.\n\nIn affected CoreDNS versions prior to 1.14.7, alternative and encrypted transports handled payload extraction independently. Rather than passing the raw extracted byte payloads through the validated deserialization logic, these handlers directly invoked the library's raw 'Unpack()' method on the unpacked message instances.\n\nThe 'Unpack()' method deserializes wire bytes into a 'dns.Msg' structure but does not enforce the 'dns.DefaultMsgAcceptFunc' filtering. This allows any unauthenticated client to deliver high-privilege opcodes, such as RFC 2136 'UPDATE' payloads, without triggering the boundary access controls. The unpacked message is subsequently treated as a normal DNS query and routed into the core plugin architecture.
To visualize the propagation of unauthorized payloads, consider the network path of the exploit from the attacker to the internal DNS infrastructure.\n\nmermaid\ngraph LR\n Attacker[\"Untrusted Attacker\"]\n CoreDNS[\"CoreDNS Server (Vulnerable Listener)\"]\n Upstream[\"Upstream Authoritative DNS Server\"]\n\n Attacker -- \"DoH POST /dns-query<br>(Opcode 5: UPDATE)\" --> CoreDNS\n CoreDNS -- \"Raw DNS Update (Opcode 5)<br>(CoreDNS Source IP)\" --> Upstream\n Upstream -- \"Processes Update\" --> Upstream\n\n\nWhen CoreDNS forwards the unpacked message via the 'forward' or 'proxy' plugins, the packet arrives at the upstream authoritative nameserver with the source IP of the CoreDNS pod or server. Because many environments establish trusted zones based on internal IP allowlists, the upstream server assumes the request is legitimate and executes the record update.
The vulnerability was addressed in commit '530b0a5ff2ad68cc0421f10dd93568945cc671c9' by introducing a standardized request parsing helper under 'plugin/pkg/dnsutil/message.go'.\n\nThis utility, 'UnpackRequest', explicitly decodes the DNS header structure and runs validation prior to performing full deserialization. This prevents raw 'UPDATE' operations from propagating further.\n\ngo\npackage dnsutil\n\nimport (\n\t\"encoding/binary\"\n\t\"errors\"\n\n\t\"github.com/miekg/dns\"\n)\n\nvar errRequestRejected = errors.New(\"dns request rejected\")\n\n// UnpackRequest unpacks a request after applying the default miekg/dns request policy.\nfunc UnpackRequest(msg []byte) (*dns.Msg, error) {\n\tvar header dns.Header\n\t// Partially decode the wire packet header\n\tif _, err := binary.Decode(msg, binary.BigEndian, &header); err != nil {\n\t\treturn nil, dns.ErrBuf\n\t}\n\t// Validate the header flags using the standard acceptance function\n\tif dns.DefaultMsgAcceptFunc(header) != dns.MsgAccept {\n\t\treturn nil, errRequestRejected\n\t}\n\n\trequest := new(dns.Msg)\n\treturn request, request.Unpack(msg)\n}\n\n\nThe alternative listeners, such as the gRPC listener ('core/dnsserver/server_grpc.go'), were then modified to utilize 'dnsutil.UnpackRequest' instead of direct unpacking:\n\ndiff\n-msg := new(dns.Msg)\n-err := msg.Unpack(in.GetMsg())\n+msg, err := dnsutil.UnpackRequest(in.GetMsg())\n if err != nil {\n \treturn nil, err\n }\n
An attacker targeting this vulnerability must identify a CoreDNS instance exposing an alternative transport mechanism, such as a DNS-over-HTTPS (DoH) endpoint. The attacker does not require credentials or access to the internal network if the DoH server is exposed externally.\n\nThe attacker crafts a binary-encoded RFC 2136 DNS UPDATE query. This message specifies the targeted domain zone (e.g., 'internal.zone') and includes Resource Record modification directives (e.g., adding an 'A' record pointing to a rogue IP address).\n\nThe payload is then encapsulated inside an HTTP POST request to the '/dns-query' path, utilizing the 'application/dns-message' content type. Because the DoH handler does not validate the header opcode, the CoreDNS server treats it as a legitimate request, matches the zone against the 'forward' plugin, and forwards it to the upstream nameserver under its own trusted IP footprint.
The impact of a successful exploitation is a complete compromise of integrity for DNS records handled by the trusted upstream server. Attackers can hijack internal domain resolution, route traffic to malicious servers, manipulate MX records to intercept corporate mail, or delete existing host entries to disrupt services.\n\nOrganizations should immediately upgrade CoreDNS deployments to version 1.14.7 or later. This release enforces validation across all transport pathways.\n\nFor systems where immediate upgrades are unfeasible, defensive actions include disabling the 'doh', 'grpc', or 'quic' plugins in the active 'Corefile' configuration. Furthermore, upstream servers must be reconfigured to require cryptographic Transaction Signatures (TSIG) for any zone modification commands, neutralizing source-IP based authorization mechanisms.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N| Attribute | Detail |
|---|---|
| CWE ID | CWE-441 |
| Attack Vector | Network (AV:N) |
| CVSS Score | 7.5 (High) |
| Exploit Status | poc |
| KEV Status | Not Listed |
| Impact | High Integrity Impact (Zone manipulation) |
CVE-2026-118777 is a prototype pollution vulnerability (CWE-1321) in the Forge JavaScript cryptography and networking library (distributed on npm as node-forge) prior to version 1.4.1. The flaw resides in the forge.http client subsystem, where incoming HTTP cookie names and paths parsed from Set-Cookie response headers are stored directly into standard JavaScript objects without key validation or property isolation. By returning crafted Set-Cookie headers containing keys such as __proto__ or constructor, a malicious HTTP server can inject arbitrary properties into Object.prototype, attach attributes to the global Object constructor, or delete built-in prototype methods to cause an application-wide denial of service.
CVE-2026-118775 (GHSA-4642-5mcj-2rqw) is an integer overflow and validation flaw in the ASN.1 serialization module of Forge (node-forge) prior to version 1.4.1. The asn1.oidToDer() function fails to validate the range of the first two arcs of an Object Identifier (OID) and truncates the packed initial subidentifier to a single 8-bit integer. Applications that perform policy checks on untrusted OID strings before encoding them into Distinguished Encoding Rules (DER) format can be tricked into emitting DER bytes that correspond to a completely different, restricted OID.
CVE-2026-119194 is an algorithmic complexity vulnerability (CWE-407) in the pyasn1 library for Python, affecting versions 0.3.3 through 0.6.4. The flaw resides in the schemaless decoding routine ConstructedPayloadDecoderBase._decodeComponentsSchemaless used across BER, CER, and DER codecs. By sending an ASN.1 container populated with child components whose tag identifiers are separated by multiples of CPython's integer hash modulus (sys.hash_info.modulus), an unauthenticated attacker can force worst-case hash collisions in an unbounded Python set, degrading decoding performance from O(N) to O(N^2) and causing a Denial of Service (DoS).
CVE-2026-119195 is an algorithmic complexity vulnerability (CWE-407) in the pyasn1 library for Python, affecting all versions prior to 0.6.5. When decoding constructed strings or indefinite-length ANY types across BER, CER, and certain DER code paths, the payload decoders repeatedly concatenate incoming fragments onto an immutable bytes object using the += operator. Because Python bytes objects cannot be resized in-place, each fragment iteration allocates a new buffer and copies all previously accumulated bytes, resulting in quadratic O(N^2) time and memory copy complexity. An unauthenticated remote attacker can supply a highly fragmented ASN.1 stream to exhaust CPU cycles and stall application worker threads.
An algorithmic complexity vulnerability (CWE-407) in pyasn1 versions prior to 0.6.5 allows unauthenticated attackers to cause a Denial of Service (DoS) via crafted ASN.1 payloads. The flaw resides in the binary-encoded ASN.1 REAL mantissa deserialization routine within RealPayloadDecoder.valueDecoder. By performing iterative byte-string slicing and repeated bitwise shifts on a growing arbitrary-precision integer, the decoder exhibits quadratic time and memory allocation complexity relative to the mantissa length. Supplying a BER-, CER-, or DER-encoded payload with a large REAL mantissa causes excessive CPU consumption and blocks application worker processes.
A vulnerability classified under CWE-407 (Inefficient Algorithmic Complexity) exists in the pyasn1 library prior to version 0.6.5. When parsing constructed ASN.1 BIT STRING payloads under BER, CER, or schema-driven DER encoding rules, the BitStringPayloadDecoder repeatedly shifts and copies the entire accumulated bit value for each incoming fragment. Processing inputs with a large number of small constructed fragments induces quadratic CPU consumption, allowing unauthenticated remote attackers to cause a denial of service via resource exhaustion during the initial decoding phase.