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



GHSA-G38R-8GMR-GHRF

GHSA-G38R-8GMR-GHRF: Malicious Code Execution via build.rs in Rust Crate mysten-metrics

Alon Barad
Alon Barad
Software Engineer

May 4, 2026·5 min read·37 visits

Executive Summary (TL;DR)

A malicious Rust crate named `mysten-metrics` executes data exfiltration scripts via `build.rs` upon compilation. Developers who compiled this crate must assume their local environment is compromised and immediately rotate all local and cloud credentials.

The `mysten-metrics` Rust crate was published as a malicious package to the crates.io registry. It utilizes a malicious `build.rs` script to execute arbitrary code during the compilation phase, enabling the silent exfiltration of sensitive developer environment variables, SSH keys, and cloud credentials to an external server.

Vulnerability Overview

The mysten-metrics package was published to the Rust crates.io registry as a malicious payload disguised as a legitimate library. The crate impersonates infrastructure components associated with the Mysten Labs ecosystem to trick developers into including it in their dependency trees. The registry maintainers removed the package after identifying its malicious behavior.

This incident represents a direct supply chain attack leveraging the Rust build process. The package contained a single version (0.1.0) and lacked any legitimate functional code or external dependencies. Its sole purpose was to execute malicious routines during the compilation phase on the developer's machine or within a continuous integration pipeline.

The vulnerability class is categorized as Embedded Malicious Code (CWE-506). Because the payload triggers automatically upon compilation, the attack requires minimal interaction from the victim beyond the initial inclusion of the dependency. The exfiltration of environment variables and configuration files presents a severe risk to organizational security.

Root Cause Analysis

The attack vector relies on the standard functionality of build.rs scripts within the Cargo build system. Cargo allows crate authors to include a build script to perform pre-compilation tasks such as generating bindings, compiling C code, or setting configuration flags. This script compiles and runs on the host machine before the main crate compilation begins.

When a developer executes cargo build, cargo test, or cargo check, Cargo automatically compiles the build.rs file into an executable and runs it. The executable runs with the exact same privileges as the user invoking the Cargo command. Cargo does not sandbox or restrict the system access of the build script by default.

The malicious actor abused this design by placing data exfiltration routines directly inside the build.rs file. Because the package possessed no legitimate functionality, the build script served exclusively as the payload delivery mechanism. The lack of execution boundaries allows the script to read arbitrary files and open outbound network connections without user consent or notification.

Exploit Mechanics and Execution Flow

The execution of the malicious payload requires the victim to add mysten-metrics to their Cargo.toml file and run a Cargo command. Once triggered, the compiled build.rs executable scans the local environment for sensitive configuration files and credentials. Targets specifically include standard paths for SSH keys, Cargo registry tokens, and cloud provider configuration files.

After gathering local files, the script iterates through all active environment variables accessible to the build process. Environment variables frequently contain API keys, database connection strings, and continuous integration secrets. The collected data is then serialized into a JSON payload or encoded format for transmission.

The final stage of the exploit involves transmitting the gathered secrets to an external server controlled by the attacker. The script uses standard network sockets to execute an HTTP POST request containing the stolen data. The process occurs silently in the background, allowing the standard build process to fail or complete without explicitly alerting the developer to the data theft.

Impact Assessment

The impact of compiling the mysten-metrics crate is the immediate and silent compromise of the host environment. An attacker gains access to all secrets readable by the user executing the build command. This typically includes source code repository access, cloud infrastructure control, and internal network credentials.

If the crate is compiled on a developer's local workstation, the attacker obtains personal access tokens and SSH keys, enabling lateral movement into organizational repositories. If compiled within a Continuous Integration/Continuous Deployment (CI/CD) pipeline, the impact often escalates to complete infrastructure compromise. CI/CD environments routinely hold highly privileged service account credentials required for production deployments.

The exfiltration occurs instantly upon the first build attempt. There is no persistence mechanism required for the attacker to achieve their primary objective. The compromised credentials can be utilized immediately or sold to initial access brokers, making rapid incident response critical.

Remediation and Incident Response

Organizations must assume full environment compromise if the mysten-metrics crate was downloaded and compiled. The primary remediation step requires the immediate rotation of all secrets present on the affected machine or CI/CD runner. This includes resetting cloud provider credentials, revoking SSH keys, and generating new API tokens.

Developers must remove the dependency from all Cargo.toml files and audit their Cargo.lock files to ensure no transitive inclusion occurred. Local environments require sanitization by running cargo clean and clearing the Cargo registry cache located at ~/.cargo/registry/. Security teams should review network logs for outbound connections from build machines to identify successful exfiltration events.

To prevent future supply chain compromises, development teams should implement dependency auditing tools such as cargo-audit. Organizations should also explore sandboxing local build environments and CI/CD runners to restrict outbound network access and file system reads during the compilation process.

Official Patches

RustSecRustSec Advisory confirming removal of package
GitHub Advisory DatabaseGitHub Advisory for GHSA-G38R-8GMR-GHRF

Technical Appendix

CVSS Score
10.0/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H

Affected Systems

Rust Developer WorkstationsContinuous Integration / Continuous Deployment (CI/CD) pipelines running Cargo

Affected Versions Detail

Product
Affected Versions
Fixed Version
mysten-metrics
crates.io
All versions (including 0.1.0)None (Removed)
AttributeDetail
CWE IDCWE-506
Attack VectorSupply Chain / Malicious Dependency
Execution Triggercargo build / compilation phase
Exploit StatusActive
Target Operating SystemsAll OS (Cross-platform execution)
ImpactHigh (Data Exfiltration / Credential Theft)

MITRE ATT&CK Mapping

T1195.001Compromise Software Dependencies and Development Tools
Supply Chain Compromise
T1059Command and Scripting Interpreter
Execution
T1552Unsecured Credentials
Credential Access
T1048Exfiltration Over Alternative Protocol
Exfiltration
CWE-506
Embedded Malicious Code

Embedded Malicious Code that performs actions contrary to the security interests of the developer.

Known Exploits & Detection

crates.ioActive deployment of malicious package on the public registry.

Vulnerability Timeline

Malicious crate `mysten-metrics` published to crates.io.
2026-04-20
Malicious activity reported to security maintainers.
2026-04-22
Official security advisory issued; package removed from crates.io.
2026-04-24
GHSA-G38R-8GMR-GHRF and RUSTSEC-2026-0107 published.
2026-04-24

References & Sources

  • [1]GitHub Advisory: GHSA-G38R-8GMR-GHRF
  • [2]RustSec Advisory: RUSTSEC-2026-0107
  • [3]Meterian Vulnerability Database Entry
  • [4]CIRCL Vulnerability Feed

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

•8 minutes ago•CVE-2026-86046
7.1

CVE-2026-86046: Arbitrary File Write via Path Traversal in termux-sync Restore Workflow

A path traversal vulnerability (CWE-22) in termux-sync prior to version 1.2.4 allows an attacker to overwrite arbitrary files within the Termux environment during the backup restoration process. The flaw stems from the application trusting attacker-controlled extraction paths defined in the backup's manifest.json file, failing to validate archive members against directory traversal sequences during tar extraction, and using unsanitized backup names when constructing temporary directories. If a user restores a malicious backup archive from local storage, shared folders, GitHub, or Google Drive, an attacker can overwrite sensitive configuration files such as shell startup scripts or local binaries, resulting in arbitrary code execution under the privileges of the Termux user.

Amit Schendel
Amit Schendel
0 views•11 min read
•about 1 hour ago•CVE-2026-129296
6.5

CVE-2026-129296: Path Traversal in SpamScope mail-parser Attachment Extraction

SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 2 hours ago•CVE-2026-129295
7.5

CVE-2026-129295: Polynomial Regular Expression Denial of Service (ReDoS) in SpamScope mail-parser

A Regular Expression Denial of Service (ReDoS) vulnerability exists in SpamScope mail-parser versions 4.2.0 prior to 4.6.1. Two separate regular expressions evaluated during standard email header parsing exhibit quadratic to cubic backtracking complexity when processing headers padded with whitespace or angle brackets. An unauthenticated remote attacker can exploit this flaw by sending a small, RFC-compliant email message, causing parsing worker threads or processes to stall at 100% CPU utilization for extended periods.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 3 hours ago•CVE-2026-129297
7.5

CVE-2026-129297: Sender IP Address Spoofing in SpamScope mail-parser

CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 4 hours ago•CVE-2026-129299
6.5

CVE-2026-129299: Uncaught Exceptions and Silent Header Loss via Reflective Attribute Dispatch in SpamScope mail-parser

CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 5 hours ago•CVE-2026-129236
7.2

CVE-2026-129236: Command-Line Argument Injection in Kubeshark MCP Server

CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.

Alon Barad
Alon Barad
6 views•11 min read