/

CVE-2026-81719

Severity:

HIGH RISK

(7.8)

Code Injection (CWE-94) in openssl_encrypt Plugin System

CVE-2026-81719

Analyzed

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Arbitrary Code 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

openssl_encrypt before 1.4.9 could compile and execute untrusted third-party plugins when their signatures were missing or could not be verified. Because execution occurred during import, before the runtime sandbox was installed, an attacker who induced a user to load a malicious plugin could execute arbitrary code with that user's privileges.

Affected context

The vulnerability occurs in openssl_encrypt deployments that load third-party plugins and rely on the default plugin signature policy. Non-built-in plugins could proceed despite an unsigned or unverifiable signature, while the available AST denylist did not reliably prevent unsafe behavior. Plugin compilation and execution occurred at import time, before runtime sandbox controls were active.

Exploit preconditions

  • Attack surface: Third-party plugin loading and compilation
  • Required access: The attacker must be able to provide, publish, or otherwise influence a plugin that a user is induced to load
  • Trigger point: Plugin import and compilation before sandbox installation
  • Why exploitation is possible: The default signature policy allowed unsigned or unverifiable non-built-in plugins to execute, and the remaining denylist controls were incomplete and bypassable

Why this happens

The underlying issue is a code-injection flaw caused by executing insufficiently trusted plugin code during the import lifecycle. A permissive signature policy treated unverifiable plugins as warn-only, while an incomplete AST denylist was used as a security boundary. This maps to CWE-94: Improper Control of Generation of Code, because attacker-influenced plugin content could be compiled and executed before stronger runtime restrictions were applied.

Potential impact

  • An attacker may execute arbitrary code in the host process
  • The attacker could obtain the privileges of the user running openssl_encrypt
  • Sensitive local files, credentials, or environment data could be accessed
  • The compromised process could be used to modify data or affect connected services
  • A developer or build environment could be exposed to supply-chain compromise

General mitigation guidance

Mitigation centers on making plugin authenticity checks mandatory before compilation or execution.

Common defensive patterns include:

  • Enforcing valid signatures for all non-built-in plugins by default
  • Rejecting unsigned, unverifiable, or policy-incompatible plugins rather than continuing with warnings
  • Treating AST denylists as supplemental controls rather than complete security boundaries
  • Performing verification and policy checks before any plugin import, compilation, or initialization
  • Separating plugin execution from the host process where practical, using least privilege and effective isolation
  • Reducing plugin trust and restricting which registries, paths, and sources may provide extensions

How teams detect issues like this

Organizations can identify similar risks through:

  • Static analysis rules for dynamic compilation, import-time execution, and plugin loading
  • Code review checks for permissive signature defaults and warning-only verification failures
  • Tests that confirm unsigned or unverifiable plugins are rejected before compilation
  • Policy enforcement requiring provenance and signature validation for extension artifacts
  • Runtime monitoring for unexpected child processes, file access, or network activity during plugin initialization
  • Automated security review tools that flag incomplete denylist-based controls and execution before sandbox setup

Sources

SourceLink
github.comgithub.com/jahlives/openssl_encrypt/security/advisories/GHSA-587j-4r3v-cm2c
vulncheck.comvulncheck.com/advisories/openssl-encrypt-before-1.4.9-remote-code-execution-via-plugin

Frequently asked

questions

It is not necessarily a network-origin vulnerability. Exploitation depends on whether an attacker can distribute or influence a plugin and induce a user or automated workflow to load it.

The attacker needs a path to provide an untrusted third-party plugin or otherwise influence the plugin source. The victim must then load the plugin in a vulnerable configuration.

Require successful signature and provenance verification before compilation or import, and reject plugins that cannot satisfy the policy. Additional process isolation and least privilege provide defense in depth.

Use secure-by-default plugin policies, verify artifacts before any execution-related processing, avoid treating denylists as complete protection, and test that sandboxing is active before untrusted code can run.

Find out what's already
exploitable in your codebase.