Summary
RustFS's FTP frontend read and probe handlers bypass IAM authorization checks, allowing authenticated FTP users to access objects and buckets regardless of explicit deny policies.
When the FTP listener is enabled, any user who can log in over FTP can read, stat, or probe buckets and objects even if their IAM policy forbids s3:GetObject under normal HTTP S3 access.
Affected context
This vulnerability occurs in RustFS deployments that expose the FTP frontend between versions 1.0.0-alpha.1 and 1.0.0-beta.9.
It affects environments where IAM policies are expected to govern access uniformly across all access paths but FTP requests (RETR, SIZE, MDTM, CWD) are routed directly to the storage backend.
The risk is highest in multi-tenant or regulated environments where explicit Deny rules are relied upon to prevent data access across buckets.
Exploit preconditions
- Attack surface: FTP listener exposed by RustFS, reachable over the network.
- Required access: Ability to authenticate to the FTP service (valid credentials or equivalent).
- Trigger point: Issuing FTP commands such as RETR, SIZE, MDTM, or CWD against any bucket or object.
- Why exploitation is possible: FTP read and probe handlers do not invoke the IAM authorization function, so the storage backend serves requests without evaluating allow/deny policies, bypassing explicit IAM Deny constraints.
Why this happens
The root cause is an inconsistent authorization design where some request paths are integrated with IAM policy enforcement while others are not.
Specifically, the FTP read and probe handlers route directly to the storage backend, omitting the IAM authorization call that is used by FTP write/list handlers and the HTTP S3 path.
This maps to CWE-862 (Missing Authorization) and CWE-863 (Incorrect Authorization), where security checks are either absent or applied only to a subset of operations, resulting in a privilege boundary that depends on protocol rather than policy.
Potential impact
- Authenticated FTP users may read any object in any bucket, regardless of IAM Deny rules.
- Users could discover the existence and layout of buckets and objects through FTP probes.
- Sensitive or regulated data can be exposed to accounts intentionally restricted via IAM.
- Policy-based access control models can be undermined, eroding trust in IAM enforcement.
- Potential lateral data exposure across tenants or projects sharing a RustFS deployment.
General mitigation guidance
Mitigation typically focuses on enforcing authorization consistently across all access paths and protocols.
Recommended design patterns include:
- Centralizing IAM checks in a shared authorization layer that every handler must call before touching the storage backend.
- Applying least-privilege principles so protocol frontends never bypass policy evaluation, even for metadata or probe operations.
- Ensuring that deny rules are processed uniformly irrespective of protocol, command type, or handler implementation.
- Minimizing the number of distinct frontends and access paths or subjecting each to the same standardized authorization middleware.
How teams detect issues like this
Detection often involves:
- Reviewing code for handlers or routes that access storage subsystems without invoking common IAM or authorization routines.
- Using static analysis or custom checks to flag calls into backend APIs that lack preceding policy evaluation.
- Establishing architectural policies that mandate a single authorization gateway for all protocol frontends and verifying adherence during code review.
- Conducting periodic access control tests to confirm that explicit Deny policies are enforced identically across HTTP, FTP, and other interfaces.

