9.3

CVSS Score

4.0

-

CVSS Score

Basic Information

Concerned about an active attack path?

Talk to our security experts and see Miggo in action.

Miggo Vulnerability Database

→

CVE-2026-41197

CVE-2026-41197: Brillig: Heap corruption in foreign call results with nested tuple arrays

Noir is a Domain Specific Language for SNARK proving systems that is designed to use any ACIR compatible proving system, and Brillig is the bytecode ACIR uses for non-determinism. Noir programs can invoke external functions through foreign calls. When compiling to Brillig bytecode, the SSA instructions are processed block-by-block in BrilligBlock::compile_block(). When the compiler encounters an Instruction::Call with a Value::ForeignFunction target, it invokes codegen_call() in brillig_call/code_gen_call.rs, which dispatches to convert_ssa_foreign_call(). Before emitting the foreign call opcode, the compiler must pre-allocate memory for any array results the call will return. This happens through allocate_external_call_results(), which iterates over the result types. For Type::Array results, it delegates to allocate_foreign_call_result_array() to recursively allocate memory on the heap for nested arrays. The BrilligArray struct is the internal representation of a Noir array in Brillig IR. Its size field represents the semi-flattened size, the total number of memory slots the array occupies, accounting for the fact that composite types like tuples consume multiple slots per element. This size is computed by compute_array_length() in brillig_block_variables.rs. For the outer array, allocate_external_call_results() correctly uses define_variable(), which internally calls allocate_value_with_type(). This function applies the formula above, producing the correct semi-flattened size. However, for nested arrays, allocate_foreign_call_result_array() contains a bug. The pattern Type::Array(_, nested_size) discards the inner types with _ and uses only nested_size, the semantic length of the nested array (the number of logical elements), not the semi-flattened size. For simple element types this works correctly, but for composite element types it under-allocates. Foreign calls returning nested arrays of tuples or other composite types corrupt the Brillig VM heap. Version 1.0.0-beta.19 fixes this issue.

(GitHub Advisory)

Miggo Vulnerability Database

→

CVE-2026-41197

CVE-2026-41197:

9.3

CVSS Score

4.0

-

CVSS Score

Basic Information

Is this CVE running in your environment?

Easily map the attack path and prioritize which CVEs are a threat to your organization

Validate Exposure

Technical Details

Package Name	Ecosystem	Vulnerable Versions	First Patched Version
brillig	rust	<= 1.0.0-beta.18	1.0.0-beta.19

Technical Details

Vulnerability Intelligence
Miggo AI

Root Cause Analysis

The security vulnerability is a heap corruption within the Brillig VM, caused by an incorrect buffer size calculation during the compilation of Noir programs. Specifically, the issue arises when a foreign call returns a nested array containing composite types like tuples.

The analysis of the provided patch pinpoints the root cause to the allocate_foreign_call_result_array function in compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_call/mod.rs. During compilation, this function is responsible for pre-allocating memory on the heap for the results of a foreign call.

The flaw was that for nested arrays, the function used the array's semantic length (the number of tuples) to determine the required memory size. However, it failed to multiply this by the size of the composite type (the number of fields in the tuple). This resulted in a significantly smaller buffer being allocated than necessary.

During runtime in the Brillig VM, when the foreign call is executed, it attempts to write the entire result to the pre-allocated buffer. Since the buffer is too small, this write operation overflows, corrupting adjacent data on the heap. This could lead to unpredictable behavior, crashes, or potentially be exploited for arbitrary code execution within the VM's context.

The patch rectifies this by correctly calculating the 'semi-flattened' size for nested arrays, ensuring that enough memory is allocated to hold the entire result, thus preventing the heap corruption.

Vulnerable functions

BrilligBlock::allocate_foreign_call_result_array

compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_call/mod.rs

This function recursively allocates memory for arrays returned by foreign calls. The vulnerability occurs when dealing with nested arrays of composite types (e.g., an array of tuples). The function incorrectly used the array's semantic length (number of elements) to allocate memory, failing to account for the fact that each composite element itself occupies multiple memory slots. This led to an under-allocation of the heap buffer. When the Brillig VM later writes the full foreign call result, it overflows this small buffer, corrupting adjacent heap memory.

Vulnerability Intelligence
Miggo AI

Unlock WAF rules for this CVE

Generate vendor-ready rules for the observed attack patterns, plus reasoning and safe deployment guidance

Get WAF rules

WAF Protection Rules

WAF Rule

W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.

Reasoning

*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.