Summary
Pipecat's development WebSocket runner exposed unauthenticated telephony control endpoints that accept attacker-supplied call identifiers and perform authenticated hang-up actions via Twilio, Telnyx, or Plivo APIs.
When reachable in a deployed or shared environment, an attacker can connect to the /ws endpoint without credentials and trigger call termination on behalf of the server operator.
Affected context
This vulnerability affects deployments that expose the Pipecat development runner's /ws WebSocket endpoint in environments accessible beyond a trusted local context.
It manifests when the endpoint handles telephony testing traffic, accepts a callSid (or equivalent call identifier) from an incoming stream handshake, and then uses the server's configured Twilio, Telnyx, or Plivo credentials to control calls.
The risk increases when the development runner is used in staging, shared, or production-like environments without additional network or application-layer authentication.
Exploit preconditions
- Attack surface: Public or internally reachable
/wsWebSocket endpoint on the Pipecat development runner. - Required access: Network-level ability to establish a WebSocket connection; no application authentication is required.
- Trigger point: Sending a crafted telephony handshake that includes an attacker-chosen
callSidor similar call identifier. - Why exploitation is possible: The server trusts the caller-provided identifier and invokes Twilio/Telnyx/Plivo REST APIs using its own authenticated credentials without verifying the client's authorization to control the referenced call.
Why this happens
The issue stems from a missing authorization check on a sensitive control operation, aligning with CWE-862: Missing Authorization.
The development runner exposes a convenient /ws endpoint meant for testing, but it accepts arbitrary call identifiers from unauthenticated clients and forwards them to telephony provider SDKs or serializers.
By not enforcing any authentication or authorization on this endpoint, the server effectively treats untrusted client input as if it were trusted operator intent, allowing unauthorized users to trigger authenticated call-control actions.
Potential impact
- An attacker could cause active calls to be forcibly terminated using the server operator's telephony account.
- The attacker may disrupt customer support, sales, or operational communication workflows that rely on the affected telephony integration.
- Repeated abuse could degrade trust in the system and generate support overhead for unexplained call drops.
- Depending on additional integrations or future features, similar missing checks could enable broader telephony account misuse.
General mitigation guidance
Effective mitigation centers on enforcing explicit authorization boundaries around telephony control operations and development utilities:
- Require authentication (such as API keys, tokens, or session-based auth) on any WebSocket or HTTP endpoints that trigger call-control actions.
- Implement fine-grained authorization checks tying each call identifier to a specific user, tenant, or trusted service context before performing provider API actions.
- Separate development/testing runners from production services, ensuring test endpoints are not exposed in internet-reachable environments.
- Apply the principle of least privilege when configuring telephony provider credentials, limiting which calls or resources can be controlled from a given integration.
- Regularly review exposed debug and test endpoints to ensure they cannot perform sensitive actions without safeguards.
How teams detect issues like this
Detection efforts can focus on both code-level and operational signals:
- Static analysis and code review: Search for WebSocket or HTTP handlers that invoke telephony provider APIs (Twilio, Telnyx, Plivo) without preceding authentication or authorization checks.
- Policy enforcement: Define secure coding guidelines that require access control middleware or decorators on all endpoints capable of performing external state-changing actions.
- Runtime monitoring: Inspect telephony provider logs for anomalous patterns, such as hang-up requests originating from the integration account at unexpected times or from non-standard workflows.
- Automated tooling: Use application security testing tools or custom linters to flag endpoints marked as "development" or "test" that can still reach production credentials or call-control sinks.

