/

CVE-2025-65480

Severity:

HIGH RISK

(8.8)

OS Command Injection in Pacom Unison Client Report Templates

CVE-2025-65480

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution by Authenticated Users

Severity:

HIGH RISK

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

Pacom Unison Client 5.13.1 contains an OS command injection flaw in its report template functionality, where authenticated users can embed malicious scripts.

When specific script conditions are met and the report processing logic executes these scripts, an attacker can achieve remote code execution on the underlying system.

Affected context

This vulnerability arises in environments using Pacom Unison Client 5.13.1 where report templates support embedded scripting or command execution.

The risk is present when:

  • Authenticated users are allowed to create or modify report templates, and
  • The application processes these templates and evaluates script content on the server or client with high privileges.

The issue is particularly concerning in deployments where report templates are shared or executed automatically as part of scheduled or conditional reporting workflows.

Exploit preconditions

  • Attack surface: Report template management and processing functionality in Pacom Unison Client.
  • Required access: Valid authenticated account with permissions to create, edit, or upload report templates.
  • Trigger point: Execution or rendering of a crafted report template when its script conditions are satisfied (e.g., on-demand or scheduled report generation).
  • Why exploitation is possible: The template scripting mechanism passes user-controlled data into command execution paths without sufficient sanitization, escaping, or strict whitelisting, enabling injection of arbitrary OS commands.

Why this happens

The underlying issue maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

The report template feature appears to interpret script content in a way that ultimately influences command execution on the host environment.

Because user-supplied script components are accepted and processed without robust validation, encoding, or strict separation from the execution context, attackers can inject metacharacters or command sequences that the system treats as part of a legitimate command line.

Conceptually, the design couples user-controlled template logic directly with command interpreters or privileged APIs, rather than treating templates as inert data rendered by a constrained engine.

Potential impact

  • Execution of arbitrary OS commands with the privileges of the Pacom Unison Client process.
  • Installation of backdoors or persistence mechanisms on the host system.
  • Access, modification, or destruction of security system data managed by Unison.
  • Use of the compromised host as a pivot point for lateral movement within the network.
  • Disruption of physical security operations if the client participates in monitoring or control workflows.

General mitigation guidance

Effective mitigation centers on decoupling user-controlled template content from command execution and hardening the scripting environment:

  • Replace direct OS command invocation with parameterized API calls that do not invoke a shell or command interpreter.
  • Restrict the template engine to a safe subset of operations, disabling arbitrary script execution where not strictly needed.
  • Apply strict input validation and allowlisting on all template fields that can influence commands, rejecting or neutralizing control characters and metacharacters.
  • Run the Pacom Unison Client and its template processing components under least-privilege accounts with minimized access to the underlying OS and network.
  • Introduce defense-in-depth controls such as process-level sandboxing and OS-level execution restrictions that limit the blast radius of any injected command.

These patterns reduce the risk even if some scripting flexibility must be retained for legitimate reporting use cases.

How teams detect issues like this

Organizations can detect and monitor for this class of vulnerability using:

  • Static analysis: Rules that flag concatenation of template-derived strings into system command execution APIs, shell wrappers, or process launch functions.
  • Code review: Manual inspection of report template processing paths, focusing on any use of shell commands, interpreters, or dynamic script evaluation.
  • Configuration and policy checks: Ensuring that scripting features in templates are explicitly justified and documented, and that any command-executing functionality is tightly controlled.
  • Runtime monitoring: Logging and alerting around unusual command execution patterns originating from the Pacom Unison Client process, including anomalous arguments and destinations.

Automated security testing and SAST tools can assist by highlighting typical OS command injection patterns in the codebase.

Sources

SourceLink
github.comgithub.com/derekyjj/vulnerability-research/tree/main/CVE-2025-65480

Frequently asked

questions

It can be, if an attacker can authenticate remotely to the Pacom Unison Client and reach the report template functionality. The vulnerability itself is not anonymous; it requires a valid user context.

The attacker must have an authenticated account with permission to create or modify report templates. Privileged or shared accounts significantly increase the risk, as a single compromised account could impact all report generation.

Remove any dependence on shell command execution for template processing, use non-shell APIs for required operations, and strictly limit or disable arbitrary scripting within templates. Where scripting is unavoidable, confine it to a sandboxed, non-OS-command-capable environment.

Adopt a design policy that forbids passing user-controlled data into command interpreters, enforce rigorous input validation and allowlisting on all dynamic execution paths, and integrate security-focused code review and static analysis into the development lifecycle for features that process templates or scripts.

Find out what's already
exploitable in your codebase.