/

CVE-2026-52797

Severity:

HIGH RISK

(8.5)

Path Traversal (CWE-22) in Gogs Git Diff Handling

CVE-2026-52797

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Write Outside Intended Directory

Severity:

HIGH RISK

(8.5)

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

Gogs contains a path traversal vulnerability in how it passes user-controlled values to the git diff command, enabling writes outside the intended target directory.

An authenticated user who can manipulate the diff output path may cause comparison results to be written to arbitrary filesystem locations, becoming risky wherever repository operations share a host with other sensitive data.

Affected context

This vulnerability occurs in Gogs instances where authenticated users can influence parameters passed to the git diff command and the resulting output path is not strictly validated or constrained. It primarily affects environments where application logic assumes that diff results are always written within a controlled repository directory. The issue is more severe on shared hosts or deployments where the Gogs process has access to sensitive filesystem locations or elevated permissions.

Exploit preconditions

  • Attack surface: Application-level Git operations exposed through the Gogs web interface or API.
  • Required access: Authenticated user account with permission to trigger git diff functionality.
  • Trigger point: Invocation of git diff using user-supplied or indirectly controlled path parameters for the diff output.
  • Why exploitation is possible: The application insufficiently validates and normalizes user-controlled path values, allowing directory traversal sequences or arbitrary paths to bypass target directory restrictions, causing diff results to be written outside the intended repository location.

Why this happens

The root cause lies in improper validation of filesystem paths derived from user input before they are passed to underlying git diff operations. This aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), where the application trusts relative or absolute path components and fails to enforce that output files remain within a designated safe directory. By not canonicalizing and restricting paths to a known base, the code allows crafted values (such as traversal sequences or external paths) to escape the repository boundary and target arbitrary locations on disk.

Potential impact

  • An attacker can write diff output to arbitrary paths accessible to the Gogs process.
  • The attacker may overwrite or corrupt application configuration or log files.
  • The attacker could plant or modify files that affect other services on the same host.
  • On misconfigured systems, the attacker may influence startup scripts or sensitive assets, potentially escalating to code execution.

General mitigation guidance

Effective mitigation focuses on strictly constraining filesystem paths derived from user input and decoupling user choices from raw OS-level file operations. Typical defensive patterns include:

  • Canonicalizing and validating all paths against a fixed base directory, rejecting any path that resolves outside the allowed repository tree.
  • Using high-level APIs that construct output paths from trusted directory roots and server-side filenames rather than accepting full user-specified paths.
  • Avoiding direct concatenation of user input with filesystem paths; instead, select from a whitelist of allowed options or identifiers.
  • Running the Git service with least privilege, ensuring that even if writing outside the intended directory is attempted, access to sensitive system paths is minimized.

How teams detect issues like this

Detection strategies generally focus on identifying unsafe path handling patterns and monitoring for anomalous file writes:

  • Static analysis rules that flag concatenation of user-controlled data into filesystem paths or arguments to git and other system commands.
  • Code review practices that require verification of path normalization, base directory enforcement, and rejection of traversal sequences for any file write operation.
  • Runtime monitoring of application logs and filesystem activity for writes to unexpected directories originating from Gogs processes.
  • CI/CD integration of automated security scanners that look for CWE-22 style issues in path construction and command invocation code.

Sources

SourceLink
github.comgithub.com/gogs/gogs/security/advisories/GHSA-pm6v-2h4w-4rp2

Frequently asked

questions

No. Exploitation requires an authenticated user account with the ability to trigger the git diff functionality, though low-privilege accounts may be sufficient depending on the deployment.

The attacker needs application-level access to perform diff operations and control or influence the path parameter that determines where the diff output is written.

The safest approach is to strictly validate and canonicalize all paths, enforce that they remain within a predefined base directory, and avoid accepting arbitrary filesystem paths from user input for any read or write operation.

Establish a standard path-handling library or utility that enforces base-directory constraints, add coding guidelines to prohibit raw path concatenation with user input, and integrate static analysis and code review checks specifically targeting CWE-22 patterns.

Find out what's already
exploitable in your codebase.