Summary
Anchorr versions 1.4.1 and below contain a stored cross-site scripting (XSS) vulnerability in the Jellyseerr user selector, allowing arbitrary JavaScript to execute in the Anchorr admin's browser.
An attacker with a Jellyseerr account can use this to call the authenticated /api/config endpoint, steal the full application configuration, forge a valid Anchorr session token, and gain full admin access and control over connected services without knowing the admin password.
Affected context
This vulnerability arises in Anchorr deployments (v1.4.1 and below) when Jellyseerr is integrated and its user selector feature is exposed in the Anchorr admin dashboard.
It becomes exploitable when:
- Jellyseerr user-controlled data is rendered in the Anchorr admin UI without proper output encoding, and
- At least one Anchorr administrator later views or interacts with the affected UI component in a browser that executes the stored payload.
The issue is not tied to a specific hosting model; it is relevant wherever Anchorr is deployed and integrated with Jellyseerr and used by an admin via a web browser.
Exploit preconditions
- Attack surface: Anchorr web UI, specifically the Jellyseerr user selector rendered in the admin dashboard.
- Required access: Ability to create or control a Jellyseerr account or data record that appears in the user selector (e.g., standard user account in Jellyseerr).
- Victim interaction: An Anchorr admin must open the affected admin page in a browser, causing the stored script to execute in their authenticated session.
- Trigger point: Rendering of attacker-controlled Jellyseerr user data in the admin browser without proper HTML/JavaScript sanitization or encoding.
- Why exploitation is possible: User-supplied content from Jellyseerr is injected into the DOM as HTML/JavaScript, rather than being safely encoded, enabling persistent script execution in the admin's trusted context.
Why this happens
The core issue is a failure to properly sanitize or encode user-controlled data before rendering it into the Anchorr admin interface, matching CWE-80: Improper Neutralization of Script-Related HTML Tags in a Web Page (Basic XSS).
Anchorr trusts Jellyseerr user selector data and inserts it into the page in a way that allows HTML/script tags to be interpreted by the browser.
Once the script runs in the admin's authenticated context, it can call privileged endpoints like /api/config, which returns highly sensitive configuration data in plaintext, reflecting additional weaknesses:
- CWE-212: Improper Removal of Sensitive Information Before Storage or Transfer – sensitive tokens and configuration values are returned wholesale through an API meant for configuration access.
- CWE-311: Missing Encryption of Sensitive Data – sensitive secrets are transmitted in clear form to the client, relying solely on session trust instead of minimizing exposure.
Together, these patterns create a chain vulnerability: stored XSS in the UI plus overexposed, unredacted configuration data in an authenticated API.
Potential impact
- Full compromise of the Anchorr admin account via forged session token.
- Theft of all configuration data, including API keys and service tokens, from the
/api/configresponse. - Account takeover of the Jellyfin media server via
JELLYFIN_API_KEY. - Account takeover of the Jellyseerr request manager via
JELLYSEERR_API_KEY. - Control of the Discord bot via
DISCORD_TOKEN, including impersonation and command abuse in Discord. - Long-term persistence through creation of additional admin accounts, reconfigurations, or deployment of malicious automations.
- Potential lateral movement into other systems that trust the compromised services or reuse the exposed tokens.
General mitigation guidance
Effective mitigation focuses on both preventing XSS and minimizing the impact of any UI compromise:
Preventing stored XSS:
- Apply strict output encoding for all user-supplied fields rendered in templates, particularly for data sourced from Jellyseerr.
- Use templating or component frameworks that auto-escape values by default, avoiding direct HTML injection or string concatenation when building the DOM.
- Restrict or sanitize HTML-like input at ingestion, validating and stripping script-related constructs before storing or forwarding data.
- Avoid using APIs or rendering modes (e.g.,
innerHTML) that interpret strings as HTML unless absolutely necessary and tightly controlled.
Reducing configuration exposure:
- Split configuration data into public vs. sensitive portions and avoid returning secrets (API keys, tokens) to browser clients.
- Introduce dedicated minimal endpoints for UI needs rather than exposing a "full config dump" API.
- Treat API keys and tokens as high-value secrets and keep them on the server side, using server-mediated calls to external services where possible.
Privilege and session hardening:
- Apply least-privilege principles for admin actions: require explicit user intent for high-risk operations and avoid baking powerful operations into easily callable endpoints.
- Implement session binding and token integrity checks that make it harder to clone or reuse admin sessions across environments.
How teams detect issues like this
Detection can combine code-centric and runtime approaches:
Static and code review:
- Search for direct insertion of Jellyseerr or other user-controlled fields into HTML without escaping, especially in admin views.
- Flag uses of dangerous DOM APIs (
innerHTML,outerHTML,document.write, or raw template string injection) where data originates from external services. - Review API handlers such as
/api/configthat return configuration data, ensuring secrets are redacted or never exposed to the client. - Use static analysis or SAST tools configured with XSS rules (CWE-79/CWE-80) and sensitive data exposure patterns (CWE-212/CWE-311).
Runtime and operational monitoring:
- Inspect HTTP logs for abnormal or frequent access to configuration endpoints from browser contexts or non-admin IPs.
- Monitor for unusual admin session activity (e.g., logins from new locations, rapid configuration reads, or sudden API key usage spikes).
- Employ Content Security Policy (CSP) reporting to capture attempted script injections and inline script execution where supported.

