Skip to main content

Hatchet CVE-2026-61681

| EUVDEUVD-2026-83976 MEDIUM
Server-Side Request Forgery (SSRF) (CWE-918)
2026-09-21 GitHub_M GHSA-fjwv-jf2v-j499
4.1
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Authenticate as Hatchet tenant
  2. Delivery
    Craft valid AWS-signed SNS UnsubscribeConfirmation
  3. Exploit
    Replace unsigned UnsubscribeURL with IMDS/internal URL
  4. Execution
    Server http.Get() fetches attacker URL
  5. Impact
    Exfiltrate IAM credentials / internal data

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Credential Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires an authenticated Hatchet tenant able to deliver messages to the SNS UnsubscribeConfirmation ingestor (SNS integration must be in use/reachable). The attacker must construct a valid AWS-signed SNS message but can freely tamper the UnsubscribeURL field because BuildSignature() excludes it from the verified signature, so VerifyPayload() still passes. Meaningful impact further depends on the deployment sitting on a network where a useful internal target exists - most notably an AWS host exposing EC2 IMDS (IMDSv1), reachable internal HTTP APIs, or internal services; IMDSv2, egress-restricted, or on-prem deployments with no sensitive internal endpoints sharply limit the payoff to blind SSRF. Fixed in 0.91.1, which restricts SNS URLs to https on an allowlisted AWS host pattern.

Impact

This is a genuine but bounded (moderate) risk. The CVSS 3.1 vector (AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:N/A:N = 4.1) correctly identifies a network-reachable SSRF with a scope change but limited confidentiality-only impact. There is NO EPSS score, NO CISA KEV listing, and NO public exploit code in the provided intelligence, so exploitation status is 'no public exploit identified at time of analysis' - this is not an urgent, actively-exploited priority. The real risk is highly conditional: the description says exploitation requires an 'authenticated Hatchet tenant', yet the vendor scored PR:H - I dispute this, since a tenant in a multi-tenant orchestrator is typically a normal low-privileged customer (PR:L is more defensible), which would slightly RAISE real-world exploitability above the 4.1 headline. Conversely, the true damage depends entirely on where Hatchet runs: on an EC2/cloud host with a reachable IMDS the payload can harvest IAM credentials (arguably C:H, above the vendor's C:L), whereas on a hardened/on-prem or IMDSv2-only deployment the impact collapses toward blind SSRF with little to exfiltrate. Bottom line: not a widespread-exploitation crisis, but a legitimate cloud-pivot primitive for any authenticated tenant on a cloud-hosted Hatchet instance - patch on normal cadence, prioritize if Hatchet runs in AWS with IMDSv1.

Exploit ScenarioDerived

An authenticated tenant on a cloud-hosted Hatchet instance sends an otherwise valid, correctly AWS-signed SNS message to the SNS ingestor but replaces the UnsubscribeURL field (which BuildSignature() never covers) with 'http://169.254.169.254/latest/meta-data/iam/security-credentials/'. VerifyPayload() passes because the tampered field is outside the signature, and the server's http.Get() fetches the attacker-chosen internal URL, potentially returning EC2 IMDS IAM credentials or hitting other internal-only services. No public exploit code is identified, but the signature-exclusion flaw is described precisely enough in the advisory and commit diff to reproduce trivially.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 21, 2026

Server-side request forgery in Hatchet versions prior to 0.91.1 lets an authenticated tenant of the platform coerce the SNS ingest service into issuing an outbound HTTP request to an arbitrary URL, because the SNS UnsubscribeConfirmation handler calls http.Get() against the payload's UnsubscribeURL even though that field is excluded from the AWS signature verification performed by BuildSignature(). Successful exploitation allows the server to reach internal-only endpoints such as the EC2 Instance Metadata Service, internal HTTP APIs, and other services on the deployment's network, with the practical payoff limited to information disclosure (for example, potentially exposing IAM credentials) rather than code execution or data modification. Exploitation requires the SNS integration to be enabled and reachable and the attacker to already hold a Hatchet tenant account; there is no public exploit identified at time of analysis, and no confirmable tracking in CISA KEV.

RemediationAI

Upgrade Hatchet to version 0.91.1 or later, which contains the upstream fix (commit 2d211bce16e5022afaf95780de82dc30e0bcba98) that validates SNS URLs with validateSNSURL(), requiring the https scheme and an allowlisted AWS SNS host for both SubscribeURL and UnsubscribeURL; per vendor guidance the advisory at https://github.com/hatchet-dev/hatchet/security/advisories/GHSA-fjwv-jf2v-j499 should be reviewed before and after upgrading. If immediate patching is not possible, the most effective compensating control is to disable or firewall off the SNS ingestor integration entirely so untrusted tenants cannot deliver messages to the UnsubscribeConfirmation handler - the trade-off is loss of SNS-driven workflow triggering. Because the core exploit path depends on the ingestor's network position, enforce IMDSv2 (hop limit 1) on all EC2 instances hosting Hatchet components; this neutralizes theft of IAM credentials via IMDSv1 but does not prevent access to other internal HTTP endpoints. Additionally, apply egress filtering so Hatchet processes cannot initiate arbitrary outbound requests to RFC1918 ranges, link-local 169.254.0.0/16, or cloud metadata endpoints, and reduce the set of tenant accounts permitted to interact with SNS integrations; both measures shrink the impact of any residual SSRF, though they add maintenance overhead for legitimate SNS and internal-service traffic and may break integrations that depend on internal callbacks.

Affected VersionsENISA

hatchet < 0.91.1

Affected Packages

go github.com/hatchet-dev/hatchet fix: 0.91.2
go hatchet-dev/hatchet fix: 0.91.1
euvd hatchet fix: 0.91.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 3 packages in go, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Hatchet is a platform for orchestrating background tasks, AI agents, and durable workflows, and its ingress layer at internal/integrations/ingestors/sns/sns.go accepts AWS Simple Notification Service (SNS) HTTP(S) notifications. AWS SNS notifications include a signature-based authenticity mechanism, but the implementation's BuildSignature() routine covers only a subset of the payload fields and deliberately omits UnsubscribeURL. The UnsubscribeConfirmation handler nevertheless passed the attacker-supplied UnsubscribeURL value into Go's http.Get(), so a tenant who could craft a message that remains validly AWS-signed while tampering with the unsigned field could force the Hatchet server to fetch an arbitrary destination. This is a classic server-side request forgery (SSRF), classified as CWE-918: the vulnerable component ceases to act as an SNS message consumer and instead becomes a proxy into the internal network. The scope change (S:C) in the assessed vector reflects that the exploited component (the ingestor) reaches resources outside its own security scope, while the C:L/I:N/A:N trio reflects that a blind or semi-blind fetch yields information exposure only - most significantly IAM credentials when an AWS host exposes IMDSv1 at 169.254.169.254, but also internal HTTP API responses or service metadata. The fix introduces a validateSNSURL() helper that rejects any URL whose scheme is not https or whose host does not match the expected AWS SNS host pattern, and it is applied to both SubscribeURL and UnsubscribeURL before any outbound request.

Know when Hatchet 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 (GitHub_M) PRIMARY 4.1 MEDIUM
AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:N/A:N
vuln.today AI 5.0 MEDIUM

Network-reachable, low-complexity SSRF requiring only a normal tenant account (PR:L, not PR:H); scope changes as the request reaches separate internal systems; confidentiality-only, limited (C:L) as it is primarily read/pivot.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
High
User Interaction
None
Scope
Changed
Confidentiality
Low
Integrity
None
Availability
None

Lifecycle Timeline

1
Patch available
Sep 21, 2026 - 17:02 EUVD

DescriptionCVE.org

Hatchet is a platform for orchestrating background tasks, AI agents, and durable workflows at scale. Prior to 0.91.1, the SNS UnsubscribeConfirmation handler in internal/integrations/ingestors/sns/sns.go calls http.Get() on payload.UnsubscribeURL after VerifyPayload() even though BuildSignature() excludes UnsubscribeURL, allowing an authenticated Hatchet tenant to replace that field in an otherwise valid AWS-signed message with an internal URL. The server-side request can reach EC2 Instance Metadata Service, internal services, and internal HTTP APIs, potentially exposing IAM credentials or network-accessible data and functionality. This issue is fixed in version 0.91.1.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Low
niche open-source background-task/AI-agent orchestrator, limited production footprint
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

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