May 4, 2026·5 min read·37 visits
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.
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.
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.
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.
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.
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.
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
mysten-metrics crates.io | All versions (including 0.1.0) | None (Removed) |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-506 |
| Attack Vector | Supply Chain / Malicious Dependency |
| Execution Trigger | cargo build / compilation phase |
| Exploit Status | Active |
| Target Operating Systems | All OS (Cross-platform execution) |
| Impact | High (Data Exfiltration / Credential Theft) |
Embedded Malicious Code that performs actions contrary to the security interests of the developer.
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.
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.
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.
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.
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.
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.