arbitrary-write-to-rce

Converts arbitrary write primitives into code execution via GOT, hooks, and TLS_dtor_list.

Updated Jun 11, 2026
One-click install
npx skills add https://github.com/utsavthakur/agenticskills --skill arbitrary-write-to-rce-utsavthakur
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: arbitrary-write-to-rce
Source: https://github.com/utsavthakur/agenticskills/tree/main/arbitrary-write-to-rce
Command: npx skills add https://github.com/utsavthakur/agenticskills --skill arbitrary-write-to-rce-utsavthakur

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides expert techniques to convert arbitrary write primitives into code execution, targeting various overwriteable locations like GOT, hooks, and TLS_dtor_list.

Core Features & Use Cases

  • Target Selection: Offers a comprehensive guide to selecting the right target based on glibc version and available hooks.
  • GOT Overwrite: Explains how to replace function pointers in the Global Offset Table for code execution.
  • Hooks: Demonstrates how to exploit hooks like __malloc_hook and __free_hook for code execution.
  • TLS_dtor_list: Provides a detailed guide on exploiting the TLS_dtor_list for post-glibc 2.34 exploitation.
  • Use Case: This skill is ideal for security researchers and penetration testers who need to understand and exploit arbitrary write vulnerabilities.

Quick Start

Use the arbitrary-write-to-rce skill to identify and exploit arbitrary write vulnerabilities in a target application.

Frequently Asked Questions about arbitrary-write-to-rce

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I convert an arbitrary write vulnerability into code execution?

To convert an arbitrary write to code execution, you overwrite function pointers in exploitable target locations like the GOT, hooks, or TLS_dtor_list. This Skill guides you through selecting the right overwrite target based on the specific glibc version and active protections.

What is the best target for arbitrary write exploitation after glibc 2.34?

For arbitrary write exploitation post-glibc 2.34, the TLS_dtor_list is the recommended target since traditional hooks were removed. This Skill provides detailed techniques for overwriting TLS_dtor_list entries to successfully achieve code execution in modern environments.

How does a GOT overwrite work for binary exploitation?

A GOT overwrite works by replacing function pointers in the Global Offset Table to redirect execution flow. This Skill explains how to leverage arbitrary write primitives to modify GOT entries, hijacking function calls to execute your chosen code.

Do I need reverse engineering knowledge to exploit arbitrary write vulnerabilities?

Yes, you need foundational knowledge of binary exploitation and reverse engineering to use this Skill effectively. It provides expert techniques for targeting overwriteable locations, but assumes the user can already identify and manipulate arbitrary write primitives.

When should I target __malloc_hook versus __free_hook for code execution?

Targeting __malloc_hook or __free_hook depends on the application's memory operations and the glibc version, as these hooks exist only in versions prior to 2.34. This Skill helps you select the appropriate hook based on your specific target environment and available execution triggers.