Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed TChannel listener
-
DeliveryComplete standard init handshake
-
ExploitSend call request with unsupported checksum type
-
ExecutionInvalid index selects no valid checksum handler
-
ImpactUnrecovered Go panic 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 | Requires the application to expose a TChannel listener that untrusted network peers can reach; the attacker must be able to complete the standard TChannel initialization handshake and then send one call request frame with a checksum-type byte outside the four supported values. No authentication and no user interaction are required (PR:N/UI:N/AC:L). The principal limiting factor is deployment topology: TChannel is typically an internal service-to-service RPC transport, so risk is realized only where the listener is reachable by untrusted or multi-tenant peers rather than confined to a trusted internal mesh. Fixed in tchannel-go v1.22.1 (PR #14). |
| Impact | This is a genuine, high-confidence remote denial-of-service issue whose real-world priority hinges almost entirely on exposure. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H) yields 8.7 and is internally consistent with the description: a network-reachable, unauthenticated peer can crash the hosting process, with availability the sole impact (VC:N/VI:N). CWE-129 (improper validation of array index) is accurate - an unsupported one-byte checksum-type value is used to select a checksum handler, and the pre-patch code path returns no valid handler, producing an unrecovered Go panic on the connection read goroutine that terminates the whole process. No EPSS score, no CISA KEV listing, and no public exploit are present in the input, so there is no evidence of active exploitation; the signal set therefore points to 'no public exploit identified at time of analysis' despite the high base score. The score is elevated primarily by the unauthenticated network vector plus VA:H, not by demonstrated exploitation. The critical mitigating factor not captured in the raw score is deployment context: TChannel listeners are typically internal RPC endpoints, so the flaw is only meaningfully exploitable where the listener is reachable by untrusted peers. A fix is confirmed available (PR #14, merged, released in v1.22.1), which lowers residual risk for anyone able to patch. Net: a real availability bug worth prioritizing for internet- or multi-tenant-exposed listeners, but not an emergency for internal-only service meshes. |
| Exploit ScenarioDerived | An attacker who can reach an application's TChannel listener completes the normal initialization handshake and sends a single call request whose one-byte checksum-type field is set to an unsupported value. The parser indexes the invalid type into the four-entry checksum pool with no validation, triggering an unrecovered Go panic on the read goroutine that crashes the entire hosting process. No authentication or user interaction is required (PR:N/UI:N); no public exploit code is referenced in the input, though the trivial trigger and available source/commit make one straightforward to construct. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 21, 2026
Remote denial of service in temporalio/tchannel-go allows any network peer that can reach a TChannel listener to crash the hosting process: after completing the standard TChannel initialization handshake, the peer sends a call frame whose one-byte checksum-type field carries an unsupported value, which the parser uses directly as an index into a four-entry checksum pool and thereby triggers an unrecovered Go panic on the connection's read goroutine. Only availability is affected (the assessed vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H with no confidentiality or integrity impact), and exploitation is unauthenticated with no user interaction, requiring only that a TChannel listener be reachable by untrusted or multi-tenant peers rather than confined to a trusted internal mesh. No public exploit code or confirmed in-the-wild exploitation has been identified at time of analysis; a vendor patch is available and the issue is fixed in v1.22.1 (PR #14), so priority is driven almost entirely by listener exposure.
RemediationAI
Upgrade github.com/temporalio/tchannel-go to v1.22.1 or later - the vendor-released fix (PR #14, commits 0cb017f6870a8420695abeb9a4560d39dadc4e2e and a6904155f628b9e602b7bc88ef489004a786f7f4, tree at https://github.com/temporalio/tchannel-go/tree/v1.22.1) validates the inbound checksum-type byte and completes the pooled-checksum refactor before the value can be used as an index. Track this as a dependency change, not a host patch: update go.mod/go.sum, rebuild and redeploy every binary that vendors the library (Temporal/Cadence services, sidecars, internal RPC daemons), and confirm the rebuilt artifacts report v1.22.1+; note that intermediate forks or vendored copies may need manual patching, since a stale vendor directory will silently keep the vulnerable parser. Until the rebuild is rolled out everywhere, the highest-value compensating control is exposure reduction rather than code changes: bind TChannel listeners to loopback or a trusted interface and enforce network policy / security-group rules so only known service peers can reach the TChannel port, or front the listener with mutual TLS so an unauthenticated peer cannot complete the handshake that precedes the malicious frame - the trade-off is that this blocks legitimate cross-cluster or partner traffic that was previously allowed by IP-based trust and requires certificate distribution and rotation. Where the protocol cannot be restricted, a per-connection recover() wrapper or process supervisor with fast automatic restart limits blast radius, but these only convert a full-process crash into transient connection loss and are strictly interim measures, since a sustaining attacker can drive repeated restarts. No public exploit code or confirmed active exploitation has been identified at time of analysis, so this can be scheduled with the exposure assessment as the deciding factor; aggressively restrict any internet-facing or multi-tenant-reachable TChannel listener first.
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 originally developed for large-scale service-to-service communication (notably Uber and, downstream, Temporal/Cadence style systems) in which each call frame header includes a single-byte checksum-type selector. In the affected code (checksum.go and the frame parsing path in reqres.go) the checksum type was mapped to a concrete Checksum implementation through a four-entry structure covering ChecksumTypeNone, ChecksumTypeCrc32, ChecksumTypeCrc32C, and ChecksumTypeFarmhash, without validating that the inbound byte fell within that range; the value is a genuine attacker-controlled index, making this a classic CWE-129 improper validation of array index. Because Go turns an out-of-range index into a runtime panic and the panic occurs on the connection read goroutine with no recover() in place, the failure propagates and terminates the entire process rather than merely dropping the offending connection - turning a single malformed frame into a whole-service outage. The upstream fix (PR #14, commits 0cb017f6870a8420695abeb9a4560d39dadc4e2e and a6904155f628b9e602b7bc88ef489004a786f7f4, released in v1.22.1) reworks checksum handling to pooled, per-type sync.Pool-backed Checksum objects with explicit Release/Reset semantics and adds bounds checking on the inbound checksum-type field so that unsupported values are rejected before any indexing occurs. The vulnerable locations are documented in the upstream source at reqres.go lines 280-295 and checksum.go lines 29-93 of the pre-fix revision.
Know when Temporalio Tchannel 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 a single malformed frame (AV:N/AC:L/PR:N/UI:N) that crashes the process; availability-only impact (A:H), no confidentiality/integrity effect, no scope change.
Primary rating from Vendor (Temporal).
CVSS VectorVendor: Temporal
DescriptionCVE.org
github.com/temporalio/tchannel-go did not validate the one-byte checksum-type field in inbound TChannel call frames. A network peer that can reach a listener can complete the standard initialization handshake and send a call request with an unsupported checksum type. The parser uses that value as an index into a four-entry checksum pool, causing an unrecovered Go panic on the connection read goroutine and terminating 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 remote denial-of-service vulnerability in the temporalio/tchannel-go library lets any unauthenticated party who can reach a TChannel listener crash the hosting process, creating a credible availability risk for services and APIs built on this RPC framework. Only availability is affected - there is no confidentiality or integrity exposure - but the flaw requires no credentials and no user interaction, so the practical concern is unplanned outages wherever TChannel endpoints are exposed beyond a trusted internal mesh. No public exploit code has been identified at time of analysis, and a vendor patch is available, making this a manageable but time-sensitive remediation item for engineering and platform teams.
Apply vendor patch.
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-83893
GHSA-2mhp-wpjp-pjr8
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB