Summary
Squidex's Rules engine allows users to configure webhooks whose URL parameter is not validated or restricted, enabling server-side request forgery (SSRF).
An attacker who can define or modify a webhook can coerce the backend to send HTTP requests to internal or otherwise unreachable endpoints and then read the full HTTP response via the rule execution logs, turning a blind SSRF into a full-read SSRF.
Affected context
This vulnerability affects Squidex deployments using the Rules engine with webhook actions enabled.
It becomes relevant when:
- Users are permitted to create or modify rules that execute webhooks.
- The Squidex backend has network access to internal services, cloud metadata endpoints, or other sensitive infrastructure.
- Rule execution logs (including the
lastDumpfield) are available via the API to users who can define these rules.
In such environments, the webhook URL field can be abused to pivot Squidex into acting as a network proxy and data exfiltration channel.
Exploit preconditions
- Attack surface: Squidex Rules engine webhook configuration and rule execution APIs.
- Required access: Ability to create or edit rules that define webhook actions, and permission to view rule execution logs via the API.
- Trigger point: Execution of a rule (manually via the trigger endpoint or automatically through content updates or other configured triggers).
- Why exploitation is possible:
- The webhook
urlparameter accepts arbitrary destinations, including localhost and internal IPs, without network-based allowlisting or blocking. - The backend server performs HTTP requests from a privileged network position on behalf of the user.
- Full HTTP responses are recorded in the
lastDumpfield and exposed via the API, converting what would normally be a blind SSRF into a full read channel.
Why this happens
The underlying issue is an absence of robust network egress and destination validation for user-controlled webhook URLs.
In the Squidex Rules engine, the webhook action trusts user-supplied URLs and sends HTTP requests directly from the server environment without enforcing:
- Restrictions on private or loopback address ranges.
- Protocol and port constraints.
- Hostname and IP resolution validation.
Additionally, the design choice to log the full HTTP response body and headers for rule executions and make this log accessible via the API amplifies the impact, aligning with CWE-918: Server-Side Request Forgery (SSRF).
The combination of unvalidated outbound requests and detailed response logging creates a powerful primitive for internal service discovery and data exfiltration.
Potential impact
- Access to internal HTTP-based services not directly exposed to the internet (e.g., admin panels, internal APIs, debug endpoints).
- Retrieval of sensitive configuration or operational data via internal endpoints.
- Potential access to cloud provider metadata services, which could expose credentials or instance identity tokens.
- Enumeration of internal network structure, including hostnames, ports, and paths reachable from the Squidex server.
- Exfiltration of secrets, tokens, or API keys returned in HTTP responses from internal targets.
- Indirect assistance in lateral movement within the hosting environment by mapping services and collecting configuration data.
General mitigation guidance
Effective mitigation generally focuses on constraining outbound requests from server-side features and minimizing data exposure in logs:
- Implement strict allowlists for webhook destinations, limiting URLs to known, vetted domains or services.
- Block requests to private, loopback, and link-local address ranges (e.g., 127.0.0.0/8, 10.0.0.0/8, 169.254.0.0/16, ::1) at the application layer and, where possible, at the network layer.
- Enforce protocol and port restrictions so that webhook actions can only use safe schemes (e.g., HTTPS) and approved ports.
- Resolve hostnames and verify that the resulting IPs remain within allowed ranges, detecting and rejecting DNS rebinding or indirect access to internal networks.
- Avoid logging full HTTP responses for user-configurable outbound requests; where logging is necessary, redact bodies and sensitive headers by default.
- Apply the principle of least privilege to outbound network access from the Squidex server or container, restricting what internal resources it can reach.
How teams detect issues like this
Organizations can identify and monitor this class of issue through a combination of code-level and operational controls:
- Static analysis and code review:
- Flag features that issue HTTP requests based on user-controlled URLs or domains.
- Look for missing validation around URL parsing, IP range checks, and protocol/port restrictions in webhook or integration modules.
- Review logging patterns where full HTTP responses are stored or returned to users, especially for calls triggered by user configuration.
- Dynamic testing and scanning:
- Use SSRF-focused tests against webhook and integration endpoints to confirm whether internal addresses and metadata URLs are reachable.
- Validate whether responses from internal endpoints are visible via APIs or logs.
- Operational monitoring:
- Monitor outbound HTTP traffic from Squidex instances for connections to internal address ranges or cloud metadata services.
- Implement security policies or WAF rules that detect atypical outbound destinations and block suspicious patterns.
- Automated review tools:
- Integrate application security testing tools capable of detecting SSRF patterns into CI/CD, emphasizing network calls based on configuration fields like webhook URLs.

