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-106502

CVE-2026-106502: Sensitive Information Exposure in Backstage Scaffolder Backend

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 7, 2026·6 min read·28 visits

Executive Summary (TL;DR)

Authenticated users can extract raw, unredacted backend-managed credentials from task failure logs and database events generated by failed Backstage Scaffolder workflows.

The @backstage/plugin-scaffolder-backend package prior to version 4.1.0 is vulnerable to sensitive information exposure in Scaffolder task failure events. Under specific template and failure conditions, an authenticated user can retrieve backend-managed credentials, such as VCS access tokens and API keys, from affected task execution events and stored database logs. This vulnerability has been remediated in version 4.1.0 of the package and is bundled with the Backstage platform release v1.54.6.

Vulnerability Overview

The Backstage Open-Source Developer Portal Framework provides a Software Templates feature (the Scaffolder) to automate infrastructure provisioning and codebase bootstrap tasks. This functionality is managed by the @backstage/plugin-scaffolder-backend package, which coordinates step-by-step actions like cloning repositories, creating directories, and registering catalog entities.

To perform operations on behalf of users or the organization, the Scaffolder backend requires access to backend-managed secrets. These secrets include personal access tokens (PATs) for version control platforms like GitHub or GitLab, as well as cloud platform access keys.

Prior to version 4.1.0, a vulnerability existed in the error handling and logging paths of the Scaffolder execution engine. Under certain conditions, when a template execution step or persistence checkpoint failed, the backend leaked the secrets used during task execution into the task's failure events. These unredacted events were recorded in the backend database and exposed to authenticated users via the Scaffolder API.

Root Cause Analysis

The underlying flaw resides in how the NunjucksWorkflowRunner and the associated Winston logging mechanism managed exceptions. In the event of a step failure, the workflow runner caught the raw error object thrown by the step and serialized it into the database via the taskTrack.markFailed(step, err) method.

Because Node.js Error objects, third-party API client exceptions, and database errors often preserve input parameters within their message or stack trace strings, the unredacted secrets were written directly into the DB. This bypasses the typical stdout/stderr logging layers that might otherwise apply basic masking rules.

Furthermore, several specific design factors exacerbated the leak:

  1. Checkpoint Failures: If checkpoint state updates failed, the system stringified the raw error via stringifyError(err) without invoking log-redaction filters.

  2. AggregateError Traps: When multiple parallel actions or actions combined with checkpoint updates failed, the runtime raised an AggregateError. Native JavaScript AggregateError objects retain their constituent error payloads in an internal .errors array. Standard redaction systems that operate on top-level properties missed these deeply nested child errors.

  3. Transformation Gaps: The Winston log redacter used basic key-value equality to build redaction lists. If a template transformed a secret (such as changing uppercase or lowercase using Nunjucks filters like ${{ secrets.token | upper }}), the redacter could not correlate the transformed token with the original secret representation, allowing the transformed secret to bypass validation filters.

Code Analysis

An analysis of the patch in commit 3f1e869708f002fb9838624b7379deb251691b47 reveals the precise architectural changes made to mitigate this exposure.

In plugins/scaffolder-backend/src/scaffolder/tasks/NunjucksWorkflowRunner.ts, the exception handling was modified to actively redact the caught errors before passing them to the state recorder:

// Before Patch
} catch (err) {
  await taskTrack.markFailed(step, err);
  await stepTrack.markFailed();
  throw err;
}
 
// After Patch
} catch (cause) {
  const err = taskLogger.redactError(cause);
  await taskTrack.markFailed(step, err);
  await stepTrack.markFailed();
  throw err;
}

The implementation of redactError in logger.ts was rewritten to sanitize errors. Instead of modifying the error object in-place, which could leave nested fields intact, the patch creates a brand-new, sterile error replica holding only sanitized name, message, and stack properties:

const redactError = (error: unknown): ErrorLike => {
  if ((typeof error !== 'object' || error === null) && typeof error !== 'function') {
    return typeof error === 'string'
      ? createSanitizedError('Error', redact(error))
      : createUnknownError(error);
  }
 
  const errorLike = error as Partial<ErrorLike>;
  let originalName: unknown;
  let originalMessage: unknown;
  let originalStack: unknown;
 
  try {
    originalName = errorLike.name;
    originalMessage = errorLike.message;
    originalStack = errorLike.stack;
  } catch {
    return createSanitizedError(); // Safe fallback for throwing getters
  }
 
  if (typeof originalName !== 'string' || !originalName || typeof originalMessage !== 'string') {
    return createUnknownError(error);
  }
 
  const name = redact(originalName);
  const message = redact(originalMessage);
  const stack = typeof originalStack === 'string' ? redact(originalStack) : undefined;
 
  return createSanitizedError(name, message, stack);
};

This defensive approach effectively strips out any non-standard metadata, custom error attributes, or nested prototype properties, preventing data leaks from alternative object fields.

In terms of completeness, this fix is highly robust. By detaching custom attributes and recreating a standardized object rather than attempting to recursively filter unknown nested fields, the patch addresses both the AggregateError issue and any potential exploitation involving custom getter functions on error objects.

Exploitation

To exploit this vulnerability, an attacker must have authenticated access to the Backstage instance with permissions sufficient to register a template, trigger a template run, or read the event log of an existing task.

An attacker can trigger this information leak by crafting a software template that deliberately forces a failure within an action executing with elevated credentials.

For example, an attacker can define a step that relies on a secret but targets an invalid endpoint or provides bad parameters to a CLI execution. When the step fails, the action handler raises an exception containing the evaluated secret parameter. This unredacted string is written directly to the task_events database.

The attacker then makes an authorized HTTP request to the Scaffolder events endpoint for that specific task: /api/scaffolder/v2/tasks/<task_id>/events. The response contains the raw execution logs, including the error object fields containing the plain-text credentials.

Impact Assessment

The security impact of this vulnerability is classified as Medium. Although it leads to high confidentiality compromise (C:H), exploitation is restricted by attack complexity and privileges required. The attacker must possess authenticated access to the Backstage platform and the ability to trigger or monitor specific Scaffolder tasks.

Despite the Medium CVSS rating, the operational risk remains significant. The credentials stored in Backstage software templates typically belong to high-privilege service accounts or organization-wide deploy tokens. Exfiltration of these tokens can allow attackers to bypass standard access controls on Git repositories, enabling supply chain attacks or giving them the ability to write malicious code to production branches.

Remediation & Mitigation

Remediation requires upgrading the @backstage/plugin-scaffolder-backend package or the overarching Backstage release.

Because task events are stored in the database, upgrading the software prevents future leaks but does not delete historical records. Security teams should run cleanup scripts to purge potentially leaked secrets from the database.

For teams unable to patch immediately, temporary mitigations include implementing strict access controls on the task events API and monitoring database event tables for standard credential regular expressions.

Official Patches

BackstageFix commit implementing error redaction in Scaffolder workflows

Fix Analysis (1)

Technical Appendix

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

Affected Systems

@backstage/plugin-scaffolder-backendBackstage Platform (Core Repository)

Affected Versions Detail

Product
Affected Versions
Fixed Version
@backstage/plugin-scaffolder-backend
Backstage
< 4.1.04.1.0
Backstage (Core Repository)
Backstage
< v1.54.6v1.54.6
AttributeDetail
CWE IDCWE-532
Attack VectorNetwork (AV:N)
CVSS Base Score5.3
EPSS Score0.00284
ImpactHigh Confidentiality Loss (C:H)
Exploit Statusnone
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1552.001Credentials In Files
Credential Access
CWE-532
Insertion of Sensitive Information into Log File

The product writes sensitive information to log files, making it retrieveable by individuals who have read access to the logs or events database.

Vulnerability Timeline

Fix commit merged in official repository
2026-08-21
GitHub Advisory GHSA-95p4-vv4g-jxxm published
2026-10-06
CVE-2026-106502 assigned
2026-10-06
NVD record processed and published
2026-10-07

References & Sources

  • [1]GHSA-95p4-vv4g-jxxm
  • [2]GitHub Fix Commit
  • [3]Backstage Release v1.54.6
  • [4]NVD Record
  • [5]CVE.org Record

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

•about 17 hours ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
4 views•10 min read
•about 18 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
6 views•12 min read
•about 19 hours ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
5 views•12 min read
•about 20 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
10 views•10 min read
•about 21 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
12 views•10 min read
•about 22 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read