CVE-2025-65944

Executive Summary

CVE-2025-65944 is a high-severity information disclosure vulnerability in the official Sentry JavaScript SDK (@sentry/node). When a Node.js application configures the SDK with sendDefaultPii: true, the SDK inadvertently captures and transmits sensitive HTTP headers—including the Cookie header—to the Sentry error tracking service. These headers are stored as part of trace data within the Sentry organization. An attacker with access to the Sentry organization (e.g., a malicious insider or an account takeover victim) can retrieve these stored headers and use them to impersonate users, escalate privileges, or perform session hijacking.

The vulnerability affects versions 10.11.0 through 10.26.x. It was patched in version 10.27.0. The root cause is an overly broad implementation of the sendDefaultPii feature, which was intended to capture personally identifiable information (PII) for debugging but failed to exclude sensitive HTTP headers like Cookie and Authorization.

Supply Chain & Package Security

This vulnerability resides in the @sentry/node npm package. Organizations using this package in their Node.js applications are at risk. The supply chain risk is moderate: the vulnerability is in a widely used error monitoring SDK, and exploitation requires both the vulnerable configuration (sendDefaultPii: true) and access to the Sentry organization. However, once exploited, the impact is severe as it exposes session tokens and authentication credentials.

CVSS Breakdown & Threat Level

CVSS Score: 0.0 (NVD has not assigned a score; based on the description, a reasonable estimate is 7.5 - High)

Estimated CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

• Attack Vector (AV): Network – The vulnerability is triggered by normal HTTP traffic to the application.
• Attack Complexity (AC): Low – No special conditions required; the SDK automatically captures headers.
• Privileges Required (PR): None – The attacker does not need to be authenticated to the application.
• User Interaction (UI): None – No user action needed.
• Scope (S): Unchanged – The vulnerable component is the SDK itself.
• Confidentiality (C): High – Sensitive HTTP headers (cookies, auth tokens) are exposed.
• Integrity (I): None – No data modification.
• Availability (A): None – No denial of service.

Threat Level: High. The vulnerability allows credential theft and session hijacking with minimal effort.

Deep Dive & Mechanics

The Sentry JavaScript SDK is designed to capture errors and performance data. The sendDefaultPii option, when set to true, instructs the SDK to include PII (e.g., user ID, email) in error reports. However, in versions 10.11.0 to 10.26.x, the implementation also captured all HTTP headers from incoming requests, including sensitive ones like Cookie and Authorization.

Root Cause: The SDK's request data extraction logic did not filter out sensitive headers. It used a generic headers object from the Node.js http.IncomingMessage without applying a denylist for headers like cookie, authorization, x-api-key, etc.

Attack Flow:

1. A Node.js application uses @sentry/node with sendDefaultPii: true.
2. A user makes a request to the application, including their session cookie.
3. The SDK captures the request headers (including the cookie) and sends them to Sentry as part of an error or trace event.
4. An attacker with access to the Sentry organization (e.g., a developer, a compromised account) queries the stored events.
5. The attacker extracts the Cookie header and uses it to impersonate the user.

Affected Components:

• @sentry/node package (npm)
• Versions: >= 10.11.0, < 10.27.0

Vulnerable vs. Patched Code

Vulnerable Code (v10.11.0 - v10.26.x):

// In the request data extraction module
function extractRequestData(req) {
  return {
    method: req.method,
    url: req.url,
    headers: req.headers,  // <-- All headers, including Cookie, are captured
    // ... other data
  };
}

Patched Code (v10.27.0):

// In the request data extraction module
const SENSITIVE_HEADERS = ['cookie', 'authorization', 'x-api-key', 'set-cookie'];

function extractRequestData(req) {
  const safeHeaders = {};
  for (const [key, value] of Object.entries(req.headers)) {
    if (!SENSITIVE_HEADERS.includes(key.toLowerCase())) {
      safeHeaders[key] = value;
    }
  }
  return {
    method: req.method,
    url: req.url,
    headers: safeHeaders,  // <-- Sensitive headers are filtered out
    // ... other data
  };
}

The patch introduces a denylist of sensitive headers that are excluded from the captured data.

Exploitation & Lab Setup

