Summary
Super Productivity contains a command-injection flaw in its Electron IPC execution path, where renderer-provided command strings can be passed to the operating system through child_process.exec().
If malicious or compromised renderer code, such as a community plugin, can invoke the exposed bridge, it may execute commands with the privileges of the desktop user. A remembered approval can allow later executions to occur without another confirmation.
Affected context
The issue occurs in desktop deployments that expose the renderer's execution bridge through the Electron preload layer and permit renderer code, including community plugins, to run without the relevant nodeExecution permission. Risk is increased when a command approval is persisted in application settings, allowing later matching commands to execute silently under the desktop account.
Exploit preconditions
- Attack surface: Electron renderer-to-main-process IPC through the
IPC.EXECchannel - Required access: Ability to run or influence renderer code, such as through a malicious or compromised community plugin
- Trigger point: Invocation of the exposed execution bridge with a command string
- Approval condition: Initial execution may require user confirmation; persistence of that approval can permit subsequent silent execution
- Why exploitation is possible: Renderer-controlled input reaches an operating-system command interpreter without an effective permission boundary or sufficiently restrictive command policy
Why this happens
The vulnerability results from treating renderer-supplied text as an executable operating-system command. The Electron preload bridge exposes an execution capability without consistently enforcing the intended permission requirement, and the main-process handler forwards the command to child_process.exec().
This is CWE-78: Improper Neutralization of Special Elements used in an OS Command, because untrusted or insufficiently constrained input is incorporated into a command-execution operation. Persisting broad command approvals further weakens the security boundary by converting a one-time confirmation into a reusable authorization.
Potential impact
- An attacker may execute arbitrary commands with the desktop user's privileges
- Local files, credentials, or application data could be read, changed, or deleted
- Malware or persistence mechanisms could be installed in the user context
- The workstation could be used for lateral movement or additional compromise
- User trust in community plugins and application extensions could be undermined
General mitigation guidance
Mitigation generally focuses on removing unnecessary shell execution from renderer-accessible paths and enforcing explicit capability boundaries.
Common defensive patterns include:
- Replacing generic command execution with narrowly scoped, fixed-function APIs
- Enforcing permission checks in the main process rather than relying only on renderer behavior
- Treating plugins and renderer content as untrusted by default
- Avoiding shell interpretation and passing validated arguments through structured process APIs where execution is unavoidable
- Requiring explicit, per-action consent instead of broadly persistent command approvals
- Restricting executable paths, arguments, and allowable operations through an allowlist
- Running the application with the minimum desktop privileges and limiting access to sensitive resources
- Protecting stored authorization settings from unauthorized modification
How teams detect issues like this
Detection approaches can include:
- Static analysis rules for
child_process.exec(), shell-enabled process APIs, and renderer-to-main IPC paths carrying command strings - Code review checks for preload bridges that expose process, filesystem, or command capabilities without main-process authorization
- Searches for plugin execution through dynamic constructs such as
new Function() - Runtime telemetry for unusual child-process creation by the desktop application
- Policy checks requiring explicit permission declarations for plugin capabilities and disallowing generic command execution in renderer-facing APIs
- Automated security review tools that flag untrusted data flowing into shell execution functions

