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

