pspy - espionagem de processos Linux sem privilégios

pspy é uma ferramenta de linha de comando projetada para espionar processos sem necessidade de permissões de root. Ela permite que você veja comandos executados por outros usuários, tarefas cron, etc., à medida que são executados. Ótima para enumeração de sistemas Linux em CTFs. Também ótima para demonstrar aos seus colegas por que passar segredos como argumentos na linha de comando é uma má ideia.

A ferramenta coleta informações de varreduras do procfs. Observadores Inotify colocados em partes selecionadas do sistema de arquivos acionam essas varreduras para capturar processos de curta duração.

Primeiros passos

Download

Obtenha a ferramenta na máquina Linux que deseja inspecionar. Primeiro obtenha os binários. Baixe os binários lançados aqui:

• 32 bit versão estática grande: pspy32 download
• 64 bit versão estática grande: pspy64 download
• 32 bit versão pequena: pspy32s download
• 64 bit versão pequena: pspy64s download

Os arquivos compilados estaticamente devem funcionar em qualquer sistema Linux, mas são bastante grandes (~4MB). Se o tamanho for um problema, tente as versões menores que dependem da libc e são comprimidas com UPX (~1MB).

Compilar

Use Go instalado no seu sistema ou execute o processo de compilação baseado em Docker que foi executado para criar o lançamento. Para este último, certifique-se de que o Docker esteja instalado e execute make build-build-image para construir uma imagem Docker, seguido por make build para compilar os binários com ela.

Você pode executar pspy --help para aprender sobre as flags e seus significados. O resumo é o seguinte:

• -p: ativa a impressão de comandos para stdout (ativado por padrão)
• -f: ativa a impressão de eventos do sistema de arquivos para stdout (desativado por padrão)
• -r: lista de diretórios para observar com Inotify. O pspy observará todos os subdiretórios recursivamente (por padrão, observa /usr, /tmp, /etc, /home, /var e /opt).
• -d: lista de diretórios para observar com Inotify. O pspy observará apenas esses diretórios, não os subdiretórios (vazio por padrão).
• -i: intervalo em milissegundos entre as varreduras do procfs. O pspy verifica regularmente novos processos independentemente de eventos Inotify, apenas no caso de alguns eventos não serem recebidos.
• -c: imprime comandos em cores diferentes. Eventos do sistema de arquivos não são mais coloridos, comandos têm cores diferentes com base no UID do processo.
• --debug: imprime mensagens de erro verbosas que de outra forma ficam ocultas.

As configurações padrão devem ser suficientes para a maioria das aplicações. Observar arquivos dentro de /usr é o mais importante, pois muitas ferramentas acessarão bibliotecas dentro dele.

Alguns exemplos mais complexos:

# print both commands and file system events and scan procfs every 1000 ms (=1sec)
./pspy64 -pf -i 1000 

# place watchers recursively in two directories and non-recursively into a third
./pspy64 -r /path/to/first/recursive/dir -r /path/to/second/recursive/dir -d /path/to/the/non-recursive/dir

# disable printing discovered commands but enable file system events
./pspy64 -p=false -f

Exemplos

Observação de tarefas cron

Para ver a ferramenta em ação, basta clonar o repositório e executar make example (Docker necessário). É sabido que passar senhas como argumentos de linha de comando não é seguro, e o exemplo pode ser usado para demonstrar isso. O comando inicia um contêiner Debian no qual uma tarefa cron secreta, executada por root, altera a senha de um usuário a cada minuto. O pspy é executado em primeiro plano, como usuário myuser, e verifica processos. Você deve ver uma saída semelhante a esta:

