/

CVE-2026-49991

Severity:

HIGH RISK

(8.6)

Path Traversal (CWE-22) in RustFS Snowball Extract

CVE-2026-49991

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22, CWE-862

Impact:

Cross-Bucket Write and Tenant Isolation Bypass

Severity:

HIGH RISK

(8.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

RustFS 1.0.0-beta.4 contains a path traversal issue in its Snowball auto-extract feature that lets authenticated users write objects outside their own buckets.

When a user with PutObject rights on a single bucket uploads crafted archive entries, the flawed path normalization and IAM matching logic can route those writes into other tenants' buckets, undermining isolation guarantees.

Affected context

This vulnerability appears in RustFS deployments that:

  • Enable the Snowball auto-extract feature to unpack tar archives server-side
  • Rely on IAM PutObject permissions scoped to specific buckets for tenant isolation
  • Use filesystem-backed path resolution to map object keys to storage locations

Risk is highest in multi-tenant environments where different users or services share a RustFS cluster and trust bucket-level access controls to segregate data.

Exploit preconditions

  • Attack surface: RustFS Snowball auto-extract endpoint receiving tar archives
  • Required access: Authenticated account with PutObject permission on at least one bucket
  • Trigger point: Uploading a tar archive whose entry names contain ../ segments that traverse bucket boundaries
  • Why exploitation is possible: The system fails to sanitize ../ in tar entry names, performs IAM wildcard matching against uncleaned keys, and later cleans filesystem paths in a way that resolves traversal across buckets, allowing writes into locations not covered by the original permissions.

Why this happens

The core bug is insufficient path normalization and validation before enforcing authorization and performing filesystem operations.

Object keys derived from tar entries are trusted even when they contain ../ path traversal sequences, and IAM checks are performed on these raw, unnormalized paths.

Subsequent filesystem path cleaning collapses traversal segments across bucket directory boundaries, effectively re-routing writes into other tenants' buckets.

This pattern maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory and is compounded by CWE-862: Missing Authorization, because the final write location is not correctly rechecked against the intended access scope.

Potential impact

  • Authenticated users may write arbitrary objects into other tenants' buckets
  • Multi-tenant isolation can be completely bypassed for write operations
  • Attackers could plant malicious or misleading data in victim buckets
  • Data integrity in shared storage environments can be compromised
  • Downstream services consuming bucket data may be tricked into processing attacker-controlled content

General mitigation guidance

Effective mitigation focuses on hardening path handling and aligning authorization with actual storage locations.

Recommended patterns include:

  • Normalizing and sanitizing object keys by removing ../ and other traversal constructs before any IAM checks or filesystem resolution
  • Enforcing strict bucket-scoped path constraints, ensuring that cleaned paths cannot escape the designated bucket directory
  • Performing authorization based on canonical, fully normalized object paths rather than raw user input
  • Treating server-side extraction features as high-risk and constraining them with additional checks or dedicated sandboxes
  • Applying least-privilege IAM policies and avoiding broad wildcards that make subtle path bugs more exploitable

How teams detect issues like this

Detection can rely on several complementary approaches:

  • Static analysis rules that flag custom path-cleaning routines, direct handling of user-supplied paths, and concatenation of bucket IDs with untrusted keys
  • Code review practices that require canonicalization of object keys prior to authorization decisions and filesystem access
  • Policy checks ensuring that IAM wildcard patterns cannot inadvertently authorize paths outside intended buckets
  • Runtime logging and anomaly detection to identify Snowball extraction jobs writing into buckets other than the caller's configured scope
  • Automated security testing (e.g., fuzzing archive entry names) to probe for traversal across bucket boundaries

Sources

SourceLink
github.comgithub.com/rustfs/rustfs/security/advisories/GHSA-f4vq-9ffr-m8m3

Frequently asked

questions

The described issue primarily enables cross-bucket writes, not direct reads. However, by placing crafted objects into other buckets, an attacker may influence services that read from those buckets.

An attacker must be an authenticated RustFS user with PutObject permission on at least one bucket and access to the Snowball auto-extract functionality. No elevated or administrative privileges are required.

Normalize and sanitize all object keys derived from user input, remove traversal constructs, enforce directory boundaries per bucket, and perform authorization checks on the canonicalized paths that reflect the actual storage location.

Adopt a strict path-handling policy that treats all user-supplied paths as untrusted, centralize canonicalization logic, validate that cleaned paths remain within intended scopes, and integrate security-focused code review and automated checks into the development process.

Find out what's already
exploitable in your codebase.