Skip to main content

arrayref EUVDEUVD-2026-63780

| CVE-2026-77651 CRITICAL
Embedded Malicious Code (CWE-506)
2026-08-21 mitre GHSA-jvc2-9prg-ffvc
9.8
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Publish trojaned arrayref 0.3.10 to crates.io
  2. Delivery
    Victim resolves it as a dependency
  3. Exploit
    cargo build runs malicious proc-macro/build script
  4. Execution
    Payload beacons to C2 server
  5. Persist
    Attacker issues arbitrary commands on build host
  6. Impact
    Credential theft and lateral movement

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Code review, malicious code detection
Exploitation Conditions

Triggering requires that a target project actually declares or transitively resolves arrayref 0.3.10 and then compiles it (running cargo build, cargo test, or any build that invokes the crate's build script/proc-macro), and that the build host has outbound network access to reach the command-and-control server. Limiting factors: exploitation is confined to the specific malicious version 0.3.10 (unaffected versions do not trigger it), it fires only at build/compile time rather than in a shipped running service, it depends on the victim adding or already depending on the crate (effective user interaction), and egress-filtered or air-gapped build environments blunt the C2 callback even if the code executes.

Impact

The input CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H = 9.8) overstates the true access model: exploitation is not a remote unauthenticated network hit against a running service but requires a victim to add and compile the poisoned crate, which is functionally user interaction (UI:R). Despite that nuance, real-world risk is high because the affected version is confirmed weaponized malware documented by the Rust project blog, StepSecurity, SafeDep, and RustSec - the technical impact is total (full code execution on build/CI infrastructure) and it is trivially automatable once the crate is in a dependency tree. No EPSS score, SSVC decision, or CISA KEV entry was provided in the input, so quantitative exploitation-probability signals are missing; however, the qualitative evidence of an active, disclosed supply-chain attack should override the absence of those scores. Treat as an urgent priority for any Rust shop, while noting the impact is scoped to environments that actually built with 0.3.10.

Exploit ScenarioDerived

An attacker publishes the trojaned arrayref 0.3.10 to crates.io; a developer or CI system resolves it as a direct or transitive dependency and runs cargo build. The malicious build-time dependency executes automatically during compilation, calls out to the attacker's C2 server, and grants arbitrary command execution on the build host - allowing credential theft, lateral movement, or poisoning of produced binaries. This is not a theoretical POC: the malicious code is the crate itself as documented by the Rust Security Response team.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 21, 2026

Build-time malicious code execution in the arrayref Rust crate version 0.3.10 allows an attacker to run arbitrary code on any developer or CI machine that compiles a project depending on it. The compromised release pulls in a rogue transitive dependency that beacons to a command-and-control server and accepts arbitrary command execution, making this a confirmed supply-chain compromise disclosed by the Rust Security Response WG and RustSec (RUSTSEC-2026-0260). No public standalone exploit is needed because the crate itself is the payload; not currently listed in CISA KEV.

RemediationAI

No vendor-released clean patch version is confirmed in the provided data; the primary action is to immediately stop using arrayref 0.3.10 and pin to a known-good prior release (verify the exact safe version against RUSTSEC-2026-0260 before pinning rather than trusting an assumed number). Run cargo update/cargo tree -i arrayref to find where 0.3.10 entered the dependency graph, purge Cargo.lock entries referencing it, and clear cached copies from ~/.cargo/registry and CI caches. Treat any machine that built with 0.3.10 as potentially compromised: rotate credentials, tokens, and SSH keys present on those build/CI hosts and inspect for C2 beacon traffic and unexpected child processes spawned during builds. As a durable compensating control, build in network-egress-restricted or sandboxed CI where build scripts/proc-macros cannot reach external hosts (trade-off: may break crates that legitimately fetch resources at build time), and adopt dependency-scanning tooling such as cargo-vet or the SafeDep/StepSecurity detections referenced in the advisories (https://www.stepsecurity.io/blog/arrayref-rust-crate-supply-chain-attack, https://safedep.io/arrayref-proc-macro1-rust-build-time-malware/). If the crate has been yanked from crates.io, ensure your registry mirror reflects the yank.

Affected VersionsENISA

arrayref 0.3.10

Affected Packages

euvd arrayref no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

arrayref is a widely-used, small low-level Rust crate (originally by droundy) that provides macros for safely taking array references to slices; it commonly appears as a transitive dependency of cryptographic and hashing crates. The classified root cause is CWE-506 (Embedded Malicious Code): the 0.3.10 release was tampered to declare a rogue dependency (reported as a malicious proc-macro/build-time component) that executes during cargo build. Because Rust build scripts and procedural macros run with the full privileges of the compiling user, code triggered at compile time - not runtime - registers with a C2 server and enables arbitrary command execution on the build host.

Know when Arrayref 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 (mitre) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

Crate is delivered over the network (AV:N) but requires the victim to depend on and compile it (UI:R); build-time execution yields full C:H/I:H/A:H on the host.

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

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

DescriptionCVE.org

The arrayref crate 0.3.10 for Rust can trigger execution of malicious code when compiling a project that uses the crate, because it has a rogue dependency that registers with a command-and-control server to offer arbitrary code execution.

Executive ViewAI

Why It Matters

The arrayref Rust crate version 0.3.10 contains a malicious supply-chain compromise that executes arbitrary code during the build process on any developer or CI system, affecting all projects with this dependency. With no vendor-released patch identified at time of analysis and critical severity (CVSS 9.8), immediate action is required to identify, isolate, and remediate all affected systems.

Business Impact: Severe
Compensating Controls

Prevent compilation of projects using arrayref 0.3.10 through dependency version pinning and restrictions; isolate affected build systems from production networks; monitor for command-and-control beaconing; implement mandatory code signing of all build artifacts; establish allowlisting of approved Rust crates with quarterly security review of transitive dependencies.

Threat Intelligence Overview

EPSS Score
0.4%
Top 64% exploitable
Prevalence
Medium
widely-used Rust crate but only version 0.3.10 malicious, build-time scope
Social Media
6
Sightings
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub 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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
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
Out-of-Cycle
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

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

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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