/

CVE-2026-50880

Severity:

CRITICAL RISK

(9.8)

Code Injection (CWE-94) in YouTransfer Sendmail

CVE-2026-50880

Deferred

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.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

A code injection vulnerability in the sendmail transport integration of YouTransfer v1.0.6 allows attackers to execute arbitrary code by sending crafted requests to the application.

When untrusted request data is used in dynamic code paths without proper validation or sanitization, an attacker can gain remote execution capabilities on the hosting server.

Affected context

This weakness appears in deployments of YouTransfer v1.0.6 that use the sendmail transport integration for outbound email functionality.

The vulnerability is exposed when user-controlled input from HTTP requests is processed by the sendmail integration and incorporated into code paths or command structures without strict validation, encoding, or separation of data from control instructions.

It is most relevant in environments where the application is reachable over a network and sendmail is configured and enabled.

Exploit preconditions

  • Attack surface: Network-exposed YouTransfer instances that accept HTTP(S) requests using the vulnerable sendmail transport integration.
  • Required access: Ability to send crafted requests to the application (typically unauthenticated or low-privilege access, depending on deployment configuration).
  • Trigger point: Handling of email-related operations in the sendmail integration, where data from the request is processed and passed through dynamic code or command execution logic.
  • Why exploitation is possible: Untrusted input is used to build or influence executable code or commands without adequate sanitization or strict separation between data and control, enabling attackers to inject and execute arbitrary code.

Why this happens

The root cause aligns with CWE-94: Improper Control of Generation of Code ('Code Injection').

The sendmail transport integration appears to incorporate data from incoming requests into dynamic code generation or execution mechanisms, such as templating, command assembly, or interpreter calls, without robust validation and confinement.

By failing to treat user input as untrusted and by not enforcing clear boundaries between data and executable instructions, the component permits adversaries to introduce additional code fragments or control tokens that the runtime subsequently interprets and executes.

This pattern manifests whenever application logic builds commands, scripts, or expressions from unvalidated inputs, instead of using parameterized or fixed structures with minimal, validated substitutions.

Potential impact

  • Remote execution of arbitrary code under the privileges of the YouTransfer process.
  • Full compromise of the affected server, including data exfiltration or modification.
  • Deployment of malware, web shells, or backdoors for persistent access.
  • Lateral movement within the hosting environment or broader infrastructure.
  • Disruption of service availability through destructive commands or resource exhaustion.

General mitigation guidance

Mitigation typically focuses on eliminating dynamic code paths that depend on untrusted input and enforcing strict boundaries between data and executable logic.

Defensive patterns include:

  • Refactoring email transport logic to avoid constructing commands or code from request data; favor parameterized APIs or well-defined configuration structures instead.
  • Applying strict input validation and canonicalization on all values that influence sendmail behavior, limiting them to whitelisted characters, formats, and lengths.
  • Ensuring that any templating or expression evaluation used in email content does not expose general-purpose code execution capabilities; restrict to safe substitutions only.
  • Running the application and mail transport with least-privilege accounts and minimal OS capabilities to reduce the blast radius if execution occurs.
  • Isolating email-processing components using process isolation or containerization, so that compromise of the sendmail integration does not directly expose broader system resources.

How teams detect issues like this

Detection efforts can focus on both code-level patterns and runtime behavior associated with code injection.

Code-centric approaches:

  • Static analysis rules that flag dynamic command or code construction using user-controlled variables, particularly in the sendmail integration layer.
  • Code review checklists that require reviewers to identify places where request parameters influence executable code, shell calls, or interpreter functions.
  • Automated scanning for calls to dangerous APIs (e.g., generic eval/exec interfaces or shell invocation routines) that use request-derived inputs without strict validation or parameterization.

Operational approaches:

  • Application logging tuned to capture unusual or malformed email-related requests that contain code-like patterns or control characters.
  • Host-based intrusion detection or EDR tools configured to alert on abnormal child processes or command lines spawned by the YouTransfer process.
  • Security policies in CI/CD that prevent merging code introducing new dynamic code execution patterns unless they pass security review.

Sources

SourceLink
gist.github.comgist.github.com/pyuysig/4013f4f10f74b3fded7ddf41b6d36ae5

Frequently asked

questions

Given the described behavior and high CVSS score, the vulnerability is likely highly exploitable wherever the affected sendmail integration is reachable over the network, as attackers can trigger it by sending crafted requests without deep interaction with other components.

Typically, an attacker only needs the ability to reach the YouTransfer instance over HTTP(S) and send crafted requests to the functionality that uses the sendmail transport integration; no elevated privileges are usually required beyond that initial access.

The safest pattern is to remove or redesign any dynamic code or command generation in the sendmail integration so that untrusted input is never interpreted as code, instead using fixed, parameterized calls with strongly validated and constrained inputs.

To prevent similar issues, teams can adopt secure coding guidelines that prohibit eval-like constructs on user input, enforce rigorous input validation and encoding, mandate code reviews focused on injection risks, and integrate static analysis tools configured to detect dynamic execution patterns before deployment.

Find out what's already
exploitable in your codebase.