Escalação de privilégios: de usuário comum a root

Conseguir um shell em uma máquina é só o começo. Quase sempre esse primeiro acesso vem com permissões limitadas — um usuário comum sem poder fazer grande coisa. A escalação de privilégios é a arte de transformar esse acesso modesto em controle total da máquina, virando root no Linux ou SYSTEM no Windows. Este guia mostra as técnicas mais usadas, como detectá-las, como automatizar a coleta sem virar refém de scripts e como pensar essa fase de forma estruturada — do lado ofensivo e do lado defensivo.

Por que escalar privilégios importa

Depois da exploração inicial de uma vulnerabilidade, você normalmente cai no sistema com os privilégios do serviço comprometido — frequentemente uma conta de baixo poder. Sem escalar, seu acesso é frágil e limitado: você não consegue ler arquivos sensíveis, instalar ferramentas de persistência ou se mover lateralmente com liberdade.

A escalação de privilégios resolve isso ao explorar:

No framework MITRE ATT&CK, essa atividade é uma tática própria, Privilege Escalation, com dezenas de técnicas documentadas a partir de comportamento real de adversários (MITRE, 2020). Mapear seus achados a essas técnicas dá rigor ao relatório: em vez de dizer "achei um SUID", você documenta "abuso de SUID/SGID (T1548.001)", o que conecta o achado a detecções e mitigações reconhecidas pelo time azul.

Vale entender também o lugar dessa fase no ciclo de ataque. Ela vem depois do acesso inicial e antes (ou em paralelo) da movimentação lateral e da exfiltração. É um ponto de inflexão: enquanto o acesso é de baixo privilégio, o atacante é barulhento e contido; depois de virar root ou SYSTEM, ele pode desligar logs, criar contas e se esconder. Por isso a escalação costuma ser o achado de maior severidade num relatório de pentest.

Dois tipos de escalação

Antes das técnicas específicas, vale distinguir os dois grandes caminhos:

Os dois são valiosos. Muitas vezes uma escalação horizontal — assumir a conta de um colega administrador, por exemplo — é o atalho mais rápido para a vertical. Em redes corporativas, é comum encadear: você compromete um usuário comum, faz horizontal para a conta de um operador de backup (que tem acesso de leitura a tudo) e, a partir das credenciais que ele guardou, faz vertical para o domínio inteiro. Pense em escalação como um grafo de confiança, não como uma escada linear.

Enumeração: o passo que não pode faltar

Escalação de privilégios é 80% enumeração e 20% exploração. Antes de tentar qualquer técnica, você precisa entender o terreno. Essa disciplina é a mesma do reconhecimento, só que agora aplicada de dentro do sistema.

Em Linux, comandos manuais de enumeração incluem:

id                      # quem sou e a quais grupos pertenço
sudo -l                 # o que posso rodar como sudo
uname -a                # versão do kernel
find / -perm -4000 2>/dev/null   # binários SUID
cat /etc/crontab        # tarefas agendadas

Em Windows, o foco muda para serviços e configurações:

whoami /priv                       # privilégios do token atual
wmic qfe get HotFixID              # patches instalados
sc query                           # serviços em execução

Ferramentas como LinPEAS, WinPEAS e linux-exploit-suggester automatizam grande parte dessa coleta, mas entender o que cada verificação significa é o que separa o profissional do executor de scripts.

Um checklist mental de enumeração

Para não se perder na avalanche de saída do LinPEAS, organize a enumeração em categorias. Pergunte-se, sistematicamente:

Esse roteiro evita que você caia na armadilha de rodar dez ferramentas e não saber interpretar nenhuma. Quando um achado aparece, classifique-o numa dessas categorias e investigue até o fim antes de seguir.

Técnicas comuns em Linux

No Linux, alguns vetores aparecem repetidamente em testes reais:

Um exemplo clássico de abuso de sudo:

# Se 'sudo -l' mostra que você pode rodar 'find' como root:
sudo find . -exec /bin/sh \; -quit
# o shell resultante herda os privilégios de root

Abusando de SUID na prática

Um binário com o bit SUID ativado roda com os privilégios do dono do arquivo, não de quem o executa. Se esse dono é root e o binário permite executar comandos arbitrários, você tem root. O reflexo é listar os SUID e cruzar com o GTFOBins:

find / -perm -4000 -type f 2>/dev/null

