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.