~/pspy (master) $ make example
[...]
docker run -it --rm local/pspy-example:latest
[+] cron started
[+] Running as user uid=1000(myuser) gid=1000(myuser) groups=1000(myuser),27(sudo)
[+] Starting pspy now...
Watching recursively    : [/usr /tmp /etc /home /var /opt] (6)
Watching non-recursively: [] (0)
Printing: processes=true file-system events=false
2018/02/18 21:00:03 Inotify watcher limit: 524288 (/proc/sys/fs/inotify/max_user_watches)
2018/02/18 21:00:03 Inotify watchers set up: Watching 1030 directories - watching now
2018/02/18 21:00:03 CMD: UID=0    PID=9      | cron -f
2018/02/18 21:00:03 CMD: UID=0    PID=7      | sudo cron -f
2018/02/18 21:00:03 CMD: UID=1000 PID=14     | pspy
2018/02/18 21:00:03 CMD: UID=1000 PID=1      | /bin/bash /entrypoint.sh
2018/02/18 21:01:01 CMD: UID=0    PID=20     | CRON -f
2018/02/18 21:01:01 CMD: UID=0    PID=21     | CRON -f
2018/02/18 21:01:01 CMD: UID=0    PID=22     | python3 /root/scripts/password_reset.py
2018/02/18 21:01:01 CMD: UID=0    PID=25     |
2018/02/18 21:01:01 CMD: UID=???  PID=24     | ???
2018/02/18 21:01:01 CMD: UID=0    PID=23     | /bin/sh -c /bin/echo -e "KI5PZQ2ZPWQXJKEL\nKI5PZQ2ZPWQXJKEL" | passwd myuser
2018/02/18 21:01:01 CMD: UID=0    PID=26     | /usr/sbin/sendmail -i -FCronDaemon -B8BITMIME -oem root
2018/02/18 21:01:01 CMD: UID=101  PID=27     |
2018/02/18 21:01:01 CMD: UID=8    PID=28     | /usr/sbin/exim4 -Mc 1enW4z-00000Q-Mk

Primeiro, o pspy imprime todos os processos em execução no momento, cada um com PID, UID e a linha de comando. Quando o pspy detecta um novo processo, ele adiciona uma linha a este registro. Neste exemplo, você encontra um processo com PID 23 que parece alterar a senha do myuser. Isso é o resultado de um script Python usado no crontab privado do root /var/spool/cron/crontabs/root, que executa este comando shell (verifique crontab e script). Observe que o myuser não pode ver nem o crontab nem o script Python. Com o pspy, ele pode ver os comandos mesmo assim.

Exemplo de CTF do Hack The Box

Abaixo está um exemplo da máquina Shrek do Hack The Box. Neste desafio de CTF, a tarefa é explorar uma tarefa cron oculta que está alterando a propriedade de todos os arquivos em uma pasta. A vulnerabilidade é o uso inseguro de um caractere curinga junto com chmod (detalhes para o leitor interessado). Requer um trabalho de adivinhação considerável para encontrá-la e explorá-la. Com o pspy, porém, a tarefa cron é fácil de encontrar e analisar:

Como funciona

Existem ferramentas para listar todos os processos executados em sistemas Linux, incluindo aqueles que já terminaram. Por exemplo, existe o forkstat. Ele recebe notificações do kernel sobre eventos relacionados a processos, como fork e exec.

Essas ferramentas exigem privilégios de root, mas isso não deve lhe dar uma falsa sensação de segurança. Nada impede você de espionar os processos em execução em um sistema Linux. Muita informação é visível no procfs enquanto um processo está em execução. O único problema é que você precisa capturar processos de curta duração no curto espaço de tempo em que estão vivos. Escanear o diretório /proc em busca de novos PIDs em um loop infinito resolve o problema, mas consome muita CPU.

Uma maneira mais furtiva é usar o seguinte truque. Processos tendem a acessar arquivos como bibliotecas em /usr, arquivos temporários em /tmp, arquivos de log em /var, ... Usando a API inotify, você pode receber notificações sempre que esses arquivos forem criados, modificados, excluídos, acessados, etc. O Linux não exige usuários privilegiados para esta API, pois ela é necessária para muitas aplicações inocentes (como editores de texto que mostram um explorador de arquivos atualizado). Assim, embora usuários não-root não possam monitorar processos diretamente, eles podem monitorar os efeitos dos processos no sistema de arquivos.

Podemos usar os eventos do sistema de arquivos como um gatilho para escanear /proc, na esperança de que possamos fazê-lo rápido o suficiente para capturar os processos. É isso que o pspy faz. Não há garantia de que você não perderá algum, mas as chances parecem boas em meus experimentos. Em geral, quanto mais tempo os processos executam, maior a chance de capturá-los.

Diversos

Logo: "Por Creative Tail [CC BY 4.0 (http://creativecommons.org/licenses/by/4.0)], via Wikimedia Commons" (link)