Learning paths

RCE learning path

18 resources, ordered. Work down the list β€” each stage assumes the one above it.

Remote Code Execution (RCE)

A route through the library rather than a dump of it. Items are drawn from the full RCE collection, filtered to teaching material (news items are excluded) and ordered within each stage by depth signals β€” whether the piece carries code, how substantial it is, and what readers actually open.

1

Start here

5 resources

Orientation and first principles β€” what the bug class is and how it behaves.

  1. Command injection in Python: examples and prevention
    10 min readsnyk.io2026
    Library for preventing command injection in Python, detailing vulnerabilities arising from insecure use of `os.system`, `subprocess.run` with `shell=True`, dynamic command construction, and `eval()`. It highlights examples like MLflow and PaddlePaddle, and emphasizes mitigation through strict input validation, sanitization, and the use of parameterized queries to protect against unauthorized command execution and system compromise.
  2. Understanding command injection vulnerabilities in Go
    7 min readsnyk.io2026
    Library for mitigating command injection vulnerabilities in Go applications. It details how insecurely handling user input with packages like `os/exec` can lead to attackers executing arbitrary commands, potentially causing data breaches or system compromise. The library emphasizes secure coding practices such as rigorous input validation and sanitation, preferring safe APIs (like `github.com/disintegration/imaging` for image manipulation) over direct system command execution, and refactoring vulnerable code to use `exec.Command` with separate arguments instead of constructing shell strings.
  3. OWASP Global AppSec USA 2026: Assume Code Execution (slides and tools)
    3 min readblog.raphael.karger.is2026
    Slides and tools from OWASP Global AppSec USA 2026 present "Assume Code Execution," detailing how untrusted code ingestion in security scanners can lead to compromise. The research highlights five vendor vulnerabilities, four involving repository-controlled code execution and one file read, and introduces the MIT-licensed "Build Canaries" tool for generating repository artifacts that test implicit build hooks and executable configurations. A deliberately vulnerable scanner, "DVASP," is also provided for safe testing of these ingestion vulnerabilities.
  4. MXC - a sandboxed code execution system
    3 min readgithub.com2026
    Library for sandboxed code execution on Windows, Linux, and macOS. MXC supports multiple containment backends like ProcessContainer, LXC, and Bubblewrap, governed by detailed filesystem, network, and UI policies. It offers Rust, .NET, and Node SDKs for integrating into applications, along with diagnostics to aid in policy tuning and troubleshooting access-denied failures. The system allows for provisioning, starting, executing, and deprovisioning persistent containers, providing fine-grained control over untrusted workloads.
  5. How I Found a Bug Worth $3,500 β€” In a Feature Nobody Was Watching.
    6 min readinfosecwriteups.com2026
    Writeup detailing the discovery of a storage-exhaustion flaw (CWE-434, CWE-770) and a stored XSS vulnerability (CWE-79) within a B2B SaaS platform's file upload feature. The storage exhaustion occurred due to a spoofed file size field, allowing for resource consumption. The XSS vulnerability leveraged an unsanitized filename that executed within an admin's browser, leading to potential session hijacking and platform compromise. The report emphasizes the importance of scrutinizing metadata, understanding the downstream impact of vulnerabilities, and re-testing "boring" features.
2

Build depth

5 resources

Real testing methodology, tooling, and writeups that show the work.

  1. Enterprise Tech In, Shell Out (Progress Kemp LoadMaster Uninitialized Heap to Pre-Auth RCE CVE-2026-8037) - watchTowr Labs
    13 min readlabs.watchtowr.com2026
    Writeup on CVE-2026-8037, an uninitialized heap to pre-authentication Remote Code Execution vulnerability in Progress Kemp LoadMaster. The vulnerability arises from improper handling of user input within the `escape_quotes` function, which fails to null-terminate an allocated buffer. This can lead to information disclosure or code execution when the uninitialized memory is later processed by the API. The writeup details the vulnerability's mechanism and the specific code changes introduced in the patch.
  2. AutoJack: How a single page can RCE the host running your AI agent
    16 min readmicrosoft.com2026
    Technique AutoJack demonstrates how a single web page can achieve remote code execution on the host running an AI agent, specifically targeting AutoGen Studio. By exploiting three weaknesses in the Model Context Protocol (MCP) WebSocket β€” an origin allowlist easily bypassed by an agent, opt-out authentication middleware, and unvalidated `server_params` from the URLβ€”an attacker can trick the browsing agent into executing arbitrary commands on the host. This crosses the localhost trust boundary, turning the agent into a delivery vehicle for RCE.
  3. Remote Code Execution in Ghost CMS (CVE-2026-29053)
    8 min readhiddeninvestigations.net2026
    Writeup on CVE-2026-29053, a remote code execution vulnerability in Ghost CMS versions 0.7.2 through 6.19.0. The flaw arises from unsafe expression evaluation within the theming system, where specially crafted themes can exploit a dependency chain involving the `jsonpath` and `static-eval` libraries. Exploitation requires an administrator to upload and activate a malicious theme, leading to arbitrary JavaScript execution on the server during page rendering, potentially impacting supply-chain trust and admin-targeted deception.
  4. Ni8mare: Unauthenticated Remote Code Execution in n8n (CVE-2026-21858)
    22 min readcyera.com2026
    Writeup of CVE-2026-21858, an unauthenticated remote code execution vulnerability in n8n discovered due to a Content-Type confusion bug. Attackers can exploit this flaw by crafting a malicious request that manipulates the `req.body.files` object, allowing them to read arbitrary local files and achieve full takeover of n8n instances. This issue impacts over 100,000 servers globally and has a CVSS score of 10.0. Users should upgrade to n8n version 1.121.0 or later for remediation.
  5. SSTI Exploitation with RCE Everywhere | YesWeHack
    7 min readyeswehack.com2026
    Writeup detailing advanced Server-Side Template Injection (SSTI) exploitation techniques for achieving Remote Code Execution (RCE) without quotes or external plugins. It covers payloads for Jinja2, Mako, Twig, Smarty, Blade, Groovy, and FreeMarker, demonstrating how to bypass auto-escaping and exploit built-in functions like `chr`, `popen`, `passthru`, and `execute` across various languages and frameworks.
3

Go deep

8 resources

Novel research, edge cases, and the techniques that push the class forward.

  1. I went looking for a managed-Postgres provider. Instead, I found a vulnerability in a 4-star PostgreSQL extension available everywhere! and turned it into code execution at NeonDB, Supabase, Xata and many other PostgreSQL service companies
    29 min readmehmetince.net2026
    Library for discovering and exploiting vulnerabilities in managed PostgreSQL instances. It details a memory corruption bug in the popular PostGIS extension's `address_standardizer` function, chaining it with a separate memory disclosure to achieve RCE on providers like NeonDB, Supabase, and Xata. The research also encompasses broader systemic risks within the managed PostgreSQL industry, including further extension vulnerabilities and core PostgreSQL RCEs.
  2. Chaining Security Bugs in Discuz! X5.0: from Race Condition to Pre-Auth RCE
    28 min readkarmainsecurity.com2026
    Library for chaining vulnerabilities in Discuz! X5.0, demonstrating a pre-authentication RCE attack. The exploit combines a Cross-Context Token Reuse leading to a Race Condition and Authentication Bypass, a custom OCR model for CAPTCHA bypass, and an administrative Local File Inclusion (LFI) vulnerability to achieve full server control.
  3. MeshCentral: From XSS to RCE
    8 min readtechanarchy.net2026
    Writeup detailing a full RCE exploit chain against MeshCentral, starting with an XSS vulnerability. The analysis demonstrates how a large language model, Claude Opus, was used to discover and develop a Proof of Concept, which was then refined to allow an attacker to impersonate an existing agent by extracting credentials from local files. The article contrasts this with a failed attempt using a local, uncensored LLM, highlighting the practical application of AI in security research and exploit development.
  4. Popping Root on UniFi OS Server: Unauthenticated RCE Chain Detection & Analysis
    18 min readbishopfox.com2026
    Tool for detecting unauthenticated RCE chains on UniFi OS Server, specifically addressing CVE-2026-34908, CVE-2026-34909, and CVE-2026-34910. This vulnerability allows attackers to bypass authentication, perform path traversal, and achieve command injection leading to root privileges. The tool aids defenders in identifying exposed systems and recommends immediate patching, network segmentation, and secret rotation, as exploitation grants access to sensitive data and control over managed devices.
  5. React2Shell: Node.js RCE Against a Production Next.js App
    52 min readhunt.io2026
    Analysis of CVE-2025-55182, "React2Shell," details a Node.js Remote Code Execution vulnerability in Next.js applications utilizing React Server Components. The exploit leverages the Flight protocol's unsafe deserialization to trigger `child_process.spawnSync()`, allowing arbitrary shell commands with server process privileges. The report reconstructs a six-stage attack campaign, including C2 communication across multiple servers and the use of Lachlan Davidson's "02-meow-rce-poc" for RCE confirmation, despite defensive measures like container restrictions limiting further attacker progression.
  6. Complete Defense Against Node.js RCE: Real-World Exploit Analysis
    10 min readseekerslab.com2026
    Analysis of Node.js RCE vulnerabilities, including CVE-2022-24329, details how attackers exploit `child_process.exec` misuse and improper input validation to achieve command injection. The article contrasts vulnerable code patterns, such as direct passing of user input to `exec`, with secure alternatives like `spawn` or `execFile` and emphasizes strict input validation and sanitization to prevent shell meta-character interpretation. It also discusses the need for an integrated security approach, combining SAST/DAST, cloud workload security with SeekersLab's FRIIM CNAPP, and real-time threat detection via Seekurity SIEM/SOAR, augmented by KYRA AI Sandbox for analyzing suspicious code.
  7. Leading the Blind to Light! - A Chain to RCE
    5 min readblog.zsec.uk2017
    Writeup detailing a Remote Code Execution chain on Oracle E-Business Suite. The exploit begins with an authentication bypass, leading to blind XXE and information disclosure. This disclosure helps identify an internal endpoint, which through further fuzzing, reveals an SQL injection vulnerability. By re-enabling `xp_cmdshell` via SQL injection, the attacker achieves command execution with administrator privileges.
  8. Turning a 22-year-old Postgres type-confusion primitive into RCE
    20 min readmehmetince.net2026
    Writeup detailing a 22-year-old PostgreSQL type-confusion primitive that was escalated to RCE (CVE-2026-6460). The analysis explores how a lack of type-checking within the Datum system, combined with output functions that implicitly trust type information, creates a vulnerability. This primitive was discovered while analyzing memory corruption exploits in PostgreSQL extensions like pg_clickhouse, highlighting systemic risks in managed PostgreSQL environments.