Feb 15, 2026·6 min read·79 visits
The go-tuf library attempts to parse untrusted JSON metadata using unsafe Go type assertions. A malicious mirror can send syntactically valid but structurally incorrect JSON (e.g., wrong types for known fields), causing the client to panic and crash immediately. This creates a Denial of Service condition that prevents updates, reachable without authentication or signing keys.
A critical Denial of Service vulnerability exists in the go-tuf library, the Go implementation of The Update Framework (TUF). By serving malformed metadata JSON, a compromised repository mirror or Man-in-the-Middle attacker can trigger a runtime panic in the client. Crucially, this crash occurs during the parsing phase, before cryptographic signatures are verified, allowing an attacker without signing keys to disable the update mechanism across a fleet of devices.
The Update Framework (TUF) is the gold standard for software supply chain security. It’s the architectural equivalent of a paranoid bank vault, designed specifically to operate in hostile environments where repository mirrors might be compromised. The entire premise of TUF is: "We don't trust the mirror to tell the truth; we only trust the cryptographic signatures on the metadata."
But here is the irony: before you can verify a signature, you have to read the message. And if reading the message causes your brain to explode, the signature doesn't matter. That is exactly what happened in go-tuf.
This vulnerability isn't about stealing keys or injecting malware directly; it's about the fragility of code handling untrusted input. By exploiting a quirk in how Go handles interfaces, an attacker can turn a standard update check into a SIGABRT, effectively freezing a fleet of clients in time, unable to ever update again.
To understand this bug, you need to understand Go's type system. Go is statically typed, but it offers the interface{} (or any) type to handle dynamic data like JSON. When you unmarshal an arbitrary JSON blob, you often get a map[string]any.
To use that data, you have to tell Go what it is. "Trust me, compiler, this field is a string." In code, that looks like value.(string).
Here is the catch: If you are wrong—if value is actually an integer, or nil—Go doesn't just return an error. It panics. It flips the table and terminates the process immediately. This is a "Reachable Assertion" (CWE-617).
The developers of go-tuf wrote code that assumed the JSON structure coming from a mirror would always match the TUF specification. They chained these assertions together, walking through the JSON tree without a safety net. If a mirror sends a JSON object where the signed field is a string instead of a map, the application crashes hard.
The vulnerability lived in metadata/metadata.go. The code was trying to determine the type of metadata (e.g., root, targets, snapshot) by inspecting the _type field inside the signed object.
Here is the smoking gun from the vulnerable version:
// The Vulnerable Code
// Assumption 1: "signed" exists and is a map
// Assumption 2: "_type" exists inside that map and is a string
signedType := m["signed"].(map[string]any)["_type"].(string)Do you see the problem? It is a one-liner of doom. If m["signed"] is present but is actually a float, the first .(...) panics. If it is a map but _type is missing or is a boolean, the second .(...) panics.
The fix, introduced in version 2.3.1, replaces this cowboy coding with the "comma-ok" idiom, which is the standard, safe way to do type assertions in Go:
// The Fixed Code
// Check if "signed" is a map
signed, ok := m["signed"].(map[string]any)
if !ok {
return &ErrValue{Msg: "metadata 'signed' field is missing or not an object"}
}
// Check if "_type" is a string
signedType, ok := signed["_type"].(string)
if !ok {
return &ErrValue{Msg: "no _type found in signed"}
}This change transforms a fatal crash into a manageable error that the client can log and ignore, allowing it to perhaps try a different mirror.
Exploiting this does not require a genius-level IQ or supercomputers. It requires a text editor. The attack vector is the repository mirror. In a real-world scenario, an attacker might compromise a CDN node, a mirror server, or perform a Man-in-the-Middle attack on HTTP traffic (since TUF is designed to work over plain HTTP, relying on signatures for security).
Here is the attack flow:
root.json from the mirror.{
"signatures": [],
"signed": "This should be a map, but I made it a string just to watch you cry."
}go-tuf client receives this. It successfully unmarshals the JSON (because it is valid JSON). It then attempts m["signed"].(map[string]any). Since "signed" is a string, the runtime panics.Because this check happens before signature verification, the attacker does not need any private keys. They just need to be in the network path.
At first glance, a crash sounds annoying but not catastrophic. In the context of an update framework, however, Availability is a security property.
If an attacker can crash the update client at will, they can enforce a "version freeze." Imagine a fleet of IoT devices with a known critical vulnerability (say, a remote root exploit). The vendor releases a patch. The devices wake up to download the patch.
The attacker, controlling a mirror or a specific network segment, serves the malformed JSON. Every single device crashes the moment it tries to update. The devices remain vulnerable to the root exploit indefinitely.
Furthermore, because the panic crashes the entire Go process, if the TUF client is integrated directly into a larger application (e.g., a microservice or a daemon) rather than running as a separate CLI tool, the entire application goes down. This escalates the issue from "cannot update" to "service outage."
The remediation is straightforward: update the library. The patch was released in version 2.3.1.
To patch your Go project:
go get github.com/theupdateframework/go-tuf@v2.3.1
go mod tidyIf you are a developer using go-tuf, you should also audit your own code for similar patterns. Search your codebase for direct type assertions (.(type)) on data that originates from external sources (user input, files, network requests). Always use the two-value assignment form (val, ok := x.(T)) to handle unexpected types gracefully without crashing the runtime.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
go-tuf theupdateframework | >= 2.0.0, < 2.3.1 | 2.3.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-617 (Reachable Assertion) |
| Attack Vector | Network (Mirror/MitM) |
| CVSS v3.1 | 5.9 (Medium) |
| EPSS Score | 0.02% |
| Impact | Denial of Service (DoS) |
| Exploit Status | Trivial (PoC available in unit tests) |
| Language | Go |
Reachable Assertion
A local elevation of privilege vulnerability exists in the Microsoft .NET Aspire CLI (`Aspire.Cli`) versions 13.5.4 prior to 13.6.5. When executing SDK management commands (`aspire sdk generate`, `aspire sdk dump`, and `aspire sdk export`), the CLI creates temporary project directories inside the shared operating system temporary folder (such as `/tmp` on Unix-like systems) without restricting directory permissions or disabling MSBuild automatic response file resolution. A local, low-privileged attacker on a multi-user system can place a crafted `Directory.Build.rsp` file in the shared temporary directory hierarchy. When a victim user executes an affected Aspire CLI command, MSBuild traverses upward, ingests the attacker-controlled response file, and executes arbitrary commands in the security context of the victim user.
CVE-2026-120792 is a high-severity local information disclosure vulnerability in the Microsoft .NET Aspire CLI (Aspire.Cli) affecting versions 13.5.4 prior to 13.6.5. The flaw stems from the insertion of sensitive information into a shared temporary log file (CWE-532) combined with insecure temporary file creation (CWE-377) within the DeprecatedMcpCommandScanner component. During agent configuration scanning, the CLI unconditionally appends internal workspace paths and the first 200 characters of Model Context Protocol (MCP) agent configuration files to a statically named file in the system temporary directory. On multi-user systems, unprivileged local users can read this file to harvest API keys, authentication tokens, and internal service endpoints.
CVE-2026-114159 is a heap-based buffer overflow vulnerability (CWE-122) in Microsoft.DiaSymReader.Native affecting Microsoft Visual Studio and the .NET Runtime on Windows. An integer truncation error during the parsing of oversized document names in Portable PDB symbol files causes an undersized heap allocation, leading to an out-of-bounds memory write and remote code execution.
CVE-2026-114158 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple supported servicing branches of Microsoft .NET (.NET 8.0, 9.0, 10.0, and 11.0) on Windows. The flaw resides in the native symbol reader library, Microsoft.DiaSymReader.Native, and is triggered when parsing Portable Program Database (PDB) metadata containing malformed EmbeddedSource custom debug information records. By supplying a parent Record Identifier (RID) of zero or an out-of-bounds value, an attacker causes an integer underflow during 1-based to 0-based index conversion, leading to a heap-based buffer overflow and arbitrary code execution within the context of the host developer tool or runtime.
CVE-2026-114151 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple supported versions of the Microsoft .NET runtime on Windows. The flaw resides in the native Debug Information Access (DIA) symbol reader component, Microsoft.DiaSymReader.Native. When parsing Program Database (.pdb) files, the component fails to validate the length of serialized numeric records (specifically LF_DECIMAL structures) before unpacking them into a fixed-size stack buffer. An attacker who convinces a user or automated diagnostic process to load a crafted .pdb file can trigger a stack-based buffer overflow, resulting in arbitrary code execution within the context of the host process.
CVE-2026-105544 is a high-severity local elevation of privilege vulnerability in Microsoft .NET and Microsoft.TestPlatform.CLI. Improper access control on local inter-process communication mechanisms and execution brokers allows an authorized local attacker to cross security boundaries and execute arbitrary code in the context of a higher-privileged user running a test execution cycle.