CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-22611

Broken Compass: Redirecting the AWS SDK for .NET (CVE-2026-22611)

Amit Schendel
Amit Schendel
Senior Security Researcher

Feb 23, 2026·7 min read·73 visits

Executive Summary (TL;DR)

The AWS SDK for .NET V4 (< 4.0.3.3) fails to validate 'region' strings properly. Attackers controlling this input can redirect AWS API requests to malicious servers, leaking SigV4 credentials. Fix: Update to version 4.0.3.3.

A deep dive into a logic flaw within the AWS SDK for .NET (V4) where improper validation of the 'region' parameter allows attackers to redirect API calls—and the sensitive credentials they carry—to arbitrary destinations. This analysis explores how a simple string manipulation vulnerability can compromise the integrity of cloud infrastructure communications.

The Hook: When the Map is the Territory

In the world of cloud development, we treat the AWS SDK like gravity—it's just there, it works, and we rarely question how it does its job. We assume that when we ask it to talk to S3, it actually talks to S3. But CVE-2026-22611 reminds us that even the most fundamental plumbing is built on code, and that code is built by humans who occasionally trust strings a little too much.

This vulnerability is a classic case of Server-Side Request Forgery (SSRF), but with a twist. It lives inside the library responsible for preventing us from having to worry about HTTP requests. The specific flaw resides in how the AWSSDK.Core component handles the region parameter. In the cloud, the 'region' is the compass. It tells the SDK where the data lives (e.g., us-east-1 or eu-west-1).

What happens when you hand a broken compass to a blind navigator? They walk right off a cliff. In this scenario, the 'cliff' is a server controlled by an attacker, and the 'navigator' is your application carrying a backpack full of sensitive authentication headers. While the CVSS score is a deceptive 3.7 (Low), the implications for an environment where configuration is mutable are anything but.

The Flaw: String Concatenation Doom

At its heart, this vulnerability is a failure of input validation, specifically CWE-20. The AWS SDK needs to construct endpoints dynamically. If you want to put an object into an S3 bucket in Virginia, the SDK constructs a URL that looks something like https://s3.us-east-1.amazonaws.com.

To do this, the SDK developers implemented a logic that essentially boils down to string interpolation: https://{service}.{region}.amazonaws.com. This is efficient and readable. It is also dangerous if {region} is not strictly defined as an alphanumeric string from a trusted enum.

In versions 4.0.0 through 4.0.3.2, the SDK treated the region input promiscuously. It didn't verify that us-east-1 was actually a valid AWS region. It just took whatever string was provided and shoved it into the URL template. This means the trust boundary was misplaced; the code assumed that the configuration source (environment variables, config files, or user input) was benevolent. In security, we know that assumptions are just vulnerabilities waiting to happen.

The Code: Anatomy of a Redirection

Let's look at the logic. While we don't have the exact proprietary source code of the vulnerable commit in front of us, the behavior is well-documented. A simplified C# representation of the vulnerable logic looks like this:

// Vulnerable Logic Representation
public Uri GetEndpointForService(string serviceName, string region)
{
    // No validation that 'region' is a valid AWS region identifier
    string hostname = $"{serviceName}.{region}.amazonaws.com";
    return new Uri($"https://{hostname}");
}
 
// Usage
var config = new AmazonS3Config { RegionEndpoint = RegionEndpoint.GetBySystemName(userInput) };
var client = new AmazonS3Client(credentials, config);

The method RegionEndpoint.GetBySystemName(string) is designed to look up a region. If it doesn't find a predefined one, it creates a new endpoint object using the string provided. This 'feature' is likely intended for forward compatibility—allowing the SDK to support new AWS regions without needing a library update.

However, the lack of sanitization allows for injection. If userInput is us-east-1.attacker-site.com/, the resulting hostname logic might produce a URL that the Uri class resolves unexpectedly, or simply appends the suffix in a way that creates a valid DNS entry pointing to the attacker.

The Fix: In version 4.0.3.3, AWS introduced defense-in-depth measures. The patch likely involves checking the input against a regex (e.g., ^[a-z0-9-]+$) or a strict allowlist of known regions, ensuring that no special characters or domain delimiters can be injected.

The Exploit: Hijacking the Signal

How do we weaponize this? We need to control the region input. This isn't a remote code execution exploit where we send a packet and get a shell; it requires Initial Access or a configuration injection vector.

Scenario: Imagine a .NET microservice that processes images. It reads the target AWS region from an environment variable AWS_REGION or a JSON config file provided by a deployment pipeline. An attacker who has compromised the CI/CD pipeline, or who can influence the environment variables (e.g., via a separate Container Injection flaw), can change the region to:

us-east-1.malicious.com

When the application initializes the S3 client and attempts to PutObject:

  1. The SDK constructs the endpoint. Depending on how the suffix is handled, it might generate s3.us-east-1.malicious.com.amazonaws.com (if the suffix is hardcoded) or, if the injection allows breaking the format, just malicious.com.
  2. The .NET application performs a DNS lookup for the attacker-controlled domain.
  3. The application sends a signed HTTP request to the attacker's server.

> [!CAUTION] > The Payload: The request includes the Authorization header containing the AWS Signature Version 4 (SigV4). This signature is valid for a short window (typically 5-15 minutes).

Replay Attack: The attacker's server captures the request headers. The attacker can now replay this exact request to the real AWS endpoint (modifying the host header if necessary, though SigV4 signs the host, making this tricky but possible depending on how the signature was calculated vs. where it was sent). More dangerously, if the attacker can influence the service name as well, they might be able to trick the SDK into signing a request that allows them to exfiltrate data.

The Impact: Why "Low" Severity is a Lie

The CVSS score of 3.7 suggests you should fix this next year. The reality suggests you should fix it now. The score is suppressed by the Attack Complexity: High metric, which assumes that changing the region configuration is difficult.

However, in modern DevOps environments, configuration injection is a common vector. If an attacker can modify a ConfigMap in Kubernetes or an .env file, they can't necessarily run code, but they can change the region. This vulnerability upgrades that configuration-write primitive into a Credential Leak primitive.

What's at stake?

  1. Credential Leakage: The most direct impact is the leakage of the SigV4 signature. While not a permanent access key, it allows for authorized actions within the signature's validity window.
  2. Denial of Service: Redirecting traffic to a black hole stops the application from functioning.
  3. Data Exfiltration (Blind): If the application is uploading data (e.g., PutObject), it is now uploading that sensitive data directly to the attacker's server. This turns the vulnerability from a simple 'traffic redirection' into a full-blown data breach.

This is a classic 'Pivot' vulnerability—useless on its own, but devastating in a chain.

The Fix: Closing the Window

The remediation is straightforward: stop using the vulnerable SDK versions. The patch provided in 4.0.3.3 validates the region string before it's used to build the endpoint.

Immediate Actions:

  1. Upgrade: Run dotnet add package AWSSDK.Core --version 4.0.3.3 (or higher) for all projects.
  2. Audit: Search your logs for RegionEndpoint initializations that use strings not present in the standard AWS region list.
  3. Restrict: Use network policies (Egress Filtering) to ensure your pods/servers can only talk to *.amazonaws.com. If the SDK tries to talk to malicious.com, the firewall should kill it regardless of what the C# code thinks.

Don't rely on the SDK to be your firewall. Security is an onion; make sure every layer makes the attacker cry.

Official Patches

AWSOfficial GitHub Security Advisory

Technical Appendix

CVSS Score
3.7/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N
EPSS Probability
0.05%
Top 84% most exploited

Affected Systems

AWS SDK for .NET (V4).NET Applications using AWSSDK.CoreSystems with user-configurable AWS region settings

Affected Versions Detail

Product
Affected Versions
Fixed Version
AWSSDK.Core
AWS
>= 4.0.0, < 4.0.3.34.0.3.3
AttributeDetail
CVE IDCVE-2026-22611
CVSS v3.13.7 (Low)
CWECWE-20 (Improper Input Validation)
Attack VectorNetwork (Configuration Dependent)
EPSS Score0.00052 (16.29%)
Exploit StatusPoC / Technical Analysis
ImpactData Exfiltration / Credential Leakage

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1566Phishing (via Config Injection)
Initial Access
T1557Adversary-in-the-Middle
Credential Access
CWE-20
Improper Input Validation

The product receives input or data, but does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Known Exploits & Detection

HypotheticalExploitation requires manipulating the region configuration string to a domain controlled by the attacker.

Vulnerability Timeline

GHSA Advisory Published
2026-01-08
CVE-2026-22611 Assigned
2026-01-10
NVD Analysis Completed
2026-01-13
Technical Analysis Published
2026-01-22

References & Sources

  • [1]GHSA-9cvc-h2w8-phrp: Server-Side Request Forgery in AWS SDK for .NET
  • [2]NVD - CVE-2026-22611

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
6 views•10 min read
•1 day ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
11 views•12 min read
•1 day ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
6 views•12 min read
•1 day ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
13 views•10 min read
•1 day ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
14 views•10 min read
•1 day ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read