Suponha que a saída inclua /usr/bin/env, que não deveria ser SUID. Pelo padrão do GTFOBins, isso vira:

# /usr/bin/env com bit SUID definido -> shell como root
/usr/bin/env /bin/sh -p
# o -p preserva o EUID privilegiado; sem ele o shell rebaixa de volta

O detalhe do -p é onde muitos iniciantes tropeçam: vários shells, por segurança, abandonam o EUID elevado ao iniciar a menos que você peça explicitamente para preservá-lo.

PATH hijacking em scripts privilegiados

Quando um script ou binário privilegiado chama outro programa sem caminho absoluto (por exemplo, chama cat em vez de /bin/cat), o sistema resolve esse nome pelo PATH. Se você controla uma entrada anterior do PATH, planta seu próprio cat:

# script root roda 'cat' sem caminho absoluto
cd /tmp
echo '/bin/bash -p' > cat
chmod +x cat
export PATH=/tmp:$PATH
# ao disparar o script privilegiado, seu 'cat' é executado como root

Esse vetor combina enumeração (achar o script que chama binários relativos) com escrita em diretório controlado — exatamente o tipo de cadeia que um relatório deve descrever passo a passo.

Técnicas comuns em Windows

No Windows, o ecossistema de privilégios é diferente, mas a lógica é a mesma — encontrar onde a confiança foi mal configurada:

Unquoted service path em detalhe

Quando um serviço aponta para C:\Program Files\My App\service.exe sem aspas, o Windows tenta executar, em ordem, C:\Program.exe, depois C:\Program Files\My.exe e assim por diante, por causa do espaço. Se você consegue escrever em algum desses pontos intermediários, planta um executável que roda com a conta do serviço:

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

# Confirmar permissão de escrita no diretório intermediário
icacls "C:\Program Files\My App"

Se o icacls mostra (M) ou (F) para o seu usuário ou para BUILTIN\Users num caminho intermediário, o vetor é explorável.

A família "Potato" e SeImpersonatePrivilege

Contas de serviço (como as usadas por IIS ou MSSQL) frequentemente carregam SeImpersonatePrivilege. Esse privilégio permite que o processo personifique tokens de outros usuários — e técnicas como JuicyPotato, RoguePotato e PrintSpoofer enganam um serviço privilegiado a se autenticar contra um endpoint controlado, capturando um token SYSTEM. Confirme o terreno com:

whoami /priv
# Procure por SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege como "Enabled"

Em qualquer dos sistemas, a chave é cruzar a enumeração com bases de conhecimento e exploits conhecidos, frequentemente reutilizando módulos de frameworks como o Metasploit para acelerar (Kennedy et al., 2011). O módulo local_exploit_suggester do Metasploit, por exemplo, testa a sessão atual contra dezenas de exploits locais conhecidos e indica candidatos plausíveis.

Coletando credenciais pelo caminho

Boa parte da escalação real não usa exploit nenhum: usa senhas que alguém deixou cair. Vale procurar ativamente:

# Linux: caçar segredos em arquivos comuns
grep -ri "password" /etc /var/www 2>/dev/null
cat ~/.bash_history ~/.ssh/id_rsa 2>/dev/null
env                      # variáveis de ambiente com tokens

# Windows: respostas automáticas e registro
findstr /si password *.xml *.ini *.config
reg query HKLM /f password /t REG_SZ /s

Credenciais reutilizadas são ouro: uma senha encontrada num arquivo de deploy pode valer para o usuário root, para o banco de dados e para o painel de administração. Por isso a coleta de credenciais costuma ser tão produtiva quanto a caça por configurações vulneráveis.

Estabilizando e mantendo o acesso

Conseguir root uma vez não basta se o shell cair no minuto seguinte. A pós-exploração responsável inclui estabilizar a sessão e, dentro do escopo autorizado, demonstrar persistência:

Um truque clássico de estabilização em Linux é atualizar um shell preso para um TTY completo:

python3 -c 'import pty; pty.spawn("/bin/bash")'
# Ctrl-Z, depois no seu terminal local:
stty raw -echo; fg
# de volta no shell remoto:
export TERM=xterm

Lembre-se de que demonstrar persistência num teste real exige autorização explícita. O objetivo do pentest é provar o risco, não causar dano. Criar uma conta backdoor ou instalar um implante sem que isso esteja no escopo do contrato pode caracterizar acesso não autorizado mesmo dentro de um engajamento legítimo.

