Npm Package - CraftedSignal Threat Feed

npm PraisonAI utility-tools.shell() Allowlist Bypass via Shell Chaining (GHSA-5jv7-2mjm-h6qj)

hello@craftedsignal.io — Thu, 18 Jun 2026 15:03:35 +0000

The npm package praisonai has been identified with a command injection vulnerability (GHSA-5jv7-2mjm-h6qj) affecting versions 1.5.1 through 1.7.1. The utility-tools.shell() helper, located in dist/tools/utility-tools.js, is designed to execute "safe read-only commands" by checking only the first whitespace-delimited token against an allowlist (e.g., ls, cat, echo). However, the function then passes the entire input string to Node.js's child_process.exec(), which executes it via a system shell. This policy/parser differential allows an attacker to prefix a malicious command with an allowed command and shell metacharacters (e.g., echo ok; malicious_command), bypassing the intended allowlist and executing arbitrary commands with the PraisonAI process's privileges. This flaw enables potential file system access, network exfiltration, or denial of service within applications using this vulnerable library.

Attack Chain

Initial Access: An attacker identifies an application or service that integrates the praisonai library (versions 1.5.1-1.7.1) and exposes functionality that processes user-controlled input through the vulnerable utility-tools.shell() helper.
Command Crafting: The attacker crafts a malicious command string. This string starts with a command found in utility-tools.shell()'s safeCommands allowlist (e.g., echo, ls) followed by a shell metacharacter (e.g., ;, &&, |) and the desired arbitrary command (e.g., cat /etc/passwd, curl evil.com).
Vulnerable Function Call: The crafted malicious command string is submitted as input to the vulnerable application. The application, in turn, passes this string to the praisonai's utility-tools.shell() function.
Allowlist Check Bypass: The utility-tools.shell() function performs its safety check by splitting the input string by whitespace and validating only the first token (e.g., echo) against its internal safeCommands allowlist. Since the first token is allowed, the check passes.
Shell Execution: The function proceeds to pass the entire, unaltered malicious command string (e.g., echo; cat /etc/passwd) to Node.js's child_process.exec().
Arbitrary Command Execution: child_process.exec() invokes the system's default shell (e.g., sh -c on Linux, cmd.exe /c on Windows), which interprets the full string. The shell executes the initial allowed command, then, upon encountering the shell metacharacter, proceeds to execute the appended arbitrary command (e.g., cat /etc/passwd).
Impact: The arbitrary command is executed with the privileges of the PraisonAI application process, potentially leading to sensitive data exposure, file modification, network communication, or system disruption, depending on the command and process context.

Impact

If an application or service exposes the vulnerable utility-tools.shell() helper to untrusted input, the safe-command allowlist becomes ineffective. Attackers can execute arbitrary shell commands with the PraisonAI process privileges. The specific consequences are determined by the embedding application's context and permissions, but can include unauthorized reading of sensitive files and secrets (e.g., credentials, configuration files), modification of files or application state, invocation of local tools, network exfiltration of data if egress is permitted, and denial of service through resource-intensive commands. While no specific victim numbers are available, the broad applicability of Node.js applications means any sector using praisonai between versions 1.5.1 and 1.7.1 could be affected.

Recommendation

Patch Vulnerable Library: Immediately update praisonai to a version higher than 1.7.1 (or explicitly prior to 1.5.1) to address GHSA-5jv7-2mjm-h6qj. The advisory suggests avoiding exec(command) for policy-checked strings and instead using execFile() or spawn() with shell: false.
Deploy Detection Rules: Implement the provided Sigma rules to detect patterns indicative of this exploitation on both Linux/macOS and Windows hosts that run Node.js applications.
Review Code for Vulnerable Usage: Developers should review their codebase for any instances where praisonai/dist/tools/utility-tools.js is imported and its shell() function is called with user-controlled input. Refactor such calls to ensure input is properly sanitized or leverage safer alternatives as described in the "Suggested Fix" section of the advisory (GHSA-5jv7-2mjm-h6qj).
Enable Detailed Process Logging: Ensure process_creation logging (e.g., via Sysmon on Windows, Auditd/eBPF on Linux) is enabled and configured to capture full command lines, parent-child process relationships, and image paths to effectively utilize the provided Sigma rules.

tmp NPM Package Path Traversal Vulnerability (CVE-2026-44705)

hello@craftedsignal.io — Wed, 27 May 2026 00:36:17 +0000

The tmp npm package is vulnerable to path traversal due to insufficient input sanitization in its file and directory creation functions. By manipulating the prefix, postfix, or dir options, an attacker can write files to arbitrary locations on the file system. This is achieved by including traversal sequences (e.g., ../) or absolute paths in these options, bypassing the intended temporary directory. The vulnerability affects applications that pass user-controlled data to tmp's file/directory creation functions without proper validation, allowing an attacker to create or overwrite files with the privileges of the running process. This can lead to web application configuration poisoning, cache poisoning, or other security bypasses. The affected versions are all versions prior to the fix. This was reported by Mapta / BugBunny_ai.

Attack Chain

An attacker crafts malicious input containing path traversal sequences (e.g., ../) within the prefix, postfix, or dir options of the tmp package's functions.
The application, without proper sanitization, passes this attacker-controlled input to the tmp.file() or tmp.dir() functions.
The tmp package constructs a file path by concatenating the tmpdir, dir, prefix, and postfix options.
The path.join() function normalizes the path, resolving the traversal sequences and potentially allowing the final path to escape the intended temporary directory.
The tmp package attempts to create a file or directory at the constructed path using fs.writeFileSync() or similar functions.
Due to the path traversal, the file or directory is created outside the intended temporary directory, potentially in a sensitive location.
Depending on the attacker's chosen location, they can achieve effects such as web application configuration poisoning or cache poisoning.
The attacker gains unauthorized access or control over the application or system.

Impact

Successful exploitation allows attackers to create files outside the intended temporary directories, leading to arbitrary file creation with the privileges of the running process. This can result in various attack scenarios, including web application configuration poisoning, cache poisoning, build pipeline compromise, container escape attempts, and multi-tenant service bypass. For instance, an attacker could overwrite application configuration files, inject malicious code into cached content, or gain access to sensitive data. The vulnerability has a CVSS v3.1 score of 8.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L).

Recommendation

Implement input validation and sanitization for the prefix, postfix, and dir options before passing them to the tmp.file() or tmp.dir() functions, as described in the Remediation section of this brief.
Monitor for file creation events outside expected temporary directories using file system monitoring tools, as demonstrated in the Detection and Monitoring section of this brief.
Deploy the Sigma rule "Detect Suspicious tmp NPM Package Path Traversal via Prefix/Postfix" to identify exploitation attempts by detecting path traversal sequences in process command lines.
Apply the safe TmpFile workaround described in the Remediation section to strip out unsafe characters.