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.

