/

CVE-2026-55189

Severity:

HIGH RISK

(7.7)

Missing FTP IAM Authorization (CWE-862) in RustFS

CVE-2026-55189

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-862, CWE-863

Impact:

Privilege Escalation and Unauthorized Data Access

Severity:

HIGH RISK

(7.7)

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'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.

Sources

SourceLink
github.comgithub.com/rustfs/rustfs/security/advisories/GHSA-3g29-xff2-92vp

Frequently asked

questions

Any RustFS deployment that exposes the FTP listener in the affected versions is at risk. Any user who can authenticate over FTP can bypass IAM restrictions on read and probe operations, even if they are blocked via HTTP S3.

The attacker needs valid credentials or equivalent access to log into the FTP frontend. Once authenticated, they can issue FTP commands that bypass IAM checks and access objects and buckets beyond their intended permissions.

The safest approach is to ensure that all protocol handlers, including FTP, route requests through a centralized authorization layer before reaching the storage backend. Every operation that retrieves data or metadata should consistently enforce IAM policies, including explicit Deny rules.

Design systems so that authorization is not implemented ad hoc in individual handlers but instead enforced by shared middleware or gateways. Complement this with routine access-control reviews, tests that validate policy enforcement across all frontends, and coding standards that forbid direct backend access without prior authorization checks.

Find out what's already
exploitable in your codebase.