Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect to WS/WSS SIP endpoint
-
DeliveryComplete WebSocket handshake
-
ExploitSend frame header with huge declared length
-
ExecutionTrigger unvalidated makeslice allocation
-
PersistPanic or exhaust memory
-
ImpactServer process crashes (DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Exploitable only when a service built on sipgo enables the WebSocket transport (WS or WSS) and exposes it to the network; the SIP-over-WebSocket listener must be reachable by the attacker. No authentication, credentials, or user interaction are required (PR:N/UI:N) - after a standard WebSocket handshake a single crafted frame header triggers the flaw against default configurations of sipgo <=1.4.2. The primary limiting factor is deployment: services using only UDP/TCP/TLS SIP transports (not WebSocket) are not affected, and the impact is limited to denial of service with no confidentiality or integrity consequences. |
| Impact | This is a genuine but bounded risk. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 HIGH) is well-supported by the evidence: a single unauthenticated WebSocket frame reaches vulnerable code with no privileges or user interaction, matching AV:N/AC:L/PR:N/UI:N. Impact is availability-only (A:H, C:N/I:N) - there is no code execution, data disclosure, or integrity loss, consistent with CWE-789 uncontrolled memory allocation. Working PoC code is embedded in the GHSA advisory (a masked text frame declaring length 2^63-1 triggers a makeslice panic), so publicly available exploit code exists, though there is no CISA KEV listing and no EPSS score in the provided data. No SSVC decision data was supplied. The realistic-priority weighting is tempered by product prevalence: sipgo is a niche Go SIP library, not a ubiquitous component, so widespread automated exploitation is unlikely despite the low attack complexity. For any organization actually running a sipgo-based SIP service on WS/WSS, this is a real and trivially-triggerable crash and should be patched to 1.4.3; for everyone else it is not relevant. No signals conflict here - the vector, description, and advisory all align on unauthenticated remote DoS. |
| Exploit ScenarioDerived | An attacker completes a normal WebSocket handshake against a sipgo-based SIP service exposed over WS/WSS, then sends a single masked frame containing only a header that declares a payload length near 2^63-1. WSConnection.Read calls make([]byte, header.Length) before any size validation, causing a makeslice panic (or massive allocation) that crashes the unrecovered server process. Working proof-of-concept code and the exact byte sequence are published in the GHSA-8h6x-h86x-75wh advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 22, 2026
Unauthenticated denial of service in the sipgo SIP library (versions up to and including 1.4.2) lets any remote attacker who can reach a SIP-over-WebSocket (WS or WSS) listener crash or memory-exhaust the server process. WSConnection.Read allocates a buffer directly from the client-declared WebSocket frame length - a value the attacker controls up to 2^63-1 - before MaxFrameSize or the downstream ParseMaxMessageLength check is ever applied, so a single header-only frame with a huge declared length triggers a makeslice panic that terminates the whole process (sipgo does not recover it), or forces an oversized allocation. No authentication, credentials, or user interaction are required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CVSS 7.5, CWE-789), a working proof-of-concept frame is documented in the vendor advisory, and the flaw is fixed in 1.4.3; impact is confined to availability, with no confidentiality or integrity effect, and only services that actually enable the WS/WSS transport are exposed.
RemediationAI
Upgrade to sipgo v1.4.3, which is the first release containing the fix; the vendor commit 769e4bc958376e2363566c8f7042202b410becdc sets reader.MaxFrameSize = int64(ParseMaxMessageLength) in sip/transport_ws.go so oversized frame headers are rejected before the buffer allocation occurs (see GHSA-8h6x-h86x-75wh and the v1.4.3 tag). Until the module dependency can be bumped, the most effective compensating control is to avoid exposing the WS/WSS SIP transport to untrusted networks at all: if you only need UDP/TCP/TLS SIP signalling, disable the WebSocket listener entirely, though this breaks browser/WebRTC clients that depend on SIP-over-WebSocket. If the WebSocket listener must stay reachable, place it behind a proxy or load balancer that terminates or forwards the WebSocket connection and enforces a strict maximum frame/payload size, and restrict the WS listener to known client networks via firewall or mTLS; note the trade-off that many generic reverse proxies validate frames for the leg they terminate but do not constrain the frame sizes that reach the upstream Go process, and that rate limiting alone will not stop a single-frame panic - the upstream process must be restarted to recover from a crash.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The issue lies in the WebSocket transport implementation of sipgo (emiago/sipgo), specifically WSConnection.Read in sip/transport_ws.go. Go's WebSocket parsing here is delegated to the gobwas/ws library: wsutil.NewReader is constructed without a MaxFrameSize, and the package documents 0 as unlimited, so NextFrame() happily returns a header whose Length field is fully attacker-controlled. sipgo then executes data := make([]byte, header.Length) using that length, meaning resource allocation is driven by unvalidated client input before the application-layer size constraint (ParseMaxMessageLength) is reached - the classic CWE-789 pattern of allocating resources based on an untrusted, unbounded size value. A length near 2^63-1 pushes make past the maximum slice size, producing a 'makeslice: len out of range' runtime panic on the read goroutine (observed at transport_ws.go:400 under TransportWS.readConnection); because sipgo does not recover from this panic, the entire server process dies, while smaller-but-still-huge values cause memory exhaustion. The reference CPE cpe:2.3:a:emiago:sipgo:*:*:*:*:*:*:*:* captures the pre-fix Go module range, and the vendor patch (commit 769e4bc958376e2363566c8f7042202b410becdc) adds the single defensive line reader.MaxFrameSize = int64(ParseMaxMessageLength), applying the message-length limit at the frame-reading layer so oversized headers are rejected before any allocation.
Know when Sipgo gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Single unauthenticated network frame after a WS handshake triggers a reliable crash, so AV:N/AC:L/PR:N/UI:N; impact is availability-only (A:H), no confidentiality or integrity effect.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
SIPGO is a library for writing SIP services in the GO language. Prior to 1.4.3, WSConnection.Read in sip/transport_ws.go creates a wsutil.Reader without setting MaxFrameSize, allowing NextFrame to accept a client-controlled header.Length before ParseMaxMessageLength is applied. An unauthenticated WS or WSS peer can send a frame header declaring an extremely large payload, causing an oversized allocation or a makeslice length panic before the payload is read and crashing or exhausting memory in the server process. This issue is fixed in version 1.4.3.
Technical POC Analysis
CWE-789 (Memory Allocation with Excessive Size Value).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Any real-time communications service built on the sipgo SIP library at version 1.4.2 or earlier can be taken fully offline by a single unauthenticated WebSocket frame sent by a remote attacker, with no credentials or user interaction required. Because the flaw terminates the entire server process rather than degrading an individual call or session, organizations running internet-exposed or partner-reachable SIP-over-WebSocket listeners should treat service availability for voice, messaging, and contact-center traffic as the exposure at stake. Publicly available exploit code exists, so the barrier to attempting this attack is low, although the impact is limited to availability with no effect on data confidentiality or integrity.
Apply vendor patch: upgrade to sipgo 1.4.3, which the advisory states fixes the flaw. Until the upgrade is deployed, restrict WS/WSS listeners to trusted networks, place them behind a proxy or load balancer that caps WebSocket frame sizes and connection rates, disable WS/WSS listeners where they are not operationally required, and run the process under supervision with automatic restart and termination alerting to limit outage duration.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-84818
GHSA-8h6x-h86x-75wh
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB