Skip to main content

Spring Micrometer CVE-2026-59296

| EUVDEUVD-2026-63885 MEDIUM
Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection') (CWE-74)
2026-08-21 vmware GHSA-8jcv-3c3x-vwg4
5.9
CVSS 3.1 · Vendor: vmware
View

Attack ChainAIDerived

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

  1. Access
    Submit HTTP request with \n embedded in input parameter
  2. Delivery
    Application passes unsanitized parameter to Micrometer meter tag
  3. Exploit
    Micrometer appends raw value to StatsD or log line
  4. Execution
    Newline character terminates current metric record early
  5. Persist
    Attacker-crafted fake metric line is emitted in same payload
  6. Impact
    Downstream 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.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 – 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

Spring Micrometer patch: 1.17.1
Spring Micrometer 1.17.0 - 1.17.0
Spring Micrometer patch: 1.14.17
Spring Micrometer 1.9.18 and earlier
Spring Micrometer patch: 1.17.0.1
Spring Micrometer patch: 1.9.19
Spring Micrometer patch: 1.16.7
Spring Micrometer 1.16.0 - 1.16.6
Spring Micrometer patch: 1.15.13
Spring Micrometer 1.15.0 - 1.15.12
Spring Micrometer 1.14.0 - 1.14.16
Spring Micrometer patch: 1.16.6.1

Affected Packages

euvd spring_micrometer_1_14_0 no fix
euvd spring_micrometer_1_15_0 no fix
euvd spring_micrometer_1_16_0 no fix
euvd spring_micrometer_1_17_0 no fix

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

Vendor (vmware) PRIMARY 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N
vuln.today AI 5.9 MEDIUM

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.

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

Primary rating from Vendor (vmware).

CVSS VectorVendor: vmware

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
High
Availability
None

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

EPSS Score
0.2%
Top 90% exploitable
Prevalence
High
core observability library in the dominant Spring Boot enterprise ecosystem
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor VulDB

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
High
Technical Impact
Partial

Priority Score

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

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Vendor StatusVendor

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