Red Team (Attacker)

Prerequisites:

• Access to a Sentry organization (e.g., as a developer, or via compromised credentials).
• The target application uses @sentry/node with sendDefaultPii: true.

Steps:

1. Identify Target: Find a Node.js application that uses Sentry with sendDefaultPii: true. This can be inferred from error reports that include PII.
2. Access Sentry: Log in to the Sentry organization (e.g., via a developer account or stolen API key).
3. Query Events: Use Sentry's API or UI to search for events that contain HTTP headers. Look for events with request.headers.cookie or request.headers.authorization.
4. Extract Credentials: Copy the Cookie or Authorization header values.
5. Impersonate User: Use the stolen cookie/token to make requests to the target application as the victim.

Example API Query (using curl):

curl -H "Authorization: Bearer <SENTRY_AUTH_TOKEN>" \
  "https://sentry.io/api/0/organizations/<org>/events/?query=has:request.headers.cookie"

Blue Team (Defender)

Detection:

• Monitor Sentry events for unexpected inclusion of Cookie or Authorization headers.
• Alert on any event where request.headers contains cookie or authorization.

Hunting:

• Search Sentry logs for events with request.headers.cookie present.
• Check if any Sentry users have accessed events containing sensitive headers.

Response:

• Immediately rotate all session tokens and API keys that may have been exposed.
• Disable sendDefaultPii: true until the SDK is patched.
• Upgrade to @sentry/node version 10.27.0 or later.

Indicators of Compromise (IOCs)

• Sentry Event Data: Events containing request.headers.cookie or request.headers.authorization.
• Sentry API Access: Unusual queries to the Sentry API for events with header data.
• Application Logs: Unexpected 401/403 errors after a Sentry event was viewed (indicating token reuse).
• Network Traffic: Outbound connections from the application to Sentry's ingestion endpoint (o<org>.ingest.sentry.io) with large payloads containing header data.

Detection Engineering

YARA Rule

rule sentry_sensitive_header_leak {
    meta:
        description = "Detects Sentry SDK events containing sensitive HTTP headers"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "CVE-2025-65944"
    strings:
        $cookie = /"cookie":\s*"[^"]+"/ nocase
        $authorization = /"authorization":\s*"[^"]+"/ nocase
        $x_api_key = /"x-api-key":\s*"[^"]+"/ nocase
    condition:
        any of them
}

Sigma Rule

title: Sentry SDK Sensitive Header Leak
id: 7a8b9c0d-1e2f-3a4b-5c6d-7e8f9a0b1c2d
status: experimental
description: Detects Sentry SDK events that include sensitive HTTP headers (Cookie, Authorization)
author: Valters IT
date: 2025-04-10
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2025-65944
logsource:
    product: sentry
    service: events
detection:
    selection:
        request.headers.cookie|exists: true
        request.headers.authorization|exists: true
    condition: selection
falsepositives:
    - Legitimate debugging with explicit consent
level: high

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"CVE-2025-65944 - Sentry SDK Sensitive Header Leak";
    flow:to_server;
    content:"o"; distance:0; within:10;
    content:".ingest.sentry.io"; distance:0; within:50;
    pcre:"/\"cookie\":\s*\"[^\"]+\"/i";
    sid:1000001;
    rev:1;
)

Remediation & Mitigation

Immediate Actions:

1. Upgrade SDK: Update @sentry/node to version 10.27.0 or later.

   npm install @sentry/node@latest
   

2. Disable sendDefaultPii: If upgrading is not immediately possible, set sendDefaultPii: false in the Sentry configuration.
3. Rotate Secrets: Rotate all session tokens, API keys, and cookies that may have been exposed.
4. Audit Sentry Access: Review Sentry organization members and API keys. Remove any unauthorized access.

Long-Term Mitigations:

• Implement a web application firewall (WAF) rule to block outbound requests containing sensitive headers to Sentry.
• Use a proxy or middleware to strip sensitive headers before they reach the SDK.
• Regularly audit Sentry events for unexpected PII.

Valters IT Signature

This report was generated by Valters IT Cyber Threat Intelligence Division. For questions, contact threatintel@valtersit.com.