/

CVE-2026-90932

Severity:

HIGH RISK

(7.2)

Path Traversal (CWE-73) in LaraDashboard Core Upgrade

CVE-2026-90932

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-73

Impact:

Arbitrary File Deletion, Arbitrary File Write, and Potential Remote Code Execution

Severity:

HIGH RISK

(7.2)

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

LaraDashboard contains a path traversal vulnerability in core-upgrade backup handling, where user-controlled backup names are combined with storage paths without sufficient path normalization or containment checks. An authenticated user with the delegated settings.edit permission may delete files outside the intended backup directory or restore an archive from an arbitrary local path, potentially enabling application compromise and remote code execution.

Affected context

The issue occurs in LaraDashboard versions 0.9.2 through 1.2.2 when the core upgrade backup workflow processes attacker-influenced backup_file or filename values. The affected code paths concatenate these values with the backup directory and rely on bounded string validation without canonicalizing the resulting path or confirming that it remains within storage/app/core-backups. Deployments are most exposed when a non-Superadmin account has the delegated settings.edit permission and the application process can access sensitive files or write to executable application locations.

Exploit preconditions

  • Attack surface: Authenticated core-upgrade and backup-management functionality
  • Required access: An account with the delegated settings.edit permission; Superadmin access is not required
  • Trigger point: Backup deletion or archive restoration using a user-controlled backup filename
  • Why exploitation is possible: The supplied path is concatenated with a trusted directory without canonicalization, basename restriction, or a post-resolution containment check
  • Environmental factor: The application process must have filesystem permissions for the targeted file or destination

Why this happens

The underlying bug is improper handling of user-controlled filesystem paths, mapping to CWE-73: External Control of File Name or Path. The application treats a bounded string validation result as sufficient trust, then combines the value with a storage directory without resolving traversal elements and verifying the canonical path boundary. This allows a filename-like input to influence filesystem operations outside the intended backup location, including deletion and archive extraction.

Potential impact

  • An attacker may delete arbitrary files reachable by the application process.
  • An attacker could restore an archive from an unintended local filesystem location.
  • Arbitrary files may be written into application directories.
  • Application integrity, availability, or configuration could be compromised.
  • Remote code execution may occur if attacker-controlled files are placed where the application loads or executes them.
  • Sensitive data could be exposed or destroyed.

General mitigation guidance

Mitigation generally focuses on reducing trust in filename inputs and enforcing

filesystem containment for every backup operation.

Common defensive patterns include:

  • Accepting server-generated backup identifiers rather than client-supplied paths or filenames.
  • Restricting filename inputs to an approved identifier format and rejecting path separators and traversal components.
  • Canonicalizing the candidate path and verifying that it remains beneath the intended backup directory before reading, deleting, or extracting.
  • Applying equivalent containment checks to archive contents and preventing extraction of absolute or escaping paths.
  • Keeping backup storage separate from executable application directories and using least-privilege filesystem permissions.
  • Treating restored archives as untrusted content and applying allowlisted file types and destinations.
  • Limiting the settings.edit permission to users who require backup-management capabilities.
  • Using transactional restore workflows and maintaining protected, independently stored backups.

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis rules that identify filesystem operations built from request parameters or form fields.
  • Code review checks for string concatenation used in file paths without canonicalization and containment validation.
  • Tests covering traversal components, absolute paths, symbolic links, archive entry names, and normalization edge cases.
  • Runtime monitoring for unusual backup deletion, restore activity, or file writes outside approved storage directories.
  • Policy enforcement requiring centralized safe-path helpers for file access and archive extraction.
  • Automated security review tools that flag externally controlled path construction and missing authorization checks.

Sources

SourceLink
github.comgithub.com/laradashboard/laradashboard/security/advisories/GHSA-g48h-h5pc-396j
vulncheck.comvulncheck.com/advisories/laradashboard-0.9.2-through-1.2.2-path-traversal-rce

Frequently asked

questions

Exploitation generally requires authentication with the delegated

settings.edit permission and access to the core-upgrade backup workflow.

Superadmin privileges are not necessarily required.

It can be reached through the application's authenticated interface when that

interface is network-accessible. The resulting filesystem impact is limited

by the permissions of the LaraDashboard process and the deployment's access

controls.

Use server-controlled backup identifiers, reject path-like input, canonicalize

every candidate path, and verify that it remains within a dedicated backup

directory before any file operation. Archive extraction requires equivalent

per-entry containment checks.

Centralize safe filesystem APIs, enforce least-privilege permissions, separate

backups from executable application paths, test traversal and archive edge

cases, and monitor privileged backup operations.

Find out what's already
exploitable in your codebase.