CVE-2026-130320 in ooRexx
Summary
by MITRE • 11/17/2026
In Open Object Rexx (ooRexx) before 5.2.0, RXAPI mishandles nameArg and userid bounds checking, possibly leading to arbitrary code execution via crafted messages.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/17/2026
The vulnerability identified in versions of Open Object Rexx prior to release 5.2.0 centers on a critical failure within the RXAPI subsystem regarding input validation for specific parameters. Specifically, the functions responsible for handling nameArg and userid arguments lack robust bounds checking mechanisms. In software development, particularly when dealing with system-level APIs or interpreters like ooRexx, proper boundary verification is essential to prevent buffer overflows and memory corruption issues. The absence of these checks allows an attacker to supply input data that exceeds the expected limits for these fields without triggering appropriate error handling or truncation logic.
This technical flaw creates a pathway for arbitrary code execution under certain conditions. When crafted messages containing oversized or malformed nameArg and userid values are processed by the RXAPI, the application may write this excessive data beyond the allocated memory buffers. Such buffer overflows can overwrite adjacent memory structures, including return addresses or function pointers on the stack. An attacker who can control these overwritten values can redirect the execution flow of the program to inject and execute malicious shellcode. This represents a severe security risk as it effectively grants the attacker the same privileges as the process running ooRexx, potentially leading full compromise of the underlying system depending on the context in which the interpreter is operating.
From an industry standard perspective, this vulnerability aligns with CWE-120 Buffer Copy without Checking Size of Input Classic and CWE-787 Out-of-bounds Write. These classifications highlight the fundamental error in memory management where input data is copied into a fixed-size buffer without verifying that the size of the input fits within the destination buffer's capacity. Furthermore, this exploitation technique maps to MITRE ATT&CK techniques related to Execution via Command and Scripting Interpreter, specifically leveraging local exploits for privilege escalation or remote code execution if the service is exposed over a network interface. The lack of proper validation on user-supplied data such as userid fields is a common precursor to more advanced attack chains involving lateral movement or persistence mechanisms within compromised environments.
The operational impact of this vulnerability extends beyond immediate code execution. If ooRexx is utilized in automated scripting environments, system administration tasks, or embedded systems where it processes untrusted input from external sources, the consequences can be catastrophic. Attackers could use this flaw to bypass security controls installed on the host machine, exfiltrate sensitive data stored by applications running under the same user context, or establish a foothold for further network intrusion. In scenarios where ooRexx runs with elevated privileges, such as root or administrator rights, the impact is amplified significantly, allowing complete control over the affected system.
Mitigation strategies primarily involve upgrading to version 5.2.0 of Open Object Rexx or later, which includes patches addressing these specific bounds checking deficiencies in RXAPI. For organizations unable to upgrade immediately due to compatibility constraints, implementing strict input validation at the application layer is recommended as a compensating control. Developers should ensure that all inputs passed to nameArg and userid parameters are validated for length and content before being processed by the interpreter. Additionally, deploying runtime protection mechanisms such as Data Execution Prevention (DEP) and Address Space Layout Randomization (ASLR) can help mitigate the success rate of exploitation attempts by making it more difficult for attackers to reliably execute injected code or predict memory layouts. Regular security audits focusing on C/C++ based components within scripting engines are also advisable to identify similar vulnerabilities in other parts of the software stack.