Skip to main content

tchannel-go EUVDEUVD-2026-83893

| CVE-2026-65652 HIGH
Improper Validation of Array Index (CWE-129)
2026-09-21 Temporal GHSA-2mhp-wpjp-pjr8
8.7
CVSS 4.0 · Vendor: Temporal
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach exposed TChannel listener
  2. Delivery
    Complete standard init handshake
  3. Exploit
    Send call request with unsupported checksum type
  4. Execution
    Invalid index selects no valid checksum handler
  5. Impact
    Unrecovered 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

temporalio/tchannel-go 0.0.0-20160105034737-a6904155f628 <1.22.1-0.20260720194454-0cb017f6870a

Affected Packages

euvd temporalio_tchannel_go fix: 1.22.1-0.20260720194454-0cb017f6870a

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

Vendor (Temporal) PRIMARY 8.7 HIGH
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
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Temporal).

CVSS VectorVendor: Temporal

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.5%
Top 57% exploitable
Prevalence
Low
niche legacy Go RPC library, largely internal Temporal-ecosystem component
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy