Description

Whisper-node through 1.1.1 contains an OS command injection vulnerability that allows attackers to execute commands by supplying crafted filePath or whisperOptions.language values to whisper(). Attackers can inject shell metacharacters or $() substitution into the command string built by createCppCommand() and run via shelljs exec() to execute commands with Node.js process privileges.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "9.8",
  "pubDate": "2026-10-14T15:17:17.277Z",
  "pubdate": "2026-10-14T15:17:17.277Z",
  "executiveSummary": "Whisper-node through version 1.1.1 is susceptible to an OS command injection vulnerability. This flaw arises from the insecure handling of user-supplied input when constructing system commands. The vulnerability allows an unauthenticated attacker to execute arbitrary commands on the host operating system with the privileges of the Node.js process. The root cause is the improper sanitization of input parameters within the library's command generation logic, specifically when passed to the underlying shell execution mechanism. Successful exploitation can lead to full system compromise, unauthorized data access, and persistent code execution, depending on the environment where the Node.js process is executing. Given that the vulnerability resides in the core execution flow of the library, any application utilizing affected versions of whisper-node to process user-provided file paths or language options is at significant risk. There are no authentication requirements for an attacker to reach this execution point if the application exposes these parameters to external input.",
  "technicalDetails": "The vulnerability originates in the createCppCommand() function within the whisper-node library, which is responsible for assembling the command string required to invoke the underlying C++ Whisper implementation. The library utilizes shelljs exec() to execute these commands in the host environment. The flaw exists because the filePath and whisperOptions.language variables are concatenated directly into the command string without adequate sanitization or escaping of shell metacharacters.\nWhen an attacker provides a crafted input string containing shell control characters—such as semicolons (;), backticks (`), or command substitution patterns like $()—the shell parsing mechanism interprets these characters as instructions rather than literal data. For example, by providing a filePath argument structured to include a secondary command, the attacker breaks out of the intended argument string and appends arbitrary instructions that the shell subsequently executes.\nThe attack flow begins when an application passes unsanitized user input into the whisper() function. The library proceeds to generate the system command string using the attacker-controlled input. This string is then passed to shelljs exec(), which executes the command via the host system's shell (e.g., /bin/sh or cmd.exe). Because shelljs executes strings directly within the shell context, the shell resolves all substituted expressions and control operators before the intended binary is invoked.\nThis vulnerability is classified as OS Command Injection because it allows the manipulation of the command context to achieve remote code execution (RCE). The impact is limited only by the permissions of the user account running the Node.js application. If the application runs with elevated privileges, the attacker gains equivalent control over the host system. Post-exploitation activities may include spawning reverse shells, exfiltrating sensitive environment variables, accessing local file systems, or pivoting deeper into the internal network. The lack of parameterized command execution or the usage of safe child process spawning methods (such as those provided by Node.js child_process.execFile, which separates arguments from the executable) is the primary technical failure point that facilitates this exploit."
}