/

CVE-2026-53649

Severity:

CRITICAL RISK

(9.6)

Cross-Origin Request Forgery (CWE-352) in Joro API Proxy

CVE-2026-53649

Deferred

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-306, CWE-352, CWE-434, CWE-942

Impact:

Unauthenticated Remote Code Execution

Severity:

CRITICAL RISK

(9.6)

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

A critical browser-to-localhost request forgery vulnerability in Joro exposes privileged proxy API endpoints without authentication and permits requests from any origin. A malicious webpage visited by an operator may use the operator's browser to upload a native plugin and trigger a restart, resulting in remote code execution under the operator's account.

Affected context

The issue affects Joro deployments using the default proxy mode with its local API bound to 127.0.0.1:9090. Risk is present when the API lacks authentication, accepts wildcard cross-origin requests, and exposes plugin upload and restart functionality that can be reached from browser-originated requests. The browser's handling of multipart/form-data allows these requests to avoid a preflight check.

Exploit preconditions

  • Attack surface: The Joro local proxy API exposed on 127.0.0.1:9090
  • Required access: No direct API authentication is required; the victim must be running the affected Joro proxy
  • Trigger point: An operator visits a webpage containing cross-origin JavaScript
  • Why exploitation is possible: Wildcard CORS permits cross-origin access, while multipart/form-data is CORS-safelisted and can reach privileged plugin upload and restart endpoints without a preflight
  • Execution condition: Uploaded native plugins execute when loaded, allowing code to run with the operator's user privileges

Why this happens

The vulnerability combines missing authentication on a privileged local API with an overly permissive wildcard CORS policy. Because browser-originated multipart/form-data requests can be sent without a preflight, a hostile origin can invoke sensitive endpoints through the operator's browser.

This primarily maps to CWE-352: Cross-Site Request Forgery, because an external webpage can induce state-changing requests to a service available in the victim's browser context. The behavior also relates to CWE-306: Missing Authentication, CWE-942: Permissive Cross-domain Policy, and CWE-434: Unrestricted Upload of File with Dangerous Type.

Potential impact

  • An attacker may execute native code as the Joro operator
  • A malicious plugin could access local files, credentials, or development resources
  • The operator's browser may be used to invoke other privileged local API actions
  • An attacker could disrupt proxy availability by triggering restarts
  • Compromised local tools or credentials could enable further compromise

General mitigation guidance

Mitigation typically focuses on protecting local administrative APIs and reducing the trust placed in browser-originated requests.

Common defensive patterns include:

  • Requiring strong authentication and authorization for every privileged API endpoint
  • Binding administrative interfaces only where necessary and isolating them from general browser access
  • Replacing wildcard CORS with an explicit allowlist, or disabling cross-origin access when it is not required
  • Requiring anti-CSRF protections and validating trusted request origins for state-changing operations
  • Restricting plugin uploads to authenticated, authorized users and validating file type, format, signature, and execution policy
  • Avoiding automatic execution of uploaded native components where a safer extension model is available
  • Running the application with least privilege and separating operator credentials from plugin execution privileges
  • Applying vendor-maintained security fixes and verifying that local API security controls are enabled by default

How teams detect issues like this

Detection can combine code review, runtime testing, and policy enforcement.

  • Use static analysis to identify unauthenticated administrative routes, wildcard CORS headers, and state-changing endpoints lacking CSRF defenses.
  • Review browser-facing APIs for multipart/form-data handlers that accept uploads or restart commands without an explicit authentication boundary.
  • Test local services from an unrelated origin to determine whether privileged requests are accepted without preflight or user confirmation.
  • Monitor local API access, plugin upload events, restart operations, and execution of newly introduced native modules.
  • Enforce development policies that prohibit wildcard CORS on privileged interfaces and require authentication for administrative operations.
  • Automated security review tools can help flag missing authentication, dangerous upload handling, and permissive cross-origin policies.

Sources

SourceLink
github.comgithub.com/BishopFox/joro/releases/tag/1.1.1
github.comgithub.com/BishopFox/joro/security/advisories/GHSA-xqhv-chqm-fhcc

Frequently asked

questions

Yes, in a drive-by sense. The attacker may host a webpage remotely, but the malicious requests are sent by the victim's browser to the Joro API running on the victim's local machine.

The attack does not require the attacker to authenticate to Joro or connect directly to the local port. The key requirement is that the victim is running the affected proxy and visits a malicious or compromised webpage.

Protect every privileged local API endpoint with authentication and authorization, restrict cross-origin access to trusted origins or disable it, and require explicit validation before accepting or executing uploaded plugins.

Treat localhost administrative services as security-sensitive, apply deny-by-default CORS policies, test requests from untrusted origins, enforce CSRF protections, and separate plugin execution privileges from the operator's account.

Find out what's already
exploitable in your codebase.