Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed TChannel listener
-
DeliveryComplete standard init handshake
-
ExploitSend call fragment with checksum, zero arg chunks
-
ExecutionReader indexes empty chunk slice
-
PersistUnrecovered Go slice-bounds panic
-
ImpactDispatch goroutine crashes hosting process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Array index validation
|
| Exploitation Conditions | Exploitation requires network reachability to a TChannel listener that is exposed to untrusted peers, and the attacker must first complete the standard TChannel initialization handshake before sending the malformed call fragment (checksum metadata present, zero length-prefixed argument chunks) on the inbound call path. No authentication, user interaction, or special product configuration beyond running github.com/temporalio/tchannel-go prior to v1.22.1 is needed (PR:N/UI:N/AC:L). The primary LIMITING factor is deployment exposure: TChannel is commonly an internal service-mesh/RPC transport, so realistic risk is confined to environments where that listener accepts connections from untrusted or attacker-controlled network positions; services that bind TChannel only to trusted internal peers are far less exposed. |
| Impact | This is a genuine, well-scoped availability risk rather than an inflated high-CVSS artifact. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H, base 8.7) is internally consistent with the description: a network-reachable, unauthenticated, low-complexity path that reliably crashes the hosting Go process via an unrecovered slice-bounds panic (CWE-129). No EPSS score, CISA KEV listing, or public POC was provided, so there is no evidence of active or automated exploitation - this places it as no public exploit identified at time of analysis, meaning the 8.7 reflects worst-case impact/reachability, not observed weaponization. The impact is strictly availability (VC:N/VI:N/VA:H); there is no confidentiality or integrity exposure, so this is a crash/DoS priority, not a compromise priority. The one caveat that tempers real-world risk: exploitation requires reaching a TChannel listener exposed to untrusted peers, and TChannel is typically an internal service-mesh RPC transport, so blast radius depends heavily on network exposure rather than being internet-facing by default. No SSVC decision data was supplied. Overall: patch promptly where the listener is reachable by untrusted parties, but the low deployment exposure of the protocol and absence of exploitation signals keep it below the tier of an internet-facing pre-auth RCE. |
| Exploit ScenarioDerived | An attacker who can reach a service's TChannel listener completes the standard initialization handshake, then sends a single malformed call fragment carrying checksum metadata but no length-prefixed argument chunks. The fragment reader leaves its chunk slice empty and then indexes element zero, triggering an unrecovered Go slice-bounds panic on a library-created dispatch goroutine that terminates the entire hosting process. No public exploit code was identified, but the malformed-fragment recipe is fully described and trivial to reproduce given the unauthenticated, low-complexity network path. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 21, 2026
Unauthenticated remote denial of service in github.com/temporalio/tchannel-go (the Go implementation of the TChannel RPC protocol) before v1.22.1 lets any network peer that can complete the standard TChannel initialization handshake crash the hosting process. A crafted call fragment that carries checksum metadata but contains no length-prefixed argument chunks leaves the fragment reader's chunk slice empty, and the unconditional selection of the first element triggers an unrecovered Go slice-bounds panic on a library-created dispatch goroutine, terminating the process. There is no confidentiality or integrity impact, exploitation requires network reachability to a TChannel listener exposed to untrusted peers, and no public exploit code was identified at time of analysis (not confirmed actively exploited / not in CISA KEV); the assessed CVSS:3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H.
RemediationAI
Upgrade github.com/temporalio/tchannel-go to v1.22.1 or later; the vendor-released fix is delivered through the upstream commits 0cb017f6870a8420695abeb9a4560d39dadc4e2e, 1dcfa67262ecd56a24f12940f4082549190cb5d1 and 8d8ca17342b3620d3a6d5c1a825145595e7588ff, tracked as pull request https://github.com/temporalio/tchannel-go/pull/14, with the patched tree at https://github.com/temporalio/tchannel-go/tree/v1.22.1. Confirm the dependency is refreshed in go.mod/go.sum and that no vendored or fork-pinned copy of the module remains at an older revision, then rebuild and redeploy the affected services. If an immediate upgrade is not possible, the effective compensating control is exposure reduction rather than input filtering: bind the TChannel listener to trusted interfaces only, place it behind network ACLs or a service mesh that enforces peer identity (mTLS), and reject connections from untrusted network positions, since the parser panics before any application-level authorization hook can run. The trade-off is that this does not fix legitimate-but-exposed peers and breaks any cross-trust-domain RPC path that relied on the listener being reachable; also note that generic HTTP/WAF-style request inspection will not reliably interdict TChannel framing, and per-connection panic recovery inside the library is not achievable from the application layer because the crash occurs on a library-owned goroutine.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
TChannel is a multiplexed, framed RPC protocol in which a large call is split into fragments, and the argument stream inside those fragments is further divided into length-prefixed chunks (arg1/arg2) alongside optional checksum metadata. The vulnerability is a state-machine defect in fragmenting_reader.go: recvAndParseNextFragment parses a fragment's header (flags, checksum type, checksum bytes) and then expects to populate a slice of argument chunks, but the code never validates that the chunk slice is non-empty before indexing its first element. A fragment that advertises checksum metadata and then terminates with zero length-prefixed chunks therefore leaves remainingChunks empty, and the subsequent [0] access raises a Go runtime panic (index out of range) on a goroutine created by the library's dispatcher rather than the caller's, so there is no recover point and the whole process exits. The root cause class is CWE-129 (Improper Validation of Array Index): an unvalidated index derived from attacker-controlled wire data. Because the malformed fragment can be delivered as a direct initial call request after the initialization handshake, no application-level handler, argument decoding, or authentication gate is reached before the panic; the flaw lives purely in the framing/parsing layer of the library, meaning every service embedding tchannel-go (including service-mesh and internal RPC transports) inherits the crash-on-input behavior.
Know when Go 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Unauthenticated network peer sends one malformed fragment (AV:N/AC:L/PR:N/UI:N) causing a process-terminating panic with no confidentiality/integrity effect, so C:N/I:N/A:H, scope unchanged.
Primary rating from Vendor (Temporal).
CVSS VectorVendor: Temporal
DescriptionCVE.org
github.com/temporalio/tchannel-go did not reject TChannel call fragments containing checksum metadata but no length-prefixed argument chunks. The fragment reader left its chunk slice empty and then unconditionally selected the first element. A network peer can supply such a malformed call fragment, including as a direct initial call request after completing the standard initialization handshake. On that inbound path, the resulting unrecovered Go slice-bounds panic occurs on a library-created dispatch goroutine and terminates the hosting process. This allows remote denial of service against applications that expose the listener to untrusted peers. The impact is limited to availability; no confidentiality or integrity impact was identified.
Executive ViewAI
A high-severity flaw in the tchannel-go RPC library used across Temporal-based services allows any unauthenticated network peer that can reach a TChannel listener to crash the hosting process, causing full service outages rather than data exposure or tampering. Because the crash is triggered during routine protocol handling and requires no credentials, any internet- or partner-facing service built on this library is at risk of repeated, low-effort availability disruption. Leadership should treat this as a resilience and uptime issue affecting service availability for customers and internal dependents of the affected components.
Apply vendor patch. Until the upgrade to v1.22.1 is complete, restrict network reachability to TChannel listeners to trusted peers only and rely on process supervision and restart automation 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.
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
The net/http package in Go through 1.6 does not attempt to address RFC 3875 section 4.1.18 namespace conflicts and there
Critical certificate validation bypass in Go crypto/tls during session resumption. If ClientCAs or RootCAs fields are mu
net/url in Go before 1.11.13 and 1.12.x before 1.12.8 mishandles malformed hosts in URLs, leading to an authorization by
Casdoor through 4.4.0 exposes its instance-wide built-in JWT signing private key unmasked through the /api/get-certs and
Host header injection in Nezha 2.2.3's OAuth2 redirect endpoint (/api/v1/oauth2/{provider}) allows an unauthenticated re
Session cross-wiring in SUSE NeuVector before 5.6.1 allows an unauthenticated remote attacker to obtain another user's a
Unauthenticated path traversal in Uber Kraken through 0.1.29 allows remote attackers to read files outside the configure
The "go get" implementation in Go 1.9.4, when the -insecure command-line option is used, does not validate the import pa
Denial of service in Temporal Server allows an authenticated caller holding at least namespace read permission to crash
Account takeover in Klever-Go's KleverUpdateAccountPermission built-in (all versions prior to 1.7.20) allows an attacker
Maliciously crafted on-chain account names processed by Klever-Go prior to 1.7.20 are spliced into Elasticsearch _bulk r
EUVD-2026-83894
GHSA-vg3p-fxfm-m684
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB