Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-49009 — POC for CVE-2026-49009, an authenticated path traversal to RCE issue in Mender Server. | Kitploit
Tools/GitHubGitHub/j0xh-sec/cve-2026-49009
Vulnerability AnalysisExploitationWeb Application ExploitationPenetration TestingLearning & EducationRed Teaming
GitHubj0xh-sec/cve-2026-49009

CVE-2026-49009

POC for CVE-2026-49009, an authenticated path traversal to RCE issue in Mender Server.

View Repository
335 months agoNot yet reviewed
Share
    ▄█████ ██  ██ ██████    ████▄  ▄██▄ ████▄ ▄██▀▀▀    ██  ██ ▄█▀▀█▄  ▄██▄   ▄██▄ ▄█▀▀█▄
    ██     ██▄▄██ ██▄▄   ▄▄▄ ▄██▀ ██  ██ ▄██▀ ██▄▄▄ ▄▄▄ ▀█████  ▀▀▀██ ██  ██ ██  ██ ▀▀▀██
    ▀█████  ▀██▀  ██▄▄▄▄    ███▄▄  ▀██▀ ███▄▄ ▀█▄▄█▀        ██  ▄▄██▀  ▀██▀   ▀██▀  ▄▄██▀

            ░█▄█░█▀▀░█▀█░█▀▄░█▀▀░█▀▄░░░█▀▀░█▀▀░█▀▄░█░█░█▀▀░█▀▄░░░█▀▄░█▀▀░█▀▀░
            ░█░█░█▀▀░█░█░█░█░█▀▀░█▀▄░░░▀▀█░█▀▀░█▀▄░▀▄▀░█▀▀░█▀▄░░░█▀▄░█░░░█▀▀░
            ░▀░▀░▀▀▀░▀░▀░▀▀░░▀▀▀░▀░▀░░░▀▀▀░▀▀▀░▀░▀░░▀░░▀▀▀░▀░▀░░░▀░▀░▀▀▀░▀▀▀░

Mender Server Authenticated Path Traversal to Remote Code Execution !

I discovered and responsibly reported a critical vulnerability in Mender Server’s single-file artifact generation workflow. The issue started as an input sanitization and path traversal bug in the user-controlled args.filename field, but I showed that the bug did not stop at arbitrary file write. By targeting a worker-owned executable inside the artifact generation container, I escalated the issue into reliable remote code execution.

In practice, an authenticated attacker with access to artifact generation could overwrite /usr/bin/mender-artifact inside the create-artifact-worker. The workflow then invoked that same binary during normal artifact generation, which caused the attacker-controlled payload to execute.

This turned a traversal / arbitrary overwrite bug into a backend code execution issue in the artifact workflow.

  • This repository is provided for educational and defensive security research only.
  • Do not run this against systems you do not own or do not have explicit permission to test.

Affected Versions

  • Vulnerable: Mender Server v4.1.0, v4.0.1 and below
  • Patched: Mender Server v4.1.1 and v4.0.2

What Was the Vulnerability?

The vulnerable workflow accepted attacker-controlled input in the single-file artifact generation flow and did not sufficiently constrain where the uploaded content would be written.

I found that I could control args.filename and abuse path traversal to write outside the intended destination. Instead of writing a normal artifact input file, I pointed the write target at /usr/bin/mender-artifact inside the worker container. Because the runtime user owned that binary in the vulnerable setup, the write succeeded.

The workflow later called mender-artifact as part of the artifact build process. Since I had already replaced that executable with my own payload, the worker executed attacker-controlled code.

Attacker Prerequisites

An attacker needed:

  • a valid authenticated Mender account
  • access to the single-file artifact generation workflow

Exploit Path

At a high level, the exploit chain worked like this:

  1. I authenticated as a normal tenant user.
  2. Submitted a single-file artifact generation request.
  3. Supplied a malicious value that traversed out of the intended path and targeted /usr/bin/mender-artifact.
  4. Uploaded a payload in place of the expected file content.
  5. The worker wrote my payload to the targeted path.
  6. The workflow later invoked mender-artifact during artifact generation.
  7. The worker executed my payload, giving me command execution inside the backend worker.

This mattered because the vulnerable write target was not just any file. It was a binary that the workflow immediately trusted and executed.

What an Attacker Could Achieve

A successful attacker could execute arbitrary commands inside the shared artifact generation worker.

From there, the impact extended beyond a single request:

  • persistent worker compromise: one successful overwrite could affect later jobs handled by the same worker
  • artifact pipeline abuse: the attacker could tamper with artifact generation behavior
  • secret exposure: the attacker could access sensitive workflow context such as tokens or presigned URLs handled by backend jobs
  • internal service exposure: once inside the worker environment, the attacker gained a foothold inside the backend trust zone
  • cross-tenant risk in shared deployments: if worker infrastructure and workflow messaging were shared across tenants, one tenant’s compromise could affect other tenants’ artifact-generation jobs

In short, this was not just a file write bug. It was a code execution bug in a sensitive backend component that sat in the software delivery path.

HackerOne ultimately assessed the report as Critical and awarded a $3,000 bounty, which aligned with the practical impact demonstrated during validation.

Technical Root Cause

The root cause was a trust boundary failure in the single-file artifact generation path.

The workflow trusted attacker-controlled path input too far into the backend processing chain. It allowed a user-influenced filename to escape its intended location and reach sensitive filesystem targets. The worker environment then amplified that mistake because it exposed executable paths that were writable by the runtime user and later executed by the workflow itself.

That combination created a clean exploit chain:

User-controlled path input → Arbitrary file overwrite → Overwrite trusted executable → Backend RCE

References

  • Vendor advisory: CVE-2026-49009 – Improper input sanitization in Mender Server
  • CVE-2026-49009 at CVE.org
  • Patch commit 484cc2a

Conclusion

CVE-2026-49009 shows how a seemingly narrow input sanitization issue can become a full RCE chain when a trusted workflow writes attacker-controlled data to executable paths.

In the vulnerable versions, an authenticated attacker could turn the single-file artifact generation feature into a path traversal, arbitrary overwrite, and remote code execution chain. The patched versions blocked that path and restored the workflow to its intended behavior.

Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    933
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    551
  • 3

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    354
  • 4

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    351
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    332
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    289

Explore all tools

Browse our collection of tools

View all tools →