/

CVE-2026-21889

Severity:

HIGH RISK

(7.5)

Improper Access Control in Weblate

CVE-2026-21889

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-284

Impact:

Unauthorized Information Disclosure

Severity:

HIGH RISK

(7.5)

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

Weblate previously served localization screenshot images directly from the HTTP server without enforcing proper access control on those resources.

Under these conditions, an unauthenticated user who can guess or enumerate screenshot filenames may be able to view images that were intended to be restricted to authorized users.

Affected context

This issue affects Weblate deployments where:

  • Screenshot images used for localization context are stored on the server and exposed under predictable or discoverable URLs
  • Access to these image resources is handled by the web server directly rather than through an application-layer permission check
  • Screenshots may contain sensitive UI states, internal tooling, or user data not intended for public exposure

The vulnerability manifests when the image-serving path does not verify the current user's authentication or authorization status before returning the file.

Exploit preconditions

  • Attack surface: Public-facing Weblate instance exposing screenshot URLs over HTTP/HTTPS
  • Required access: No prior authentication required; attacker only needs network access to the Weblate endpoint
  • Trigger point: Direct HTTP requests to screenshot URLs, using guessed or enumerated filenames
  • Why exploitation is possible: The HTTP server serves screenshots as static files without enforcing Weblate's access control logic, enabling unauthenticated retrieval of images when filenames or paths can be predicted or discovered.

Why this happens

The core problem is an authorization gap between how screenshots are stored and how they are accessed.

Instead of routing screenshot requests through an application handler that checks the current user's permissions, the HTTP server serves these files directly.

This design bypasses any contextual access checks (such as project membership or authentication status) and maps to CWE-284: Improper Access Control, where resources are reachable without appropriate authorization enforcement.

Conceptually, the file storage and URL scheme make the filenames guessable or enumerable, and the lack of permission checks turns a predictable identifier into an access token.

Potential impact

  • Unauthorized viewing of internal UI screenshots that may reveal project structures, internal labels, or workflows
  • Exposure of potentially sensitive text or user data captured in screenshots
  • Leakage of information about private or unreleased features indicated in UI captures
  • Assistance to attackers conducting reconnaissance on internal applications and localization targets

General mitigation guidance

Effective mitigations focus on enforcing access control at the resource boundary and reducing guessability of direct resource identifiers:

  • Route all screenshot downloads through application-layer endpoints that perform authentication and authorization checks aligned with project-level permissions.
  • Avoid serving sensitive or contextual assets directly as static files without a permission check.
  • Use unguessable, high-entropy identifiers or time-limited, signed URLs for any file that might require restricted access.
  • Apply the principle of least privilege to file storage paths, limiting which components can read raw screenshots.
  • Document which asset types can be public and which must always be mediated by the application, and configure the web server accordingly.

How teams detect issues like this

Detection can rely on both design-time and runtime approaches:

  • Static analysis / review patterns:
  • Identify static file mappings where application data (e.g., project-specific screenshots) is exposed via direct file serving.
  • Look for resources under predictable paths (e.g., sequential IDs or human-readable filenames) that are not guarded by authentication middleware.
  • Review routing and web server configuration (e.g., reverse proxy, CDN, static directory mappings) for bypasses around authorization logic.
  • Runtime and operational checks:
  • Perform unauthenticated requests to known or guessed asset URLs to verify whether access control is enforced.
  • Use automated crawling tools to discover accessible files and validate whether they should be public.
  • Policy enforcement:
  • Adopt development policies that require access-controlled resources to be served only through application handlers, not raw static paths.
  • Integrate security checks in CI/CD to flag new static directories or patterns that expose user- or project-specific content.

Sources

SourceLink
github.comgithub.com/WeblateOrg/weblate/commit/a6eb5fd0299780eca286be8ff187dc2d10feec47
github.comgithub.com/WeblateOrg/weblate/pull/17516
github.comgithub.com/WeblateOrg/weblate/security/advisories/GHSA-3g2f-4rjg-9385

Frequently asked

questions

It can be exploited by any unauthenticated party who has network access to the affected Weblate instance and can guess or enumerate screenshot filenames, potentially at internet scale if the instance is publicly exposed.

No explicit account is required; the weakness arises because screenshot resources can be retrieved directly by URL without verifying authentication or project membership.

The most robust approach is to route all screenshot access through the application, enforce proper authentication and authorization checks, and avoid direct static serving of any screenshots that are not explicitly intended to be public.

Design file and asset handling so that sensitive or context-rich resources are never served directly by the web server; enforce centralized access control, use non-guessable identifiers or signed URLs, regularly review static content mappings, and include access-control tests in your security and QA processes.

Find out what's already
exploitable in your codebase.