Jump to content

Leaderboard


Popular Content

Showing content with the highest reputation since 03/25/19 in Posts

  1. 2 points
    Fiz um vídeo sobre o onionscan, explicando a teoria e a prática da ferramenta. Abre e da like, 50 faço continuação.
  2. 2 points
    bom no momento em que vc faz a conexao vc ja ta requisitando um pacote entao isso e basicamente a mesma coisa o que muda e o tipo de pacote que vc vai envia se vai ser tcp udp SYN...
  3. 2 points
    Curso de Inglês Mairo Vergara 4.0 24 Módulos Tipo de arquivo: Torrent Tamanho do arquivo Torrent: 309.64KB Tamanho do arquivo baixado: 23.1GB Servidor: MEDIAFIRE LINK: DOWNLOAD *Aguarde 5 segundos e feche a propaganda* Tem Bastante seeds aproveitem! Se o link estiver OFF, avise nos comentários!
  4. 2 points
    Cerca de 29GB de dados no site do Wikileaks. https://file.wikileaks.org/file/ https://file.wikileaks.org/torrent/
  5. 2 points
    Já dei inicio ao projeto, segue o LINK DA PLAYLIST. Espero ajudar, quem queira !
  6. 1 point
    Chego com o intuito de trocar conhecimento, aprender e fortalecer a comunidade.
  7. 1 point
  8. 1 point
    quais musicas vcs escutam na hora da hackinagem / programação?
  9. 1 point
    <head> <title>Prazer em conhecelos</title> </head> <body> Sou novo aqui, tenho 17 anos, me interessei por computadores aos 12 anos quando comecei a fazer cursos de programação, não posso dizer em que nivel estou porque nem mesmo eu sei, em coisas facéis eu geralmente "mosco" e em coisas q são um pouco mais complexas tenho facilidade Estou aqui atras de conhecimento </body>
  10. 1 point
    Ola eu fiz um bot em python, que faz trabalhos escolares. Este foi o primeiro projeto "grande" em que fiz, e quero compartilhar com vocês! Um amigo pediu que ensinasse a ele, caso achem a ideia boa posso tentar fazer uma serie para o Youtube. Video do BOT
  11. 1 point
    Essa é uma ótima ideia!
  12. 1 point
    Eu li sobre este livro em alguns lugares depois que comecei a visitar o forum e vou deixar para quem mais se interessar. [Manning] - Secrets of the JavaScript Ninja - [Resig].pdf
  13. 1 point
  14. 1 point
    Cara é um ótima ideia, eu adoraria aprender também. Fico no aguardo
  15. 1 point
    Galera nessa postagem vou mostrar o vmlab (Visual Micro Lab) que é um simulador para arquitetura AVR e ST6. Os microcontroladores aceito nesse simulador são: esse simulador alem de permitir escrever o nosso codigo em assembly é possivel instalar o winavr e integrar a ele a linguagem C, tambem tem alguns outros recursos como descrever um circuitinho em spice, um painel onde tem alguns componentes (botões, leds, potenciômetro e etc). Para baixar ele podemos ir direto no site oficial site oficial depois de baixar, instalar e executar vamos nos deparar com janela inicial para começar basta a gente criar um projeto apertando no menu "Project" e depois "New project". Na proxima aba no "Step 1" escolhemos onde vamos salvar o nosso projeto, no "Step 2" vamos escolher o processador (no meu caso vou brincar com o atmega168), no "Step 3" podemos deixar o compilador padrao, no "Step 4" podemos adicionar uma codigo fonte digitando o nome e apertando em "Add this", por fim apertamos no botão "OK" com o projeto criado basta digitar o nosso codigo assembly na aba do codigo e o nosso circuito na aba do projeto (podemos usar apenas o codigo e debugar ele, não é necessario criar o circuito). Nesse tutorial não vou abordar a linguagem assembly (talvez em um futuro tutorial quem sabe). Para esse exemplo vou fazer um simples codigo que coloca um dos pinos do microcontrolador como saida e fica alternando ele em um loop infinito, para isso setamos em um registrador a pinagem que vamos ter como saida ou como entrada (diferente dos PICs onde o numero 0 indica a saida e o numero 1 a entrada, os AVRs o numero 0 indica a entrada e 1 seria a saida '-' ), agora enviamos o conteudo daquele registrador para o DDRx indicando quem vai ser a saida ou entrada daquele Port .include "C:\VMLAB\include\m168def.inc" reset: rjmp inicio inicio: ;reg r20 recebe 00000100 ldi r20,4 ;especificamos as entradas/saidas do PORTD out DDRD,r20 agora em um loop infinito vou ficar alternando (tem formas mais eficientes como manipular cada bit XD), nesse caso tambem não vamos enviar para o DDRx e sim para o proprio PORT .include "C:\VMLAB\include\m168def.inc" reset: rjmp inicio inicio: ;reg r20 recebe 00000100b ldi r20,4 ;especificamos as entradas/saidas do PORTD out DDRD,r20 repetir: ;seta no reg20 00000000b ldi r20,0 out PORTD,r20 ;seta no reg20 00000100b ldi r20,4 out PORTD,r20 ;pulo incodicional para o repetir rjmp repetir depois de escrever o nosso codigo basta compilar e debugar o codigo, para isso apertamos no menu "Project" e por fim "Build" (tambem podemos apertar a tecla F9), se tudo ocorrer bem vai aparecer uns quadradinhos verde no lado do codigo alem de uma mensagem na aba message ("Success! All ready to run") podemos rodar nosso codigo indo no menu "Run", apertando em "Go / Continue" (F5) ele vai rodar o codigo direto ou podemos rodar passo a passo apertando no menu "Step over" (F6) ou "Step into" (F7) no lado do codigo tem uns quadrado verde sendo um breakpoint, podemos apertar nele e parar a execução do codigo sempre que passar naquela determinada instrução que tiver o breakpoint, assim podemos da um run direto e analisar apenas aquele trecho em especifico podemos abrir algumas abas no menu "View" que mostra algumas informações dos registradores, pinos, memorias. no menu "View" tambem tem o "Control Panel" com alguns componentes como botões e leds. Para interligar um dos pinos do microcontrolador a um dos led usamos a aba project e descrevemos o circuito em spice (tem um pequeno probleminha, não da para usar o pino como source para o led, então vai ter que acender o led em nivel logico baixo e apagar ele em nivel logico alto kkk) .MICRO "ATmega168" .PROGRAM "kodo.asm" .TARGET "meuprojeto.hex" .TRACE ; Activate micro trace .POWER VDD=5 VSS=0 ; Power nodes .CLOCK 1meg ; Micro clock .STORE 250m ; Trace (micro+signals) storage time ;tem um resistor de 280 ohms ta conectado ao PortD pino 2 e ao Nó 1 R1 PD2 1 280 ;o anodo do led ta no VDD e o catado ta no Nó 1 D1 VDD 1 tambem existe um osciloscópio no simulador, para usar ele declaramos .PLOT o pino no project .PLOT V(PD2) se a gente olhar na pasta do projeto vai ter o .hex então é possivel subir o nosso codigo em um microcontrolador real bom galera esse simulador é bem legal para aprender programar em assembly para microcontroladores AVR ^^ by kodo no kami
  16. 1 point
    https://drive.google.com/drive/folders/0BzaTvtY-IGcpekJGYUwyZ09MRHM
  17. 1 point
    Dicionário Hacker. Créditos TheCyberTeam DicionarioHacker(TheCybersTeamv1.1).pdf
  18. 1 point
    ---_ ......._-_--. (|\ / / /| \ \ / / .' -=-' `. / / .' ) _/ / .' _.) / / o o _.-' / .' \ _.-' / .'*| \______.-'// .'.' \*| \| \ | // .'.' _ |*| ` \|// .'.'_ _ _|*| . .// .'.' | _ _ \*| \`-|\_/ / \ _ _ \*\ `/'\__/ \ _ _ \*\ /^| \ _ _ \* ' ` \ _ _ \ ASH (+VK) \_ fonte: http://ascii.co.uk/art/snake = Python with Penetration Testing and Networking Penetration(pen) tester e hacker são termos semelhantes. A diferença é que pen-testers trabalham em uma organização para evitar às investidas de hackers, enquanto que um hacker geralmente trabalha para obter fama, vender vulnerabilidades por dinheiro, ou para explorar vulnerabilidades a fim de adiquirir algumas inimizades. Hackers bem treinados trabalham no campo de segurança da informação, invadindo um sistema e informando a vítima dos bugs de segurança para que eles possam ser corrigidos. Um hacker chamado de pentester é aquele que trabalha em uma empresa a fim de protejer seu sistema. Um pentester só inicia suas tentativas de quebrar a rede depois de obter a aprovação legal do cliente e, em seguida, apresenta um relatório de suas descobertas. Para se tornar um especialista em pentesting, uma pessoa deve ter profundo conhecimento dos conceitos de sua tecnologia. Neste capítulo, abordaremos os seguintes tópicos: • O escopo do pentesting • A necessidade do pentesting • Componentes a testar • Qualidades de um bom pentester • Abordagens do pentesting • Compreendendo os testes e ferramentas que você precisará • Network sockets • Métodos server socket • Métodos client socket • Métodos general socket • Exemplos práticos com socket • Socket exceptions • Métodos úteis do socket == Introducing the scope of pentesting Em simples palavras, penetration testing é o teste que avalia as políticas de segurança da informação de uma empresa. As medidas de segurança da informação envolvem a rede da empresa, banco de dados, site, servidores públicos e tudo o mais especificado pelo cliente. No final do dia, um pentester deve apresentar um relatório detalhado de suas descobertas, tais como instabilidades, vulnerabilidade na infra-estrutura da empresa, e o nível de risco da vulnerabilidade em particular, e fornecer soluções, se possível. === The need for pentesting Existem vários pontos que descrevem o significado do pentesting: * O pentesting identifica as ameaças que podem expor a confidencialidade de uma organização * Um Expert em pentesting fornece garantia para a organização com uma avaliação completa e detalhada da segurança organizacional * O pentesting avalia a eficiência da rede, produzindo uma enorme quantidade de tráfego e examina a segurança de dispositivos como firewalls, roteadores e switches * Alterar ou atualizar a infra-estrutura de software existente, hardware ou design de rede pode levar a vulnerabilidades que podem ser detectadas por pentesting * No mundo de hoje, as ameaças potenciais estão aumentando significativamente; Pentesting é um exercício proativo para minimizar a chance de ser "exploitado" * O Pentesting garante se as políticas de segurança adequadas estão sendo seguidas ou não Considere um exemplo de um e-commerce de nome que que gera sua renda com um serviço on-line. Um hacker ou grupo de hackers black hat encontram uma vulnerabilidade no site da empresa e a explora. Pode ser devastador a quantidade de prejuízo que eles podem causar. === Components to be tested Uma organização deve realizar uma operação de avaliação de risco antes do pentesting; isso ajudará a identificar as principais ameaças, como a má configuração ou vulnerabilidades em: * Roteadores, switches, ou gateways * Sistemas voltados para o público; Sites, DMZ, servidores de e-mail e sistemas remotos * DNS, firewalls, servidores proxy, FTP, e servidores web O teste de segurança deve ser executado em todos os componentes de hardware e software de um sistema em rede. === Qualities of a good pentester Os pontos a seguir descrevem as qualidades de um bom pentester. Ele deve: * Escolher um conjunto adequado de testes e ferramentas que equilibram custos e benefícios * Seguir procedimentos adequados com planejamento e documentação adequada * Estabelecer o escopo de cada teste, tais como objetivos, limitações e justificativa de procedimentos * Estar pronto para mostrar como explorar as vulnerabilidades * Indicar claramente os potenciais riscos achados no relatório final e fornecer métodos para a correção dos mesmos, se possível * Manter-se sempre atualizado porque a tecnologia está em constante evolução Um pentester testa a rede usando técnicas manuais ou ferramentas relevantes. Existem muitas ferramentas disponíveis no mercado. Algumas delas são de código aberto; outras muito caras. Com a ajuda da programação, você pode fazer suas próprias ferramentas. Ao criar suas próprias ferramentas, você pode esclarecer seus conceitos e também executar mais "R&D". Se você está interessado em pentesting e quer fazer suas próprias ferramentas, então a linguagem de programação Python é a melhor, pois conta com uma ampla variedade de pacotes para pentesting e é muito simples programar com ela. Esta simplicidade, juntamente com as bibliotecas de terceiros, tais como scapy e mechanize, reduz o tamanho do código. Em Python, para fazer um programa, você não precisa definir classes "gordas" como no Java. É mais produtivo escrever código em Python do que em C, e existem bibliotecas de alto nível para fazer praticamente qualquer tarefa imaginável. Se você já sabe um pouco sobre programação com Python e está interessado em pentesting este livro é ideal para você. === Deining the scope of pentesting Antes de entrar na fase do pentesting, o escopo do pentesting deve ser concebido. Os seguintes pontos devem ser considerados enquanto definimos o escopo: * Você deve desenvolver o escopo do projeto em consulta com o cliente. Por exemplo, se Bob (o cliente) quiser testar toda a infra-estrutura de rede da organização, então a pentester Alyosha definirá o escopo do pentesting levando essa rede em consideração. Alyosha consultará Bob quando houver alguma área a mais que precisa ser analizada * Você deve levar em conta o tempo, as pessoas e o dinheiro. * Você deve perfilar os limites do teste com base em um contrato assinado pelo pentester e pelo cliente. * As mudanças nas práticas da empresa podem afetar o escopo. Por exemplo, a adição de uma sub-rede, novas instalações de componentes, a adição ou modificação de um servidor web, e assim por diante, pode alterar o escopo do pentesting. O escopo do pentesting é definido em dois tipos de testes: * **Teste não destrutivo**: Este teste é limitado a encontrar e executar os testes sem riscos potenciais. Ele executa as seguintes ações: ** Escaneia e identifica potenciais vulnerabilidades no sistema remoto ** Investiga e verifica as descobertas ** Mapeia as vulnerabilidades com exploits apropriados ** Exploita o sistema remoto com o devido cuidado para evitar interrupções ** Fornece uma prova de conceito ** Não efetua um ataque de negação de serviço(DoS) * **Teste destrutivo**: Este teste pode produzir riscos. Ele executa as seguintes ações: ** Efetua ataques DoS e buffer overflows, que tem o potêncial de derrubar o sistema == Approaches to pentesting Existem três tipos de abordagens para pentesting: * **Black-box pentesting** segue a abordagem não-determinística de testes ** Você receberá apenas um nome de empresa ** Você deve agir - entre aspas - como um black hat(sem conhecimento prévio da infra) ** Não há necessidade de qualquer conhecimento prévio do sistema ** É demorado * **White-box pentesting** segue a abordagem determinista de testes ** Você receberá o conhecimento completo da infra-estrutura que precisa ser testada ** Serão fornecidas informações sobre a infra-estrutura da empresa, o tipo de rede, as políticas da empresa, os tópicos a fazer e a não fazer, o endereço IP e o firewall IPS/IDS * **Grey-box pentesting** segue uma abordagem híbrida de ambas as abordagens citadas acima: ** O pentester geralmente tem informações limitadas sobre a rede/sistema que é fornecido pelo cliente para reduzir os custos e diminuir tentativa e erro por parte do pentester ** Ele realiza a avaliação de segurança e os testes internamente == Introducing Python scripting Antes de começar a ler este livro, você deve conhecer os conceitos básicos da programação em Python, como a sintaxe básica, os tipos de variáveis, a estrutura de dado tupla, o dicionário, as funções, as strings, os métodos e assim por diante. Duas versões, 3.4 e 2.7.8, estão disponíveis em python.org/downloads/. Neste livro, todas as experiências e demonstrações foram feitas em Python versão 2.7.8. Se você usa o sistema operacional Linux como Kali ou BackTrack, então não haverá nenhum problema, porque muitos programas, como snifing wireless, não funcionam na plataforma Windows. O Kali Linux também usa a versão 2.7. Se você gosta de trabalhar no Red Hat ou CentOS, então esta versão é adequada para você A maioria dos hackers escolhem esta profissão porque eles não querem programar. Eles querem usar ferramentas. No entanto, sem programação, um hacker não pode melhorar suas habilidades. E de tempos em tempos eles procuram novas ferramentas na internet. Acredite em mim, depois de ver a sua simplicidade, você vai adorar esta linguagem. == Understanding the tests and tools you'll need Como você deve ter visto, este livro é dividido em sete capítulos. Para realizar varreduras e snifing pentesting, você precisará de uma pequena rede de dispositivos conectados. Se você não tem um laboratório, você pode fazer máquinas virtuais em seu computador. Para análise de tráfego sem fio, você deve ter uma rede sem fio. Para realizar um ataque na web, você precisará de um servidor Apache rodando na plataforma Linux. Será uma boa idéia usar CentOS ou Red Hat versão 5 ou 6 para o servidor web, pois contém os RPM's do Apache e PHP. Para o script Python, vamos usar a ferramenta Wireshark, que é de código aberto e pode ser executado no Windows, bem como plataformas Linux. == Learning the common testing platforms with Python Agora vamos começar a falar de pentesting; Espero que você esteja bem familiarizado com fundamentos de rede, como endereços IP, sub-redes classful, sub-redes sem classes, o significado das portas, endereços de rede e endereços de broadcast. Um pentester deve ser perfeito em fundamentos de redes, ou pelo menos entender bem um sistema operacional; Se você está pensando em usar o Linux, então você está no caminho certo. Neste livro, vamos executar nossos programas no Windows, bem como Linux. Neste livro, Windows, CentOS e Kali Linux serão usados. Um hacker sempre gosta de trabalhar em um sistema Linux. Como é livre e de código aberto, Kali Linux marca o renascimento do BackTrack e vem com um arsenal de ferramentas de hacking. Kali Linux NetHunter é a primeira plataforma de teste de penetração Android de código aberto para dispositivos Nexus. Algumas ferramentas funcionam no Linux e no Windows, mas no Windows, geralmente essas ferramentas não funcionam. Espero que você tenha conhecimento do Linux. Agora, é hora de trabalhar com redes em Python. == Network sockets Um network socket adress contém um endereço IP e um número de porta. De uma forma muito simples, um socket é uma maneira de falar com outros computadores. Por meio de um socket, um processo pode se comunicar com outro processo através da rede. Para criar um socket, use a função `socket.socket()` que está disponível no módulo socket. A sintaxe geral de uma função socket é a seguinte: [source,python] ---- s = socket.socket (socket_family, socket_type, protocol=0) ---- Aqui está a descrição dos parâmetros: `socket_family: socket.AF_INET, PF_PACKET` **AF_INET** é a família de endereços para **IPv4**. **PF_PACKET** opera na camada de driver de dispositivo. A biblioteca pcap para Linux usa **PF_PACKET**. Você verá mais detalhes sobre **PF_PACKET** no Capítulo 3, Snifing e Penetration Testing. Esses argumentos representam as famílias de endereços eo protocolo da camada de transporte: `Socket_type : socket.SOCK_DGRAM, socket.SOCK_RAW,socket.SOCK_STREAM` O argumento **socket.SOCK_DGRAM** descreve que UDP é confiável e sem conexão, e **socket.SOCK_STREAM** descreve que o TCP é confiável e é um serviço de conexão bidirecional. Discutiremos **socket.SOCK_RAW** no Capítulo 3, Snifing e Penetration Testing. `protocol` Geralmente, deixamos esse argumento; recebe 0 se não for especificado. Veremos o uso deste argumento no Capítulo 3, Sniffing and Penetration Testing. == Server socket methods * `socket.bind(address)`: Este método é usado para conectar o endereço(endereço IP, número da porta) ao socket. O socket deve estar aberto antes de se conectar ao endereço. * `socket.listen(q)`: Este método inicia a esculta TCP. O argumento q define o número máximo de conexões line-up. * `socket.accept()`: Usado para aceitar a conexão do cliente. Antes de usar este método, os métodos `socket.bind(address)` e `socket.listen(q)` devem ser usados. O método `socket.accept()` retorna dois valores: `client_socket` e `address`, onde `client_socket` é um novo objeto socket usado para enviar e receber dados através da conexão e o address é o endereço do cliente. Você verá exemplos mais tarde. == Client socket methods O único método dedicado ao cliente é o: * `socket.connect(address)`: Este método conecta o cliente ao servidor. O argumento `address` é o endereço do servidor. == General socket methods * `socket.recv(bufsize)`: Esse método recebe uma mensagem TCP do socket. O argumento `bufsize` define o máximo de dados que ele pode receber. * `socket.recvfrom(bufsize)`: Esse método recebe dados do socket. O método retorna um par de valores: o primeiro valor são dados recebidos, e o segundo valor é o endereço so socket que envia os dados. * `socket.recv_into(buffer)`: Este método recebe dados menores ou iguais a `buffer`. O parâmetro `buffer` é criado pelo método `bytearray()`. Discutiremos isso em um exemplo mais adiante. * `socket.recvfrom_into(buffer)`: Esse método obtém dados do socket e os gravam no buffer. É retornado dois valores(nbytes, address), onde `nbytes` é o número de bytes recebidos e `address` é o endereço do socket que envia 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. Retorna o número de bytes enviados. * `socket.sendto(data, address)`: Este método é utilizado para enviar dados(parâmetro data) para o socket. Geralmente, usamos esse método em UDP. UDP é um protocolo sem conexão; Portanto, o socket não deve ser conectado a uma máquina remota, e no argumento address especifique o endereço da máquina remota. O valor de retorno fornece o número de bytes enviados. * `socket.sendall(data)`: 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. Esse método transfere incessantemente dados até que um erro seja encontrado. Se um erro for encontrado, uma exceção é lançada, e `socket.close()` fecha o socket. Então vamos a prática! == Moving on to the practical Primeiro, vamos fazer um programa server-side que oferece uma conexão com o cliente e envia uma mensagem para o mesmo. Crie o arquivo `server1.py` e adicione o seguinte código: [source,python] ---- import socket host = "192.168.1.2" #Server address port = 12345 #Port of Server s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((host,port)) #bind server s.listen(2) conn, addr = s.accept() print(addr, "Now Connected") conn.send("BSD is Life") conn.close() ---- O código precedente é muito simples; É o código mínimo no lado do servidor. Primeiro, importe o módulo socket e defina o host e o número da porta: **192.168.1.2** é o endereço IP do servidor. `socket.AF_INET` define a família do protocolo IPv4. `Socket.SOCK_STREAM` define a conexão TCP. A instrução `s.bind((host, port))` leva apenas um argumento. Liga(bind) o socket ao host e número de porta. A instrução `s.listen(2)` escuta a conexão e aguarda o cliente. A instrução `conn, addr = s.accept()` retorna dois valores: **conn** e **addr**. O socket **conn** é o socket cliente, como discutimos anteriormente. A função `conn.send()` envia a mensagem para o cliente. Finalmente, `conn.close()` fecha o socket. A partir dos exemplos a seguir com capturas de tela, você entenderá melhor o `conn`. Saída do programa server1.py: `$ python server1.py ` Agora o servidor está em listening(modo de escuta) aguardando o cliente: Dê uma olhada no código do client-side. Crie o arquivo client1.py e adicione as seguintes linhas: [source,python] ---- import socket s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host = "192.168.1.2" # server address port =12345 #server port s.connect((host,port)) print s.recv(1024) s.send("Hello Server") s.close() ---- No código anterior, vimos dois métodos novos: `s.connect((host, port))`, que conecta o cliente ao servidor, e `s.recv(1024)`, que recebe as strings enviadas pelo servidor. A saída do `client.py` e a resposta do servidor são mostradados na seguinte captura de tela: image::http://i.imgur.com/iUgdChG.png[img1] A saída mostra que o servidor aceitou a conexão de `192.168.1.5`. Não se confunda com a porta 42000; É a porta aleatória do cliente. Quando o servidor envia uma mensagem para o cliente, ele usa o socket conn, como mencionado anteriormente, e este socket contém o endereço IP do cliente e o número da porta. Como vimos na imagem acima, o servidor está no modo de escuta e o cliente se conecta ao servidor. Quando você executar o servidor/cliente novamente, a porta aleatória será alterada. Para o cliente, a porta do servidor **12345** é a porta de destino, e para o servidor, a porta aleatória do cliente **42000** é a porta de destino. Você pode estender a funcionalidade do servidor usando o loop while, conforme mostrado no seguinte programa. Execute o programa `server2.py`: [source,python] ---- import socket host = "192.168.1.2" port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((host,port)) s.listen(2) while True: conn, addr = s.accept() print(addr, "Conexão bem sucedida") conn.send("BSD é VIDA!") conn.close() ---- O código anterior é o mesmo que o primeiro que vimos, apenas adicionamos um loop `while` infinito. Execute o programa `server2.py` em um host(no meu caso um FreeBSD), e o `client1.py` em outro host(no meu caso o Fedora). Observe o output(saída) do server2.py: image::http://i.imgur.com/Uq2nSfH.png[img2] Um servidor pode responder muitos clientes. O loop while mantém o programa do servidor vivo e não permite que o código pare de rodar. Você pode definir um limite de conexão para o loop while; Por exemplo, defina `while i > 10` e incremente 1 em i(i += 1) a cada conexão. Antes de prosseguir para o próximo exemplo, o conceito de `bytearray` deve ser entendido. O array `bytearray` é uma sequência mutável de inteiros unsigned no intervalo de 0 a 255. Você pode excluir, inserir ou substituir valores ou pedaços isolados. Os objetos do array `bytearray` podem ser criados chamando a matriz interna `bytearray`. A sintaxe geral de bytearray é: `bytearray([source[, encoding[, errors]]])` Vejamos um exemplo: ``` >>> m = bytearray("Heise Berg") >>> m[1] 101 >>> m[0] 72 >>> m[:5] = "Ollar" >>> m bytearray(b'Ollar Berg') >>> ``` Isto é um exemplo de slicing no `bytearray()`. Agora, vejamos a operação splitting no bytearray(): ``` >>> m = bytearray("Hello Heise") >>> m bytearray(b'Hello Heise') >>> m.split() [bytearray(b'Hello'), bytearray(b'Heise')] ``` Em seguida temos a operação append no bytearray(): ``` >>> m.append(33) >>> m bytearray(b'Hello Heise!') >>> ``` No próximo exemplo utilizaremos `s.recv_into(buff)`. Neste exemplo, usaremos `bytearray()` para criar um buffer de armazenamento de dados. Primeiro, execute o código server-side. segue abaixo o código do `server3.py`: [source,python] ---- import socket host = "192.168.1.2" port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((host, port)) s.listen(1) conn, addr = s.accept() print("conectado em", addr) conn.send("Thanks") conn.close() ---- O programa anterior é o mesmo que vimos anteriormente. Neste programa, o servidor envia Thanks, seis caracteres. Agora execute o seguinte programa client-side: [source,python] ---- import socket host = "192.168.1.2" port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) buf = bytearray("-" * 30) # buffer criado print("Numero de bytes ",s.recv_into(buf)) print(buf) s.close ---- No programa anterior, um parâmetro `buf` é criado usando `bytearray()`. A instrução `s.recv_into(buf)` fornece o número de bytes recebidos. O parâmetro `buf` nos dá a string recebida. Veja as imagens do exemplo apresentado: image::http://i.imgur.com/T0Fw6V8.png[img3] Nosso client recebeu com sucesso uma string de 6 bytes, `Thanks`. Agora, você já tem uma noção sobre `bytearray()`. Espero que você se lembre. Desta vez vou criar um socket UDP Execute `udp1.py`, e em seguida vamos discutir o código linha por linha: [source,python] ---- import socket host = "192.168.1.2" port = 12346 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.bind((host,port)) data, addr = s.recvfrom(1024) print("received from ",addr) print("obtained ", data) s.close() ---- `socket.SOCK_DGRAM` cria um socket UDP, e `data, addr = s.recvfrom(1024)` retornam duas coisas: primeiro são os dados e a segunda é o endereço da fonte. Agora, veja o client-side. Execute `udp2.py`: [source,python] ---- import socket host = "192.168.1.2" port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) print(s.sendto("hello all",(host,port))) s.close() ---- Aqui, eu usei o socket UDP e o método `s.sendto()`, como você pode ver na definição do `socket.sendto()`. Você sabe muito bem que UDP é um protocolo sem conexão, então não há necessidade de estabelecer uma conexão aqui. A seguinte captura de tela mostra a saída de udp1.py(o servidor UDP) e udp2.py(o cliente UDP): image::http://i.imgur.com/7gmjvoa.png[img4] O server recebeu os dados com êxito. Vamos supor que um servidor está em execução e não há nenhuma conexão inicial com o cliente, pelo menos que ele tenha ouvido. Para evitar essa situação, use o `socket.timeout(value)`. Geralmente, passamos um valor inteiro; Se eu passo 5 como o valor, significa que ele vai esperar por 5 segundos. Se a operação não for concluída dentro de 5 segundos, será lançada uma exceção de tempo limite. Você também pode fornecer um valor do tipo float não-negativo. Por exemplo, vamos olhar para o seguinte código: [source,python] ---- import socket host = "192.168.1.2" port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.bind((host,port)) s.settimeout(5) data, addr = s.recvfrom(1024) print("recevied from ",addr) print("obtained ", data) s.close() ---- Eu adicionei uma linha extra, ou seja, `s.settimeout(5)`. O programa espera por 5 segundos; caso não haja conexões nesse intervalo, ele lança um erro. Execute udptime1.py. A saída é mostrada na seguinte imagem: image::http://i.imgur.com/d52rKiK.png[img5] O programa mostra um erro; tudo indica que ele não é um bom programa, pois seu erro é obscuro. O programa deve ser capaz manipular as exceções. === Socket exceptions Para lidar com exceções, usaremos os blocos `try` e `except`. O próximo exemplo lhe dirá como lidar com as exceções. Execute `udptime2.py`: [source,python] ---- import socket host = "192.168.1.3" port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: s.bind((host,port)) s.settimeout(5) data, addr = s.recvfrom(1024) print("recevied from ",addr) print("obtained ", data) s.close() except socket.timeout : print("Client not connected") s.close() ---- A saída é mostrada na seguinte imagem: image::http://i.imgur.com/EPyZ4zu.png[img6] No bloco try, eu coloco o meu código; no except, uma mensagem personalizada para ser exibida caso ocorra alguma exception. Diferentes tipos de exceções são definidos na biblioteca sockets do Python para diferentes erros. Vejamos algumas: * `exception socket.herror`: Este bloco detecta erros relacionados à endereços. * `exception socket.timeout`: Este bloco captura uma exceção quando o tempo limite de esculta do socket expirar. No exemplo anterior você pode ver que usamos `socket.timeout`. * `exception socket.gaierror`: Este bloco captura qualquer exceção que é gerada devido a `getaddrinfo()` e `getnameinfo()`. * `exception socket.error`: Este bloco detecta quaisquer erros relacionados a socket. Se você não tiver certeza sobre qualquer exceção lançar, você pode usá-lo. Em outras palavras, você pode dizer que é um bloco genérico que pega qualquer tipo de exceção. === Useful socket methods Você ganhou conhecimento sobre socket e sobre a arquitetura cliente-servidor. E você já é capaz de fazer um pequeno software networking. No entanto, o objetivo deste livro é testar e coletar informações em alguma rede. Python pode fazer isso de maneira elegante, ele possuí métodos úteis para coleta informações. Primeiro, `import socket` e use os seguintes métodos: * `socket.gethostbyname(hostname)`: Este método recebe um hostname como parâmetro e retorna um endereço IPv4. O endereço IPv4 é retornado na forma de string. Aqui está um exemplo: ``` >>> import socket >>> socket.gethostbyname('thapar.edu') '220.227.15.55' >>> >>> socket.gethostbyname('google.com') '173.194.126.64' >>> ``` Eu sei que você está pensando sobre o comando **nslookup**. Mais tarde, você verá mais bruxarias. * `socket.gethostbyname_ex (name)`: Este método converte um nome de host para um endereço IPv4 padrão. No entanto, a vantagem sobre o método anterior é que ele dá todos os endereços IP do nome de domínio. Ele retorna uma tupla (hostname, canonical name, and IP_addrlist) onde hostmane é dado por nós, canonical name é uma lista(possivelmente vazia) de nomes de host canônicos do servidor para o mesmo endereço e IP_addrlist é uma lista de todos os IPs disponíveis no mesmo hostname. Muitas vezes, um nome de domínio é hospedado em muitos endereços IP para equilibrar a carga do servidor. Infelizmente, este método não funciona para IPv6. Espero que você esteja bem familiarizado com tuplas, listas e dicionários. Vejamos um exemplo: ``` >>> import socket >>> socket.gethostbyname_ex('pt.org.br') ('pt.org.br', [], ['199.83.132.133', '199.83.128.133']) >>> >>> socket.gethostbyname_ex('google.com') ('google.com', [], ['172.217.29.78']) >>> >>> socket.gethostbyname_ex('facebook.com') ('facebook.com', [], ['31.13.85.36']) >>> ``` Ele retorna muitos endereços IP (ou não) de um único nome de domínio. Isso significa que um domínio como `pt.org.br` é executado em dois IPs. * `socket.gethostname()`: Isso retorna o hostname do sistema onde o interpretador Python está sendo executado atualmente: ``` >>> socket.gethostname() 'dhcppc0' >>> ``` Para obter o endereço IP da máquina atual usando o módulo socket, você pode usar o seguinte truque executando `socket.gethostbyname(socket.gethostname())`: ``` >>> socket.gethostbyname(socket.gethostname()) '200.148.457.114' >>> ``` Você sabe que o nosso computador tem muitas interfaces. Se você quiser saber o endereço IP de todas as interfaces, use a interface estendida: ``` >>> socket.gethostbyname_ex(socket.gethostname()) ('gvt.com.br', ['dhcppc0.gvt.com.br'], ['134.456.457.171']) >>> ``` Ele retorna uma tupla contendo três elementos: primeiro é o nome da máquina, segundo é uma lista de aliases para o nome do host e terceiro é a lista de endereços IP das interfaces(no meu caso só tenho uma). * `socket.getfqdn([name])`: Isso é usado para encontrar o fully qualified name, se estiver disponível. O fully qualified name consiste em um host e um nome de domínio; Por exemplo, beta pode ser o nome do host, e example.com pode ser o nome do domínio. O **fully qualified domain name(FQDN)** torna-se beta. example.com: ``` >>> socket.getfqdn('facebook.com') 'edge-star-mini6-shv-01-gru2.facebook.com' >>> ``` No exemplo anterior, edge-star-mini6-shv-01-gru2 é o nome do host, e facebook.com é o nome do domínio. No exemplo a seguir, FQDN não está disponível para thapar.edu: ``` >>> socket.getfqdn('thapar.com') 'thapar.com' >>> ``` Se o argumento name estiver em branco, ele retornará o nome da máquina atual: ``` >>> socket.getfqdn() 'gvt.com.br' ``` * `socket.gethostbyaddr(ip_address)`: Isso é como um "reverse" lookup para o nome. Ele retorna uma tupla (hostname, canonical name, and IP_addrlist) onde hostname é o nome do host que responde ao dado ip_address, o canonical name é uma lista (possivelmente vazia) de nomes canônicos do mesmo endereço e IP_addrlist é uma lista de endereços IP para a mesma interface de rede no mesmo host: ``` >>> socket.gethostbyaddr('31.13.85.36') ('edge-star-mini-shv-01-gru2.facebook.com', [], ['31.13.85.36']) >>> >>> socket.gethostbyaddr('119.18.50.66') Traceback (most recent call last): File "<stdin>", line 1, in <module> socket.herror: [Errno 1] Unknown host >>> ``` Ele mostra um erro na última consulta porque o DNS lookup não está presente. * `socket.getservbyname(servicename[, protocol_name])`: Isso converte qualquer protocol name para o número da porta correspondente. O nome do protocolo é opcional, TCP ou UDP. Por exemplo, o serviço DNS usa TCP, bem como conexões UDP. Se o nome do protocolo não for fornecido, qualquer protocolo pode corresponder: ``` >>> socket.getservbyname('http') 80 >>> socket.getservbyname('smtp','tcp') 25 >>> ``` * `socket.getservbyport(port[, protocol_name])`: Isso converte um número de porta de um protocolo para o nome do serviço correspondente. O nome do protocolo é opcional, TCP ou UDP: ``` >>> socket.getservbyport(80) 'http' >>> socket.getservbyport(23) 'telnet' >>> socket.getservbyport(445) 'microsoft-ds' >>> ``` * `socket.connect_ex(address)`: Esse método retorna um indicador de erro. Se obter êxito. Ele `retorna 0`; Caso contrário, ele retorna a variável `errno`. Você pode aproveitar esta função para escanear as portas. Execute o programa `connet_ex.py`: [source,python] ---- import socket rmip ='127.0.0.1' portlist = [22,23,80,912,135,445,20] for port in portlist: sock= socket.socket(socket.AF_INET,socket.SOCK_STREAM) result = sock.connect_ex((rmip,port)) print(port,":", result) sock.close() ---- A saída é mostrada na seguinte imagem: image::http://i.imgur.com/jZgqJNH.png[img7] A saída do programa anterior mostra que somente a porta 22 está aberta. Este é um scanner de porta rudimentar. Caso não encontre portas abertas, execute isso em outro dispositivo com uma grande lista de portas. Desta vez você terá que usar `socket.settimeout(value)`: `socket.getaddrinfo(host, port[, family[, socktype[, proto[, flags]]]])` Este método socket converte os argumentos host e port em uma seqüência de cinco tuplas. Dê uma olhada no exemplo: ``` >>> socket.getaddrinfo('www.thapar.edu', 'http') [(2, 1, 6, '', ('220.227.15.49', 80)), (2, 2, 17, '', ('220.227.15.49', 80))] >>> ``` O 2 representa a família, 1 representa o tipo de socket, 6 representa o protocolo, ' ' representa o canonical name e ('220.227.15.49', 80) representa o endereço dos dois sockets. No entanto, este número é difícil de compreender. Navegue para onde estão seus arquivos de exemplos. Use o código a seguir para obter um resultado mais legível. `getadd1.py`: ``` import socket def get_protnumber(prefix): return dict( (getattr(socket, a), a) for a in dir(socket) if a.startswith(prefix)) proto_fam = get_protnumber('AF_') types = get_protnumber('SOCK_') protocols = get_protnumber('IPPROTO_') for res in socket.getaddrinfo('www.thapar.edu', 'http'): family, socktype, proto, canonname, sockaddr = res print('Family :', proto_fam[family]) print('Type :', types[socktype]) print('Protocol :', protocols[proto]) print('Canonical name :', canonname) print('Socket address :', sockaddr) print('--------------------------------------------') ``` image::http://i.imgur.com/k5Uus10.png[img7] A primeira parte do código faz um dicionário usando `AF_, SOCK_` e `IPPROTO_prefixes` que mapeia o número do protocolo para seus respectivos nomes. Este dicionário é formado pela técnica he list comprehension. O código dentro da função(get_protnumber(prefix)) do código acima pode parecer um pouco confusa, mas podemos executá-la separadamente da seguinte maneira: ``` >>> dict(( getattr(socket,n),n) for n in dir(socket) if 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 ficou mais simples de entender. Esse código é geralmente usado para obter o número do protocolo: `for res in socket.getaddrinfo('www.thapar.edu', 'http'):` A linha de código anterior retorna os cinco valores, conforme discutido na definição. Esses valores são então combinados com seu dicionário correspondente.
  19. 1 point
    A coleta de informações é um dos assuntos mais importantes quando falamos de pentest. Para alcançarmos sucesso em nossa invasão, é necessário temos muitas informações sobre o alvo. Independente de qual informação seja, é necessário, termos o máximo possível. São essas informações que serão responsáveis pelo nosso sucesso, e podemos confirmar isso hackeando o site da sua escola, ou um site ou pessoa qualquer. Tendo isso em mente, eu lhes trago um vídeo lhe ensinando à coletar informações de forma adequada usando a ferramenta Maltego. * VÍDEO DO CANAL: FenixSec. https://youtu.be/oSJCUfEcgT0
This leaderboard is set to Sao Paulo/GMT-03:00


×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.