CVE-2021-41556: Squirrel-lang RCE Vulnerability

CVE-2021-41556 Overview

CVE-2021-41556 is a critical out-of-bounds read vulnerability in sqclass.cpp within the Squirrel scripting language interpreter. This flaw affects Squirrel versions through 2.2.5 and 3.x through 3.1, allowing attackers to achieve code execution by escaping the Squirrel script sandbox. Even when dangerous functionality such as File System functions has been disabled, an attacker who can execute a malicious Squirrel script can break out of the sandbox and execute arbitrary code on the underlying system.

This vulnerability is particularly concerning for cloud services that allow customization via Squirrel scripts and video games that embed the Squirrel Engine for modding or scripting capabilities. The ability to bypass sandbox restrictions makes this a severe threat to any application relying on Squirrel for safe script execution.

Critical Impact

Attackers can escape the Squirrel VM sandbox and achieve arbitrary code execution on the host system, even when all dangerous scripting functions are disabled.

Affected Products

• Squirrel-lang Squirrel versions through 2.2.5
• Squirrel-lang Squirrel versions 3.x through 3.1
• Fedora 35 and 36 (packages using vulnerable Squirrel versions)

Discovery Timeline

• 2022-07-28 - CVE-2021-41556 published to NVD
• 2024-11-21 - Last updated in NVD database

Technical Details for CVE-2021-41556

Vulnerability Analysis

This vulnerability is classified as CWE-125 (Out-of-Bounds Read), occurring in the core interpreter of the Squirrel virtual machine. The flaw exists in the class member handling code within sqclass.cpp, where insufficient validation of member count allows an attacker to trigger an out-of-bounds memory read condition.

The Squirrel language is designed as an embeddable scripting language, commonly used in game engines and cloud platforms where user-provided scripts need to run in a sandboxed environment. The sandbox is intended to prevent scripts from accessing dangerous system functions. However, this vulnerability allows an attacker to bypass these protections entirely by exploiting the memory corruption primitive to achieve code execution outside the sandbox context.

The attack requires the victim to execute an attacker-controlled Squirrel script, which could be delivered through various vectors including malicious game mods, compromised cloud service configurations, or supply chain attacks targeting applications that embed the Squirrel engine.

Root Cause

The root cause of CVE-2021-41556 is the absence of a bounds check on the number of members that can be added to a Squirrel class. The sqclass.cpp implementation did not validate whether the member count exceeded the maximum allowable value (MEMBER_MAX_COUNT), allowing an integer overflow or out-of-bounds memory access when handling class member operations.

Without this check, an attacker can craft a malicious script that creates classes with an excessive number of members, causing the interpreter to read or write beyond allocated memory boundaries. This memory corruption primitive can then be leveraged to achieve arbitrary code execution.

Attack Vector

The attack vector is network-based, as vulnerable applications may process attacker-supplied Squirrel scripts received over the network. Exploitation scenarios include:

1. Cloud Services: Platforms allowing users to customize behavior via Squirrel scripts can be compromised if they process malicious scripts
2. Video Games: Games using Squirrel for modding or scripting may execute malicious mods that exploit this vulnerability
3. Embedded Applications: Any application embedding the Squirrel interpreter that processes untrusted scripts is at risk

The following patch was applied to fix the vulnerability by adding a maximum member count check:

// Source: https://github.com/albertodemichelis/squirrel/commit/23a0620658714b996d20da3d4dd1a0dcf9b0bd98
// sqclass.h - Define maximum member count constant

#define MEMBER_TYPE_METHOD 0x01000000
#define MEMBER_TYPE_FIELD 0x02000000
+#define MEMBER_MAX_COUNT 0x00FFFFFF

#define _ismethod(o) (_integer(o)&MEMBER_TYPE_METHOD)
#define _isfield(o) (_integer(o)&MEMBER_TYPE_FIELD)

// Source: https://github.com/albertodemichelis/squirrel/commit/23a0620658714b996d20da3d4dd1a0dcf9b0bd98
// sqclass.cpp - Add bounds check before adding new members

         _defaultvalues[_member_idx(temp)].val = val;
         return true;
     }
+	if (_members->CountUsed() >= MEMBER_MAX_COUNT) {
+		return false;
+	}
     if(belongs_to_static_table) {
         SQInteger mmidx;
         if((sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) &&

The patch introduces a MEMBER_MAX_COUNT constant set to 0x00FFFFFF and adds a validation check that returns false if the member count reaches this limit, preventing the out-of-bounds condition.

Detection Methods for CVE-2021-41556

Indicators of Compromise

• Unusual crashes or memory access violations in applications using Squirrel scripting
• Unexpected code execution or process spawning from Squirrel-enabled applications
• Squirrel scripts containing abnormally large class definitions with excessive member counts
• Memory corruption artifacts in application logs or crash dumps

Detection Strategies

• Monitor applications embedding Squirrel interpreters for abnormal memory access patterns
• Implement runtime monitoring for Squirrel script execution that detects class definitions with unusually high member counts
• Deploy endpoint detection solutions capable of identifying sandbox escape attempts
• Analyze Squirrel scripts before execution for suspicious patterns indicative of exploitation attempts

Monitoring Recommendations

• Enable crash reporting and memory analysis for all applications using Squirrel scripting
• Monitor for unexpected child processes spawned by Squirrel-enabled applications
• Implement logging for Squirrel script execution in production environments
• Use SentinelOne's behavioral AI to detect anomalous code execution patterns following Squirrel script processing

How to Mitigate CVE-2021-41556

Immediate Actions Required

• Upgrade Squirrel to version 3.2 or later which includes the security fix
• Audit all applications in your environment that embed the Squirrel scripting engine
• Restrict or disable execution of untrusted Squirrel scripts until patches are applied
• Review and validate any user-submitted Squirrel scripts before allowing execution

Patch Information

The vulnerability has been addressed in commit 23a0620658714b996d20da3d4dd1a0dcf9b0bd98 in the official Squirrel repository. Organizations should update to the latest version of Squirrel that includes this fix.

For Fedora users, updated packages are available through the standard package repositories. Refer to the Fedora package announcements for specific package versions.

Additional resources:

• Official Squirrel Language Download Page
• SonarSource Technical Analysis
• GitHub Security Patch

Workarounds

• Disable Squirrel script execution in production environments until patches can be applied
• Implement strict input validation and sandboxing at the application level around Squirrel script execution
• Use allowlisting to restrict which Squirrel scripts can be executed in your environment
• Consider containerization or additional isolation for applications processing untrusted Squirrel scripts

# Configuration example: Disable Squirrel scripting temporarily (application-specific)
# Check your application's documentation for script execution settings
# Example for applications with configuration files:
SQUIRREL_SCRIPTING_ENABLED=false
ALLOW_UNTRUSTED_SCRIPTS=false