/

CVE-2026-81180

Severity:

HIGH RISK

(8.8)

Code Injection (CWE-20) in SysReptor Professional App

CVE-2026-81180

Deferred

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Application Process Code Execution

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

A high-severity input handling vulnerability in SysReptor Professional allows authenticated users to upload image files that trigger unsafe Ghostscript and temporary-file processing behavior. By combining this with a race involving GnuPG configuration files, an attacker may place Python code in the application directory and execute it after a worker restart.

Affected context

The issue affects SysReptor Professional deployments that process attacker-uploaded image files using image-processing paths capable of invoking Ghostscript. Risk increases when the application shares temporary directories with GnuPG operations and permits conditions in which attacker-controlled files can influence configuration handling. The Community edition is not affected according to the provided description.

Exploit preconditions

  • Attack surface: Authenticated image-file upload and server-side image processing
  • Required access: A valid SysReptor Professional user account with permission to upload images
  • Trigger point: Processing of a specially formatted image followed by vulnerable temporary-file and GnuPG interactions
  • Additional condition: A worker restart is required before injected Python code executes
  • Why exploitation is possible: Insufficiently constrained file processing and temporary-directory handling allow attacker-controlled content to cross into application code and configuration paths

Why this happens

The underlying issue is improper validation and isolation of attacker-controlled image content and temporary files. Image processing can invoke Ghostscript for formats containing PostScript, while a race involving GnuPG configuration files can cause attacker-controlled code to be copied into a trusted application directory. This behavior maps to CWE-20: Improper Input Validation, with related weaknesses involving unsafe file handling, temporary-file races, and insufficient separation between data and executable code.

Potential impact

  • The attacker may execute Python code with the privileges of the SysReptor application process.
  • The attacker could access or modify application-managed data.
  • The attacker may alter generated reports, configurations, or other platform content.
  • The compromise could persist across worker restarts through modified application files.
  • The attacker could use application privileges to access connected services or other internal resources.

General mitigation guidance

Mitigation generally focuses on reducing trust in uploaded files and isolating all temporary processing activity.

Common defensive patterns include:

  • Restricting accepted image formats to formats that do not invoke script-capable interpreters.
  • Disabling or sandboxing Ghostscript and equivalent content interpreters for untrusted uploads.
  • Validating file content using independent format detection rather than relying only on extensions or metadata.
  • Using private, securely created temporary directories with strict permissions and predictable lifecycle management.
  • Separating GnuPG configuration and temporary files from application code directories.
  • Preventing runtime processes from writing to application code paths.
  • Running workers with least privilege and limiting access to credentials, files, and connected services.
  • Treating uploaded files as untrusted data throughout their entire processing lifecycle.

How teams detect issues like this

Organizations can look for:

  • Static analysis findings involving image-processing libraries, Ghostscript invocation, shell execution, or archive and file conversion paths.
  • Code review signals such as user-controlled filenames, shared temporary directories, predictable temporary paths, and writes from temporary locations into application directories.
  • Runtime telemetry showing unexpected Ghostscript or GnuPG child processes spawned by application workers.
  • File-integrity monitoring for new or modified Python files in application code directories.
  • Alerts for worker restarts preceded by unexpected changes to application files.
  • Policy enforcement that blocks script-capable image formats and prevents application processes from writing executable code.

Automated security review tools may help identify unsafe file-processing and temporary-file handling patterns.

Sources

SourceLink
github.comgithub.com/Syslifters/sysreptor/commit/7d800e5c737df0dbc3d4ea2d095c89235790a1cc
github.comgithub.com/Syslifters/sysreptor/commit/7ecf56a6b8e5c05a2d2212bc8aa340f69855cdea
github.comgithub.com/Syslifters/sysreptor/commit/e8bd31cb42a15a10bb5102337b55dde704be397f
github.comgithub.com/Syslifters/sysreptor/commit/f27760961943fb1716cbb68f2a6705e7251b4e5c
github.comgithub.com/Syslifters/sysreptor/commit/f5ad35b9e71d370b5e06ef4680979cb05c24ff3c
github.comgithub.com/Syslifters/sysreptor/releases/tag/2026.61
github.comgithub.com/Syslifters/sysreptor/security/advisories/GHSA-wmf3-gv8j-7qp7

Frequently asked

questions

Exploitation requires authentication to an affected SysReptor Professional deployment and permission to upload image files. The Community edition is not affected based on the supplied information.

It can result in code execution within the SysReptor application process after a worker restart, subject to the process privileges and deployment configuration.

Treat uploaded images as untrusted data, disable or isolate script-capable image processing, secure temporary directories, and prevent application processes from writing to code directories.

Use strict content validation, sandbox external converters, avoid shared temporary locations, apply least privilege, and monitor application directories for unexpected changes.

Find out what's already
exploitable in your codebase.