donut

Convert .NET assemblies and Win32 executables into position-independent shellcode.

15|1|Updated Feb 12, 2026
One-click install
npx skills add https://github.com/AeonDave/malskill --skill donut
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: donut
Source: https://github.com/AeonDave/malskill/tree/main/offensive-tools/evasion/donut
Command: npx skills add https://github.com/AeonDave/malskill --skill donut

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill automates the conversion of various executable formats into position-independent shellcode, enabling in-memory execution without touching disk.

Core Features & Use Cases

  • Shellcode Generation: Converts .NET assemblies, EXEs, DLLs, and COM objects into injectable shellcode.
  • In-Memory Execution: Facilitates loading and executing code directly in memory, bypassing traditional file-based detection.
  • Use Case: Convert a .NET utility like Rubeus.exe into shellcode for process injection or use it to generate payloads for various injection techniques.

Quick Start

Use the donut skill to convert Rubeus.exe into shellcode and save it to rubeus.bin.

Frequently Asked Questions about donut

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

FAQPage Schema
How do I convert a .NET assembly into injectable shellcode for in-memory execution?

To convert .NET assemblies into injectable shellcode for in-memory execution, you use a payload generation tool that transforms EXE and DLL files into position-independent code. This process bypasses traditional file-based detection by loading and executing code directly in memory.

What executable formats can be transformed into position-independent shellcode?

Position-independent shellcode generation supports converting .NET assemblies, Win32 executables (EXEs), dynamic link libraries (DLLs), and COM objects. This allows various executable formats to be loaded directly into memory for process injection without touching disk.

Can I bypass AMSI when generating shellcode from Win32 executables?

Yes, you can bypass AMSI when generating shellcode from Win32 executables by utilizing specific flags during the payload generation process. This feature helps evade detection mechanisms while converting .NET assemblies or EXEs for in-memory execution.

Is there a way to pass arguments to a .NET assembly converted as shellcode?

Yes, you can pass arguments to a .NET assembly converted as shellcode by utilizing the parameters flag during payload generation. This allows the injected position-independent code to execute with the same runtime arguments as the original executable.

How do I specify the target architecture when converting EXEs to shellcode?

You specify the target architecture when converting EXEs to shellcode by using the architecture flag during payload generation. This ensures the resulting position-independent code matches the memory space of the target process injection environment.

What is the primary use case for generating shellcode from .NET assemblies?

The primary use case for generating shellcode from .NET assemblies is to enable in-memory execution and process injection techniques. Converting tools like Rubeus.exe into shellcode allows security professionals to execute payloads while bypassing traditional disk-based detection.