Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit HTTP request with \n embedded in input parameter
-
DeliveryApplication passes unsanitized parameter to Micrometer meter tag
-
ExploitMicrometer appends raw value to StatsD or log line
-
ExecutionNewline character terminates current metric record early
-
PersistAttacker-crafted fake metric line is emitted in same payload
-
ImpactDownstream StatsD agent or log scraper ingests spoofed metric as legitimate
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Input neutralization, injection prevention
|
| Exploitation Conditions | Exploitation requires all three of the following conditions to hold simultaneously. First, the application must use a vulnerable version of io.micrometer:micrometer-registry-statsd or io.micrometer:micrometer-core. Second, the application must be configured to use specifically the Datadog or Etsy flavor of the StatsD registry - not the Telegraf or other protocol flavors - or must use LoggingMeterRegistry for metric output. Third, and most critically, the application must construct meter names, tag keys, or tag values using user-controlled, unvalidated input: for example, passing an HTTP request header, query parameter, path variable, or externally sourced identifier directly into a meter tag without stripping control characters. Exploitation is bounded by: the AC:H multi-condition dependency; the requirement that Datadog/Etsy StatsD or LoggingMeterRegistry is actively deployed (not all Micrometer backends are affected); the need for user input to reach the instrumentation layer without prior input validation; and the integrity-only impact scope, which limits attacker objectives to metric and log spoofing rather than data exfiltration or service disruption. |
| Impact | The CVSS 3.1 score of 5.9 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N) appropriately reflects the multi-condition dependency: exploitation requires the Datadog or Etsy StatsD flavor or LoggingMeterRegistry to be configured, and user-supplied strings must flow unvalidated into meter tag fields - a high attack-complexity designation that keeps the score in the medium tier. However, the AC:H rating may understate practical exposure, because passing request-derived data into custom meter tags for high-cardinality observability is a common Spring Boot pattern, making the preconditions less exceptional than the score implies. The impact is integrity-only: no confidentiality breach and no availability degradation are achievable via this primitive, limiting attacker motivation to corrupting observability pipelines, suppressing genuine alerts, or injecting false log evidence. No EPSS data was present in the provided intelligence, and this CVE does not appear in the CISA KEV catalog, which aligns with a scenario of no confirmed widespread exploitation at time of analysis. The real-world risk is most acute for organizations whose security operations or SRE teams treat Micrometer-sourced telemetry as authoritative - even a mid-sized engineering department in a place like rybnik operating a Spring Boot microservices platform could find spoofed JVM or business metrics meaningful enough to delay or misdirect incident response - but the absence of active exploitation and the AC:H preconditions mean this is a patch-cycle priority rather than an emergency for most deployments. |
| Exploit ScenarioDerived | An attacker sends an HTTP request whose path variable or query parameter - for example, a tenant identifier or user-agent string - is passed directly as a Micrometer tag value without sanitization. By embedding a literal \n character in that parameter, the attacker terminates the in-progress StatsD line and appends a fully formed fake metric line such as 'system.cpu.usage:0.00|g', which the Datadog or Etsy StatsD agent records as a legitimate application metric. No public exploit code has been identified at time of analysis, but the technique requires only standard HTTP tooling and knowledge of the application's meter tag structure. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 21, 2026
Line-protocol injection and log spoofing in Spring Micrometer's StatsD and LoggingMeterRegistry components allow network-reachable attackers to forge arbitrary metrics and log entries by embedding newline characters into user-supplied strings that flow unvalidated into meter names, tag keys, or tag values. Affected deployments span the 1.9.x through 1.17.x release lines of io.micrometer:micrometer-registry-statsd and io.micrometer:micrometer-core when the Datadog or Etsy StatsD flavor is active, or when LoggingMeterRegistry is in use. No public exploit has been identified at time of analysis, though the integrity-focused impact carries real risk for organizations whose incident-response workflows depend on Micrometer-sourced telemetry.
RemediationAI
Upgrade to the patched release corresponding to the active branch in use: 1.9.19, 1.14.17, 1.15.13, 1.16.7 (or 1.16.6.1), or 1.17.1 (or 1.17.0.1), as detailed in the vendor advisory at https://spring.io/security/cve-2026-59296. If an immediate library upgrade is not feasible, the most effective compensating control is to sanitize all user-supplied strings at the application boundary before passing them as meter names, tag keys, or tag values - strip or reject any input containing \n, \r, or other ASCII control characters; this trade-off is that it requires audit and modification of all instrumentation call sites. Switching away from the Datadog or Etsy StatsD flavor to a registry that does not use a newline-delimited protocol (e.g., Telegraf) eliminates the StatsD injection surface but does not address the LoggingMeterRegistry spoofing path and may require reconfiguring the metrics backend. Restricting which application endpoints contribute user-derived data to custom meter tags reduces exposure with minimal side effects but may degrade observability cardinality. No compensating control substitutes for patching the underlying library.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 4 packages in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Spring Micrometer is a vendor-neutral application metrics instrumentation library widely embedded in Spring Boot applications through the io.micrometer:micrometer-registry-statsd and io.micrometer:micrometer-core artifacts (CPE cpe:2.3:a:vmware:spring_micrometer:*:*:*:*:*:*:*:*). The StatsD protocol is a UDP-based, newline-delimited text format where each metric occupies exactly one line; the Datadog and Etsy flavors both rely on this line-oriented wire format. Prior to the fix, when Micrometer constructed StatsD payloads or LoggingMeterRegistry output, it concatenated metric names, tag keys, and tag values into output lines without stripping or encoding CRLF characters (\n, \r). An attacker who controls any fragment of that concatenation can terminate the current metric line early and append additional fully formed metric lines. The same antipattern applies to LoggingMeterRegistry: metric data written line-by-line to log files can be broken apart by injected newlines, causing downstream log-metric scrapers or parsers - such as a Datadog agent log-parsing rule or a Prometheus log exporter - to ingest attacker-controlled lines as discrete, legitimate metric or log records. The reporter lists CWE as N/A, but the vulnerability class most closely aligns with improper output neutralization (analogous to CWE-117) and CRLF injection (CWE-93), compounded by missing input sanitization at the instrumentation boundary.
Know when Spring Micrometer 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
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N
AC:H reflects three mandatory preconditions (specific registry flavor, vulnerable version, unsanitized user input reaching meter tags); PR:N because no authenticated access to the target system is needed - attacker input arrives via normal application channels; integrity-only impact since the primitive yields only metric and log spoofing.
Primary rating from Vendor (vmware).
CVSS VectorVendor: vmware
DescriptionCVE.org
Using untrusted, non-normalized input as-is for metrics data (such as metric names, tag keys, or tag values) is a dangerous antipattern that general-purpose instrumentation should never perform. When such unsafe instrumentation is used, the application becomes vulnerable to injection and spoofing attacks because micrometer-registry-statsd and micrometer-core do not sanitize newline characters (\n, \r) by default prior to this fix.
- For the StatsD registry in micrometer-registry-statsd (when using the Datadog or Etsy flavor), because the StatsD protocol is newline-delimited, this allows for line-protocol injection (cross-metric spoofing).
- For LoggingMeterRegistry in micrometer-core, because metric output is printed line-by-line to log files, this allows for both metric spoofing (if downstream log-metrics scrapers or parsers ingest the log lines as separate metrics) and general log spoofing.
Specifically, an application is vulnerable when all the following are true:
- The application uses a vulnerable version of io.micrometer:micrometer-registry-statsd or io.micrometer:micrometer-core.
- The application uses the Datadog or Etsy flavor of the StatsD registry, or uses LoggingMeterRegistry.
- The application instruments meters using user-controlled, unvalidated input for metric names, tag keys, or tag values.
When vulnerable, an attacker can break out of the current metric or log line by injecting line terminators. This allows them to spoof arbitrary metrics (e.g., system load, standard JVM metrics, or other business metrics) across the metrics registry namespace (either directly via StatsD protocol or via downstream log-metric scrapers/parsers), as well as inject arbitrary log entries to spoof general log records.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
EUVD-2026-63885
GHSA-8jcv-3c3x-vwg4
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB