Regexp2, a regular expression engine for Go, prior to version 2.3.0, contains a vulnerability where patterns with large fixed-count quantifiers applied to zero-width subexpressions can cause excessive memory allocation. This leads to multi-gigabyte memory usage and potential out-of-memory (OOM) termination of the process. The issue arises because the engine pushes two integers onto the backtracking stack for each iteration, and the repetition count can be very large. The MatchTimeout setting does not fully prevent this due to rapid memory allocation. This vulnerability has been fixed in version 2.3.0.
CVE-2026-62297 is a high-severity vulnerability in the ag-psd JavaScript library used for reading and writing Photoshop Document files. Prior to version 31.0.0, the library's readPsd() function allocates memory buffers based on attacker-controlled PSD geometry declarations without sufficient validation, potentially causing multi-gigabyte memory allocations. This can lead to denial of service by exhausting system memory or crashing the process. Version 31.0.0 introduces a composite-image allocation limit to mitigate this issue, though some allocation paths may still require review.
A vulnerability in Pillow's SpiderImagePlugin allows bypassing the decompression bomb check when seeking frames in multi-frame SPIDER stack files. This enables a crafted file under 1KB to trigger a very large memory allocation (multi-gigabyte) during image loading, causing a denial of service via unbounded memory consumption. The issue arises because the decompression bomb check is only performed once during the initial open, but not when seeking frames that re-parse header data and reset image size without validation.
Google Guava versions from 4.0 up to but not including 33.7.2 contain a deserialization vulnerability in CompactHashMap, CompactHashSet, and MapMakerInternalMap. These classes read an attacker-controlled size value from a serialized stream without proper upper bound validation, leading to uncontrolled memory allocation. This can cause the Java Virtual Machine (JVM) to allocate multi-gigabyte arrays and crash with an OutOfMemoryError, even when the serialized data contains only a small number of actual elements.
A vulnerability in the Pillow library's handling of animated PNG (APNG) files causes it to allocate large amounts of memory before performing decompression bomb checks. Specifically, when an APNG's first frame requests OP_BACKGROUND disposal, Pillow's Image.open() allocates and zero-fills memory sized by the image dimensions claimed in the file header before checking if the image is oversized. This can lead to multi-gigabyte memory spikes and potential process termination by the operating system due to out-of-memory conditions.
Memory Allocation with Excessive Size Value, Allocation of Resources Without Limits, and Uncontrolled Recursion in the Java implementation of Apache PLC4X (PLC4J) allow a malicious or impersonated device to exhaust the memory or stack of the client application, causing a denial of service.
In the OPC UA driver these defects are reachable before authentication: the offending data is parsed while the secure channel and session are being established, before the server's identity has been bound to it. Configuring a trusted server therefore does not prevent exploitation by an attacker who can
impersonate it.
The individual defects are:
- Length-prefixed byte strings are allocated at the size claimed on the wire before the length is checked against the data actually received (0.10.0 through 0.13.1).
- Array fields in generated protocol parsers pre-allocate a list with the element count claimed on the wire, allowing a single count field to trigger a multi-gigabyte allocation. This parser is shared by all PLC4J drivers; the OPC UA driver is the verified pre-authentication path (0.10.0 through 0.13.1).
- The OPC UA driver accumulates message chunks without enforcing the negotiated maximum chunk count and message size (0.12.0 through 0.13.1).
- The OPC UA driver pre-allocates collections using element counts received from the server (0.10.0 through 0.13.1).
- Recursive protocol types are parsed without a nesting-depth limit. The same defect in the Go implementation is covered by CVE-2026-102510 https://cveprocess.apache.org/cve5/CVE-2026-102510 .
This issue affects Apache PLC4X: from 0.10.0 before 1.0.0.
Users are recommended to upgrade to version 1.0.0, which fixes the issue.
Vector is a high-performance observability data pipeline. From 0.15.0 until 0.57.0, the logstash source reads a 32-bit compressed-frame length from the network and uses it to size an in-memory buffer without an upper bound. An unauthenticated remote peer that can reach the default 0.0.0.0:5044 listener can send a minimal frame declaring a multi-gigabyte payload, causing an excessive allocation that can abort Vector or invoke the host OOM killer. Because the allocation follows the declared length rather than bytes transmitted, the attacker has low resource cost, and process termination can halt log ingestion for every tenant on a shared pipeline. This issue is fixed in version 0.57.0.
adm-zip is a JavaScript library for creating and extracting ZIP archives in Node.js. Prior to 0.6.1, getData() in zipEntry.js trusts an entry's central-directory uncompressed size and allocates output memory before validating that value against the actual compressed data and decompression result. A small crafted ZIP can declare a multi-gigabyte uncompressed size, causing Buffer.alloc and decompression handling to commit excessive resident memory before CRC validation reports an error. Applications that read entries from untrusted archives can therefore be terminated by the operating system or suffer service-wide memory exhaustion. This issue is fixed in version 0.6.1.
Envoy Gateway is an open source project for managing Envoy Proxy as a standalone or Kubernetes-based application gateway. Prior to 1.7.4 and 1.8.1, getFileFromGZ in internal/wasm/httpfetcher.go calls io.ReadAll on a gzip.Reader without limiting decompressed output when a tenant-controlled EnvoyExtensionPolicy.spec.wasm[].code.http.url points to a reachable compressed Wasm payload. The 256 MiB compressed-input cap does not constrain the expanded size, no operator Wasm URL allowlist exists, and the optional sha256 check occurs only after decompression, so a comparatively small gzip stream can force a multi-gigabyte allocation in the shared controller. The resulting out-of-memory termination restarts the controller, re-reconciles the persistent custom resource, and can create a persistent cross-tenant control-plane outage. This issue is fixed in versions 1.7.4 and 1.8.1.
FFmpeg versions up to 8.1.2 contain an uncontrolled resource consumption vulnerability in the IAMF demuxer. An unauthenticated attacker can trigger excessive memory allocation by crafting the count_label field, causing multi-gigabyte allocations from small input files. This occurs because the mix_presentation_obu() function allocates memory based on attacker-controlled input before validating data, potentially exhausting system memory or causing out-of-memory termination during format probing. The vulnerability is fixed in a commit after version 8.1.2.
Symfony's YAML component prior to versions 5.4.52, 6.4.40, 7.4.12, and 8.0.12 contains a vulnerability where recursive resolution of YAML collection aliases can cause a small untrusted YAML input to expand into a multi-gigabyte structure, leading to memory exhaustion. This issue is addressed in the specified fixed versions.
CVE-2026-9492 is an improper access control vulnerability in the MBStorage DRAM lighting control module of Gigabyte Control Center. Authenticated local attackers can send specific IOCTL commands via the MyPortIO_x64.sys driver, allowing arbitrary physical memory read/write and kernel-level privilege escalation. The vulnerability has a high severity score of 8.5. No patch or official remediation has been confirmed yet.
### Impact
In Phantom <= 1.3.0, when `PHANTOM_OUTPUT_DIR` was unset (the default), the MCP tools accepted arbitrary absolute output paths with no confinement. Anything able to send tool calls (e.g. an AI agent driving the MCP interface) could **write or overwrite arbitrary files** the process user can write — including shell startup files (`~/.zshrc`) or a Reaper `__startup.lua`, which is effectively local code execution on a developer workstation.
Separately, the stem-separation and render paths decoded input audio with no size/duration cap (the analysis path was already guarded). A small, highly compressed FLAC/OGG could expand to multi-gigabyte PCM, causing memory-exhaustion DoS, and widened exposure to decoder bugs including libsndfile CVE-2026-37555.
### Patches
Fixed in **1.3.1**:
- File writes are always confined to `PHANTOM_OUTPUT_DIR` (default `~/.phantom/output`); symlinks resolved and re-verified on the final path.
- Decode/duration/size guards mirrored onto the separation and render paths (plus ffmpeg `-max_alloc`/`-t`/`-fs`).
- Atomic `O_CREAT|O_EXCL` output creation in reference matching and symlink-TOCTOU hardening on confined input reads.
### Workarounds
Set `PHANTOM_OUTPUT_DIR` (and optionally `PHANTOM_AUDIO_DIR`) to dedicated directories before starting the server.
### Credit
Found during an internal security audit.
### Summary
The array multiplication operator (`array * integer`) in Scriban allocates a result whose size is the product of the attacker-controlled integer and the array length, with **no `LoopLimit` / `LimitToString` check and no overflow-safe arithmetic**. A ~40-byte template forces a multi-gigabyte allocation, producing a denial-of-service.
This is the unguarded sibling of operations that *were* hardened against the same class of abuse: `string * integer` (gated by a `LimitToString` pre-check), `array.insert_at` (gated by `StepLoop`/`LoopLimit` — the **GHSA-24c8-4792-22hx** fix shipped in 7.2.0, scored 8.7 High), and the range/iteration paths covered by **GHSA-c875-h985-hvrc** ("Built-in operations bypass LoopLimit", fixed 7.0.0). The same `LoopLimit`-based hardening pattern was applied to those operations but never to `array * integer`.
This can be observed directly in 7.0.0, the release where GHSA-c875 was patched: `(1..5) * 50000000` (and `1..N | array.size`) correctly throws `Exceeding number of iteration limit '1000'`, while `[1,2,3,4,5] * 50000000` allocates ~2 GB with no limit. The `LoopLimit` control is enforced on the iteration path but not on the `array * int` allocation path, side by side, in the same version. The bug has been present since the operator was introduced in **3.0.0**, survives all of the 6.6.0 / 7.0.0 / 7.2.0 DoS-hardening passes, and is still present in 7.2.0 (current) — i.e. it is both a missed sibling of GHSA-24c8 and an incomplete coverage of GHSA-c875's `LoopLimit` hardening.
### Details
The `array * int` operator is handled in `ScriptArray<T>.TryEvaluate`:
```csharp
// src/Scriban/Runtime/ScriptArray.cs:504-508 (Multiply case)
var newArray = new ScriptArray<T>(intModifier * array.Count);
for (int i = 0; i < intModifier; i++)
{
newArray.AddRange(array);
}
```
`intModifier` is the attacker-supplied integer (`context.ToInt(...)`, `ScriptArray.cs:399`). Two problems:
1. **No resource limit.** Neither `new ScriptArray<T>(intModifier * array.Count)` nor the `AddRange` loop consults `LoopLimit`, `LimitToString`, or calls `context.StepLoop(...)`. A grep of the entire `TryEvaluate` method (`ScriptArray.cs:360-560`) finds no `StepLoop` / `LoopLimit` / `Limit` reference. `LoopLimit` (default 1000) is therefore not enforced: a template that requests 250,000,000 elements creates them all without any "iteration limit" error.
2. **Integer overflow in the capacity.** `intModifier * array.Count` is unchecked `int` arithmetic. The overflow-safe `long` cast used by the string sibling is absent here.
The DoS-hardening passes guarded the two sibling operations but not this one:
```csharp
// src/Scriban/Syntax/Expressions/ScriptBinaryExpression.cs:341 (string * int — GUARDED)
if (context.LimitToString > 0 && value > 0 && leftText.Length > 0
&& (long)leftText.Length * value > context.LimitToString) // long arithmetic, pre-check
{
throw new ScriptRuntimeException(spanMultiplier, $"String multiplication exceeds LimitToString `{context.LimitToString}`.");
}
```
```csharp
// src/Scriban/Functions/ArrayFunctions.cs:414 (array.insert_at — GUARDED, GHSA-24c8 fix in 7.2.0)
for (int i = array.Count; i < index; i++)
{
context.StepLoop(span, ref loopStep); // LoopLimit enforced
array.Add(null);
}
```
`array * int` (`ScriptArray.cs:504`) received neither guard.
When the oversized allocation fails as a managed exception, it is wrapped by the binary-expression evaluator:
```csharp
// src/Scriban/Syntax/Expressions/ScriptBinaryExpression.cs:241-243
catch (Exception ex) when (!(ex is ScriptRuntimeException))
{
throw new ScriptRuntimeException(span, ex.Message);
}
```
So a host that wraps `Render()` in `try/catch` sees a `ScriptRuntimeException` carrying the original `OutOfMemoryException` message (or `ArgumentOutOfRangeException` on the integer-overflow path).
### PoC
A single console project reproduces it on the released NuGet package.
`poc.csproj`:
```xml
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<!-- If only the .NET 9 SDK is installed, change to net9.0. Behavior is identical. -->
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Scriban" Version="7.2.0" />
</ItemGroup>
</Project>
```
`Program.cs`:
```csharp
using Scriban;
// ~41-byte template requests 5 * 200,000,000 = 1,000,000,000 elements
string tpl = "{{ x = [1,2,3,4,5] * 200000000; x.size }}";
System.Console.WriteLine("Rendering...");
var sw = System.Diagnostics.Stopwatch.StartNew();
var result = Template.Parse(tpl).Render(); // allocates ~7.7 GB
System.Console.WriteLine($"size={result.Trim()} peakWS="
+ System.Diagnostics.Process.GetCurrentProcess().PeakWorkingSet64 / (1024 * 1024)
+ "MB elapsed=" + sw.ElapsedMilliseconds + "ms");
```
Run:
```sh
dotnet run -c Release
```
Measured peak working set on Scriban 7.2.0 (net8.0, .NET 9 runtime, Linux), varying only the multip
Klever-Go is the Go implementation of the Klever blockchain protocol. Prior to 1.7.17, a remote, unauthenticated denial-of-service vulnerability in Batch.Decompress (data/batch/batch.go) allows any peer that participates in a topic served by MultiDataInterceptor to allocate multi-gigabyte heaps on the receiving node from a sub-50 KiB gossip payload. A single packet is sufficient to OOM-kill a validator with conventional memory provisioning. Fleet-wide application affects chain liveness. This vulnerability is fixed in 1.7.17.
CVE-2026-42371 is a numeric truncation error vulnerability in uriparser versions before 1.0.1. It occurs during text range comparison when an application processes URIs with lengths in the gigabyte range. This flaw can cause a denial of service due to application crashes or instability.
CVE-2026-4416 is a high-severity vulnerability in the Performance Library component of the Gigabyte Control Center. It involves insecure deserialization of untrusted data, allowing authenticated local attackers to send malicious serialized payloads to the EasyTune Engine service. Successful exploitation can lead to privilege escalation on the affected system. There is no information about an available patch or vendor advisory at this time. The vulnerability requires local authentication and does not involve user interaction.
CVE-2025-68971 is a medium-severity denial of service (DoS) vulnerability in Forgejo versions up to 13.0.3. The issue arises from the attachment component, which allows an attacker with limited privileges to upload extremely large multi-gigabyte files associated with issues or releases. This can exhaust system resources, leading to service disruption. Exploitation does not require user interaction but does require some level of privileges. No known exploits are currently reported in the wild. The vulnerability impacts availability but does not affect confidentiality or integrity. Organizations using Forgejo should monitor for updates and implement controls to restrict attachment sizes to mitigate risk. The threat primarily affects organizations relying on Forgejo for source code management and issue tracking, especially those with exposed or shared upload capabilities.
CVE-2026-0870 is a high-severity local privilege escalation vulnerability in GIGABYTE's MacroHub application. The flaw arises because MacroHub launches external applications with excessive privileges, allowing an authenticated local attacker to execute arbitrary code with SYSTEM-level privileges. This vulnerability requires local access and no user interaction, but only low complexity to exploit. Although no known exploits are currently reported in the wild, the impact on confidentiality, integrity, and availability is high due to SYSTEM-level code execution. European organizations using GIGABYTE hardware with MacroHub installed could be at risk, especially in sectors with high reliance on GIGABYTE products. Mitigation involves applying patches once available, restricting local user permissions, and monitoring for suspicious local activity. Countries with significant GIGABYTE market penetration and critical infrastructure sectors, such as Germany, France, and the UK, are most likely affected. Defenders should prioritize vulnerability scanning and restrict local access to trusted users to reduce risk.
Certain ASRock, ASUS, GIGABYTE, and MSI motherboard models are vulnerable to pre-boot memory attacks that can compromise system integrity before the operating system loads. These attacks exploit weaknesses in the early boot process, potentially allowing attackers to access or manipulate sensitive data stored in memory. While no known exploits are currently active in the wild, the vulnerability poses a medium-level risk due to the complexity of exploitation and the critical nature of pre-boot environments. European organizations using affected motherboards in critical infrastructure or enterprise environments could face confidentiality and integrity risks. Mitigation requires firmware updates from vendors and enhanced physical security controls to prevent unauthorized access. Countries with high adoption of these motherboard brands and significant industrial or governmental IT infrastructure are more likely to be impacted. Given the attack complexity and potential impact on system trustworthiness, the threat severity is assessed as medium. Defenders should prioritize monitoring for firmware updates and restrict physical access to systems to reduce risk.