Como detectar e corrigir do lado defensivo

Entender a escalação ofensiva ensina a defender. As mitigações mais eficazes atacam exatamente as causas que você explorou:

Na prática defensiva, vale automatizar a busca pelos mesmos sinais que o atacante procura. Um inventário periódico de binários SUID inesperados, de regras de sudo amplas (NOPASSWD: ALL) e de serviços com caminho sem aspas fecha a maioria das portas antes que alguém as encontre:

# Auditoria defensiva: SUID fora do baseline esperado
find / -perm -4000 -type f 2>/dev/null > suid_atual.txt
diff suid_baseline.txt suid_atual.txt

Esse trabalho de auditoria contínua deve fazer parte de uma metodologia de pentest madura, em que escalação não é um achado isolado, mas parte de uma narrativa de risco.

Erros comuns de quem está começando

Alguns tropeços se repetem em quem está aprendendo a escalar:

Exploits de kernel: poder e risco

Quando todos os caminhos de configuração estão fechados, sobra o kernel. Um kernel desatualizado pode ter falhas locais conhecidas que dão root diretamente — mas esse é o vetor mais delicado de toda a escalação, e vale entender por quê.

O ponto de partida é casar a versão exata com vulnerabilidades conhecidas:

uname -r                          # versão precisa do kernel
cat /etc/os-release               # distribuição e release
# cruzar com bases de exploits locais conhecidos

Ferramentas como linux-exploit-suggester automatizam esse cruzamento, listando candidatos plausíveis. Mas atenção aos riscos reais:

A regra de ouro: trate exploit de kernel como último recurso. Esgote configurações vulneráveis (sudo, SUID, serviços, credenciais) antes de arriscar derrubar o alvo. E, num engajamento real, confirme com o cliente que esse tipo de teste está autorizado, dado o risco de indisponibilidade.

Movimentação lateral: o que vem depois do root

Virar root numa máquina raramente é o objetivo final de um pentest corporativo — é um trampolim. Com privilégios elevados, abrem-se caminhos para a movimentação lateral:

Essa transição — de escalação vertical local para expansão pela rede — é onde o pentest demonstra impacto de negócio: não "uma máquina caiu", mas "a partir de uma máquina, todo o ambiente ficou exposto". Documentar essa cadeia completa, host a host, é o que dá peso ao relatório final.

Treinando escalação com segurança

Como toda técnica ofensiva, escalação só pode ser praticada em ambientes autorizados. Plataformas de CTF e máquinas de laboratório oferecem cenários ricos, e a fase de descoberta inicial costuma começar com scanning de portas e serviços usando o Nmap antes de você sequer pensar em escalar.

Ao montar seu laboratório:

Perguntas frequentes

Preciso decorar os comandos de enumeração? Não. Vale entender as categorias (quem sou, o que posso executar, o que está rodando, o que posso ler/escrever, o que está desatualizado) e ter um cheat sheet à mão. A compreensão das categorias é o que transfere de uma máquina para outra; os comandos exatos você consulta.

LinPEAS resolve tudo? Ele acelera a coleta, mas despeja muita informação. Sem critério para interpretar a saída, você não vai distinguir o achado real do ruído. Use a automação para coletar e o seu julgamento para decidir.

Exploit de kernel é sempre a melhor saída? Raramente. É o vetor mais arriscado, podendo travar o sistema, e costuma ser o último recurso. Configurações vulneráveis (sudo, SUID, serviços) são mais confiáveis e mais comuns na vida real.

Escalação horizontal conta como achado válido? Sim. Acessar dados de outra conta do mesmo nível já demonstra quebra de isolamento e frequentemente abre o caminho para a vertical. Documente-a como passo da cadeia.

Conclusão

Escalação de privilégios é a fase que transforma um acesso frágil em controle real, e é tão decisiva que muitas vezes define o veredito de todo o pentest. O segredo não está em conhecer exploits exóticos, mas em enumerar com paciência, reconhecer configurações vulneráveis e mapear cada passo a técnicas conhecidas, como as catalogadas no MITRE ATT&CK. Domine o checklist mental de enumeração, aprenda a abusar de SUID, sudo, PATH e tokens privilegiados, colete credenciais que ficaram pelo caminho e documente o caminho completo e reproduzível. Pratique em ambientes legais e você terá uma habilidade que serve tanto para atacar com responsabilidade quanto para defender com profundidade.

Referências