/

CVE-2026-71551

Severity:

HIGH RISK

(7.8)

OS Command Injection (CWE-78) in Super Productivity

CVE-2026-71551

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution

Severity:

HIGH RISK

(7.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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.EXEC channel
  • 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

Sources

SourceLink
github.comgithub.com/super-productivity/super-productivity/commit/97e97042cde2e33524c9ad50dd46312c56be0072
github.comgithub.com/super-productivity/super-productivity/pull/8669
github.comgithub.com/super-productivity/super-productivity/security/advisories/GHSA-256q-p9ff-jv8q

Frequently asked

questions

It is primarily a local application issue, but exploitation may occur when a user installs or runs malicious or compromised plugin code, or when another condition allows untrusted renderer code to execute.

The attacker generally needs a way to influence renderer execution, such as through a community plugin or compromised application content. Direct access to the operating system is not necessarily required beforehand.

Remove generic command execution from renderer-accessible interfaces. Where process execution is necessary, use narrowly scoped main-process functions with strict permission checks, fixed operations, validated arguments, and least privilege.

Treat plugins and renderer content as untrusted, enforce capabilities in the privileged main process, avoid shell interpretation, minimize persistent approvals, and monitor unexpected child-process activity.

Find out what's already
exploitable in your codebase.