/

CVE-2026-76148

Severity:

HIGH RISK

(7.8)

Code Injection (CWE-94) in CorvusSKK Software Product

CVE-2026-76148

Deferred

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Arbitrary Code Execution

Severity:

HIGH RISK

(7.8)

CVSS version:

3.0

Catch this CVE while code is being written

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

Summary

CorvusSKK contains a code injection vulnerability that may allow attacker-controlled input to be interpreted as executable code. Under conditions where untrusted data reaches the vulnerable processing path, an attacker could execute arbitrary code with the privileges of the affected process.

Affected context

The vulnerability may occur when CorvusSKK processes attacker-influenced content through a code path that evaluates, constructs, or executes it without adequately separating data from executable instructions. Exploitability depends on how input reaches the affected component and the privileges available to the CorvusSKK process.

Exploit preconditions

  • Attack surface: An input-processing or integration path exposed to attacker-controlled data
  • Required access: The ability to provide, modify, or cause processing of input accepted by the vulnerable component
  • Trigger point: Handling or evaluation of that input by the affected CorvusSKK code path
  • Why exploitation is possible: Insufficient separation between untrusted data and executable code may cause crafted input to be interpreted as instructions

Why this happens

The underlying issue is a failure to keep data separate from executable logic. When externally influenced input is incorporated into an interpreter, evaluator, command construction path, or equivalent execution mechanism without strict controls, attacker-supplied content may alter program behavior. This maps to CWE-94: Improper Control of Generation of Code, commonly known as code injection.

Potential impact

  • An attacker may execute arbitrary code in the context of the affected process
  • The attacker could access or modify data available to that process
  • Application integrity may be compromised
  • The vulnerability could enable further compromise when excessive privileges or accessible integrations are present

General mitigation guidance

Mitigation generally focuses on eliminating dynamic code evaluation and reducing trust in externally supplied input.

Common defensive patterns include:

  • Treating all external content as data rather than executable instructions
  • Replacing dynamic evaluation or command construction with fixed, parameterized APIs
  • Applying strict allowlist validation and context-appropriate encoding
  • Separating parsing from execution and enforcing well-defined input schemas
  • Running the application with least privilege and limiting access to sensitive resources
  • Restricting unnecessary integrations, interpreters, and operating-system capabilities

How teams detect issues like this

Detection efforts can include:

  • Static analysis for dynamic evaluation, unsafe command construction, and interpreter invocation using externally influenced values
  • Code review checks for string concatenation or template expansion at execution boundaries
  • Data-flow analysis tracing user-controlled input into code-generation or execution APIs
  • Runtime monitoring for unexpected child processes, command execution, or anomalous application behavior
  • Policy enforcement requiring approved parameterized APIs and security review for new execution paths

Automated security review tools may help identify suspicious data-to-code flows, but findings should be validated against the application's actual input and trust boundaries.

Sources

SourceLink
github.comgithub.com/nathancorvussolis/corvusskk/releases/tag/3.3.4
jvn.jpjvn.jp/en/jp/JVN18496672/

Frequently asked

questions

Exploitability depends on whether an attacker can remotely supply input that reaches the vulnerable CorvusSKK processing path. The available description does not establish a specific remote attack surface.

An attacker generally needs the ability to provide, modify, or trigger processing of data accepted by the affected component. The required access may vary by deployment and integration.

Avoid evaluating or generating executable code from untrusted input. Prefer fixed, parameterized APIs with strict allowlist validation and context-appropriate encoding.

Apply data-flow analysis during development, prohibit unnecessary dynamic execution, enforce least privilege, and include code-injection checks in code review and automated security pipelines.

Find out what's already
exploitable in your codebase.