Jump to content

gnoo

Membros
  • Content Count

    145
  • Joined

  • Last visited

Everything posted by gnoo

  1. Olá @kassane tudo bem, o projeto que tu estás a indicar ele segue precisamente o caminho que eu não quero, eu não quero usar este tipo de utilitários do sistema, e como podemos ver no código do projeto em questão: def set_interface_mac(self, device, mac, port=None): """ Set the device's mac address. Handles shutting down and starting back up interface. """ # turn off device & set mac cmd = "ifconfig {} down hw ether {}".format(device, mac) subprocess.call(cmd.split()) # turn on device cmd = "ifconfig {} up".format(device) subprocess.call(cmd.split()) ele está a criar sub-processos, auxiliado com o programa " ifconfig ", eu quero ir um pouco mais fundo do que isso, aquilo que ele faz, isso eu já sei fazer qualquer das formas obrigado por mostrar esse projeto pode servir para outras coisas, nunca se sabe, tirar uma ideia... @Fernando Mercês obrigado pelas dicas com certeza vão ser muito úteis, na escolha do caminho a seguir, quando tiver pronto eu deixo ai o resultado, mas ainda vai demorar um bocado eu tenho outras prioridades no momento e não tenho cabeça para tudo, mas já vai dar para tentar desenhar uma estratégia de estudo e material a reunir, provavelmente vou ter que cair em cima do código do programa " ip ", para analisar isso melhor. Acho que vai ser interessante ficar a perceber como realmente funciona até para futuras ferramentas ou scripts que possam surgir... a estratégia de usar subprocess do python é um pouco primitivo, temos que refinar um pouco mais isso... Obrigado, abraço.
  2. @fredericopissarra não sei se me fiz entender bem. O que eu quero é fazer um script em C ou em python que altere o endereço MAC, e também não quero usar bibliotecas para executar comando do sistema, na realidade por motivos educacionais quero fazer a alteração do MAC diretamente na memória ( se for essa forma ). No exemplo que tu usaste com programa " ip " onde é que ele está a fazer essa alteração quando executamos o comando mencionado ? quando iniciamos o sistema o endereço que pertence à placa de rede deve ficar numa memória qualquer sem ser alterado, certo? onde? Questões a ponderar são: A alteração desse endereço deve ser feito ( " reescrito " ), na memória? Se deve ser "reescrito" na memória em que memória deve ser feita essa alteração? Se a opção for "reescrever" na memória riscos envolvidos nisso?
  3. Para além das dúvidas deveria ser uma área onde se FALASSE de assembly na área da programação os tópicos ficariam diluidos. Até porque este fórum tem foco na área de engenharia reversa e para mim ( apesar de não perceber nada do assunto ) não me faz muito sentido falar de engenharia reversa sem falar de assembly enrre outras coisas, especialmente quando o foco são iniciantes.
  4. Saudações, Eu queria tentar fazer um "mac changer", e tenho lido algumas coisas que me indicam que o mac poderá ser alterado na eeprom, eprom, talvez... Mas não compreendi muito bem. Alguém sabe como isso é feito na prática?
  5. Saudações, Falta uma área no fórum para conteúdo relacionado com assembly que é a base dos treinamentos do mente binária, e não se está a dar a devida atenção a essa matéria.
  6. Eu também faço o mesmo, não com assembly porque não tenho interesse ( pelo menos por agora ), ter várias fontes de informação é benéfico na maioria das vezes, o ponto de vista que eu quero deixar aqui tem a ver com a falta de objetividade ( na minha opinião ) em relação ao conteúdo que pode ajudar um individuo que queira iniciar ou complementar os seus estudos nessa área. Tópicos deste tipo devem ser pensados para disponibilizar informação de forma objetiva sobre um determinado tema, para fazer um "apanhadão" de assembly um utilizador não precisa vir aqui para encontrar fontes de informação, basta que abrir o seu browser preferido num motor de busca qualquer e fazer uma busca por " livros assembly PDF". Um tópico sobre assembly para ser entendido como um guia através da informação que nele é disponibilizado deve ser pensado de forma a que um iniciante obtenha a informação necessária e repito outra vez OBJETIVA em relação a como iniciar estudos nessa área, tem de haver um guia que seja consensual e prático ( no sentido de entendimento fácil ), para quem obtem essa informação. Exemplos: Como obter informação sobre o nosso processador ? Como escolher a versão ou tipo de assembly a usar mediante o processador que temos na nossa máquina ? Como obter informação sobre arquitetura de de computadores ( ULA, registadores, cache, barramentos, etc), fontes com informação objetiva, de linguagem simples ? Onde ir buscar informação sobre a arquitetura que vamos usar? É isso que uma pessoa que se inicia nesta matéria precisa... eu até acredito que os livros tragam alguma informação nesse sentido, mas será suficiente? não sei talvez ( eu não percebo nada disso)... NOTA: Eu não estou a pôr em causa o conteúdo deste tópico nem a fazer uma depreciação da participação dos seus intervenientes. Eu só acho é que se é para falar, que se fale realmente de assembly... exemplos, conceitos, demonstrações... não me parece que despejar aqui 30 gb de PDF's vá acrescentar alguma coisa.
  7. Eu acho que a solução não seria fazer um "apanhadão" de livros de assembly, mas sim quais são os melhores livros recomendados de forma consensual ( entre aqueles que estudam essa matéria ), ou seja, quais as fontes mais vezes citadas entre a comunidade ( pessoas que REALMENTE têm conhecimento de causa ). Eu também sei que as pessoas aprendem de formas diferente, e em ritmos diferentes, e o material de estudo para uns não é o melhor para outros e que o assembly segundo ouvi dizer "por aqui e por ali", tem varias versões e características diferentes... mas ... Eu há uns tempos também andava atrás de livros de redes feito louco à procura do livro que me iria abrir os olhos para o mundo e iluminar o meu caminho, e essas coisas poéticas que se costuma dizer, mas a realidade é que mesmo de uma forma diferente eles dizem mais ou menos a mesma coisa. Então o que eu fiz foi escolher dois que achei interessantes e comecei a estudar a matéria. Isso de andar à procura de PDF's a olhar o "table of contents" do livro a pensar "é mesmo este, é mesmo este", a ser redireccionado de página para página e os recursos da tua rede a serem utilizados pelo site em que estas a fazer o download não se sabe bem para quê, não é proveitoso em vez de um estudante de assembly passas a ser um caçador de livros profissional, com 10 gb de PDF's no disco e não leste nenhum deles em condições. Eu também já tive o hobby de caçar PDF's eu tenho à vontade uns 15 gb de PDF's que nunca li.
  8. Vocês levam mais tempo à procura de livros do propriamente a estudar a matéria ☺️
  9. 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 desta página: https://tools.ietf.org/html/rfc792 Para complementar a informação da página acima indicada deve ser lido este ou outro livro da especialidade: NOTA: O script em python que aqui é apresentado apenas suporta os seguintes TIPOS de mensagem: TIPO 8 TIPO 0 TIPO 11 SCRIPT COM PYTHON #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii ICMP_TYPE_NUMBERS = {8:'Echo request (8)', 0:'Echo reply (0)', 11:'Time Exceeded (11)'} 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(payload): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", payload[:20]) versao_e_HLEN = tupla_dados_ipv4[0] tamanho_header = (versao_e_HLEN & 15) * 4 versao = versao_e_HLEN >> 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]) dados_ipv4_header = {'Versão':versao,'Tamanho do Header':tamanho_header, 'Tipo de Serviço': tipo_servico, 'Tamanho Pacote':tamanho_total, 'Identificação':identificacao, 'Fragmento':offset_fragmento, 'TTL':tempo_vida_ttl, 'Protocolo':protocolos, 'Checksum':checksum_cabecalho, 'IPv4 Orivgem':ip_origem, 'IPv4 Destino':ip_destino} return dados_ipv4_header, payload[20:] def mensagem_time_exceeded(payload_ipv4): tupla_dados_icmp = struct.unpack("!BBHi", payload_ipv4[:8]) print("Type: {} \nCode: {}\nChecksum: {}\nUnused: {}".format(ICMP_TYPE_NUMBERS[tupla_dados_icmp[0]], \ tupla_dados_icmp[1], tupla_dados_icmp[2], tupla_dados_icmp[3])) header_pacote_ipv4, _ = dados_pacote_ipv4(payload_ipv4[8:29]) print("{}\n".format(header_pacote_ipv4)) def icmp_header(tupla_dados_icmp): print("Type: {} \nCode: {}\nChecksum: {}\nIdentifier (BE): {}\nSequence Number (BE): {}\n".format(ICMP_TYPE_NUMBERS[tupla_dados_icmp[0]], \ tupla_dados_icmp[1], tupla_dados_icmp[2], tupla_dados_icmp[3], tupla_dados_icmp[4])) def dados_pacote_icmp(payload_ipv4): tupla_dados_icmp = struct.unpack("!BBHHH", payload_ipv4[:8]) if tupla_dados_icmp[0] == 8 or tupla_dados_icmp[0] == 0: icmp_header(tupla_dados_icmp) elif tupla_dados_icmp[0] == 11: mensagem_time_exceeded(payload_ipv4) else: pass sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, payload = ethernet_frame(raw_dados) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: dados_ipv4_header, payload_ipv4 = dados_pacote_ipv4(payload) if dados_ipv4_header['Protocolo'] == 1: dados_pacote_icmp(payload_ipv4)
  10. Existe alguém no mundo que ainda use windows ??? Temos que salvar essas pessoas rapidamente... = |
  11. O meu conhecimento de redes também não é grande coisa, mas vai-se aprendendo aos poucos :)
  12. @BrNaka Esse livro para introdução é bom, mas se quiseres um livro um pouco melhor para estudo do TCP / IP tens este:
  13. 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: SCRIPT EM PYTHON #!/usr/bin/env python3 from socket import * import struct import binascii # Faz desempacotamento dados do frame ethernet que nos chegam em formato de bytes def ethernet_frame(raw_dados): mac_destino, mac_fonte, tipo_ethernet = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(tipo_ethernet), raw_dados[14:] # Passa o endereço da função MAC na função ethernet_frame para hexadecimal # Acabando por ser representado numa arquitetura de 6 octetos 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)]) # Extrai dados do header, pacote ARP (Request/ Reply) def header_pacote_arp(payload): (tipo_hardware, tipo_protocolo, tamanho_endereco_hardware, tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest) = struct.unpack("!HHBBH6s4s6s4s", payload) # Dicionário tipo_de_operacao """ Este dicionario indica que tipo de operação é realizada é usado no diconaŕio a seguir(dados_header_arp), onde é passado o valor da variável operacao que é passado como key """ tipo_de_operacao = {1:"(1) Request", 2:'(2) Reply'} dados_header_arp = {'Tipo Hardware':tipo_hardware, 'Tipo Protocolo':htons(tipo_protocolo), 'Tamanho Endereço Hardware':tamanho_endereco_hardware, 'Tamanho Endereço Protocolo':tamanho_endereco_protocolo, 'Operação': tipo_de_operacao[operacao], 'MAC de quem envia': byte_to_hex_mac(mac_sender), 'Ip de quem envia':inet_ntoa(ip_sender), 'MAC de quem recebe': byte_to_hex_mac(mac_dest), 'IP de quem recebe':inet_ntoa(ip_dest)} return dados_header_arp sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, tipo_ethernet, payload = ethernet_frame(raw_dados) if tipo_ethernet == 1544: print("##### HEADER ARP #####") print("\n".join("{}: {}\n".format(key, valor_key) for key, valor_key in header_pacote_arp(payload[:28]).items())) O conteúdo aqui deixado é imprescindível, que seja complementado por informação contida no livro recomendado no início do post. Abraço.
  14. Ao ler estas coisas, cada vez mais me sinto um inepto :) .
  15. @void_ tudo bem ? Queres aprender redes com python é só ir à área de redes aqui no fórum eu tenho feito lá uns posts em relação a isso, e não tens que pagar nada TCP Handshake com python socket [ Parte 1 ] - "O inicio" Raw Sockets python [ Parte 2 ] - "IPv4" - Raw Sockets python [ Parte 3 ] - "TCP" - Raw Sockets python [ Parte 4 ] - "UDP" - Raw Sockets python [ Parte 5 ] - "DNS" - Raw Sockets python Ainda tenho mais conteúdo para colocar ai mas falta um pouco a paciência, mas devagar vou deixando algum conteúdo do meu estudo e faço as referência a fontes de informação.
  16. Sim, eu já tinha visto que o DNS poderia vir em TCP, mas ainda não tinha tido oportunidade de analisar isso, fica a nota obrigado.
  17. 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: A informação disponibilizada sobre DNS retirada do livro acima indicado, vai estar em inglês porque não tenho tempo para estar a fazer tradução, quem tiver dificuldade no inglês tem de ter paciência e fazer a tradução, ou então procurar outra fonte de informação que lhe sirva melhor, este livro é uma boa fonte de informação para quem quer programar para redes, contém informação bastante detalhada das características dos protocolos que nele são abordados. NOTA : O script em python que vos vou deixar aqui deve ser visto como uma fonte de estudo e não uma ferramenta acabada, para aqueles que têm interesse em iniciar o estudo na análise de pacotes ou redes devem pegar neste script no intuito de formar uma estrutura de pensamento e critica analisar o fluxo de dados, e melhorar o que já está feito... montar e desmontar ( mexer no código ). No meu ponto de vista as melhorias a serem feitas no código passa por melhorar a análise de dados efetuada na função decode_label ( em algumas circunstâncias apenas ), uma vez que o número e o fluxo de pacotes UDP que nos chega pode ser elevado, deve ser implementado um queue FIFO (first in, first out), com um sistema de threads, e passa também por melhorar a estrutura de dados. Este script apenas suporta os seguintes tipo de DNS records: A AAA CNAME Se conseguires fazer a análise de dados destes 3 tipos de DNS Records, é muito mais fácil passar aos restantes. O processo de análise de pacotes DNS pode demorar algum tempo até que fique claro como todo o processo se desenrola na sua análise, não conseguir a primeira ou à décima tentativa é normal :P hehehehehehe Já percebemos no tópico anterior que o DNS nos chega em pacotes UDP Apesar de haver quem jure a pés juntos que também se desloca em TCP ( não sei porque nunca vi). Então o DNS vem no payload do UDP a imagem que segue representa o header do DNS Descrição do campos de Header DNS A função para no script que trata os dados header do dns é esta: def dns_header(payload): # Dados do header tupla_dados_header = struct.unpack('!HHHHHH', payload[:12]) ID = tupla_dados_header[0] flags_and_codes = tupla_dados_header[1] question_count = tupla_dados_header[2] answer_record_count = tupla_dados_header[3] authority_record = tupla_dados_header[4] additional_record_count = tupla_dados_header[5] return ID, flags_and_codes, question_count, answer_record_count, authority_record, additional_record_count, payload[12:] ATENÇÃO: Para análise do nome da questão, ou alguns tipos de DNS records tais como CNAME ou SOA, é importante perceber o conceito que segue: Todos os nomes / labels, no campo da questão e nos tipos de DNS records suportados por este script são tratados com a função que segue: def decode_label(payload, inicio_fatiamento, fim_fatiamento): # Vai buscar label à questão label_string = [] len_label = [] #Recebe dados a desde o inicio do header onde é feito o fatiamento até ao inicio do primeiro label objeto_iterador = iter(payload[inicio_fatiamento:fim_fatiamento]) # BYTE representa o valor do tamanho de cada label for BYTE in objeto_iterador: #se BYTE for zero indica o fim do label e termina iteração if BYTE == 0: break #Adiciona o valor de cada label à lista para calcular o tamanho total do label len_label.append(BYTE) #faz um fatiamento nos caracteres do label mediante o valor representado por BYTE #passando para valor do tipo lista adicionando à lista # 46 é o valor ascci que representa um ( . ) para completar o dominio for elemento in list(islice(objeto_iterador, BYTE)) + [46]: label_string.extend(chr(elemento)) # Apanha a o tamanho do dominio para fazer o fatiamento a partir desse tamanho para a frente # O +1 inclui o tamanho do byte zero que indica o fim do label que deve contar também # No tamanho para fazer o fatiamento nome = ''.join(label_string[:-1]) # +1 indica o último byte da compressão do label que é valor 0, este byte também conta no tamanho do label soma_tamanho_label = sum(len_label) + len(len_label) + 1 tamanho_nome = len(''.join(label_string[:-1])) return nome, soma_tamanho_label, tamanho_nome, label_string, len(len_label) Atenção: DNS pode conter múltiplas respostas No tratamento das respostas, no caso de serem duas ou mais passou por ser feito um fatiamento no bytearray, o tamanho do fatiamento feito com base no soma dos campos que formam a resposta somando o valor do Resource Data Lenght,e adicionando a uma lista até que o valor do tamanho do bytearray seja zero, pode ser visto neste ciclo de repetição while while len(resposta) != 0: Type, Class, _ ,TTL, R_d_len = struct.unpack("!HH2HH", resposta[2:12]) tamanho = 12 + R_d_len LISTA_DNS_RECORDS.append(resposta[:tamanho]) resposta = resposta[tamanho:] SCRIPT COMPLETO EM PYTHON #coding:utf-8 #!/usr/bin/env python3 from socket import * import binascii import struct from itertools import islice 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]) tamanho_header_bytes = (versao & 15) * 4 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_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:] def dns_header(payload): # Dados do header tupla_dados_header = struct.unpack('!HHHHHH', payload[:12]) ID = tupla_dados_header[0] flags_and_codes = tupla_dados_header[1] question_count = tupla_dados_header[2] answer_record_count = tupla_dados_header[3] authority_record = tupla_dados_header[4] additional_record_count = tupla_dados_header[5] return ID, flags_and_codes, question_count, answer_record_count, authority_record, additional_record_count, payload[12:] def decode_label(payload, inicio_fatiamento, fim_fatiamento): # Vai buscar label à questão label_string = [] len_label = [] #Recebe dados a desde o inicio do header onde é feito o fatiamento até ao inicio do primeiro label objeto_iterador = iter(payload[inicio_fatiamento:fim_fatiamento]) # BYTE representa o valor do tamanho de cada label for BYTE in objeto_iterador: #se BYTE for zero indica o fim do label e termina iteração if BYTE == 0: break #Adiciona o valor de cada label à lista para calcular o tamanho total do label len_label.append(BYTE) #faz um fatiamento nos caracteres do label mediante o valor representado por BYTE #passando para valor do tipo lista adicionando à lista # 46 é o valor ascci que representa um ( . ) para completar o dominio for elemento in list(islice(objeto_iterador, BYTE)) + [46]: label_string.extend(chr(elemento)) # Apanha a o tamanho do dominio para fazer o fatiamento a partir desse tamanho para a frente # O +1 inclui o tamanho do byte zero que indica o fim do label que deve contar também # No tamanho para fazer o fatiamento nome = ''.join(label_string[:-1]) # +1 indica o último byte da compressão do label que é valor 0, este byte também conta no tamanho do label soma_tamanho_label = sum(len_label) + len(len_label) + 1 tamanho_nome = len(''.join(label_string[:-1])) return nome, soma_tamanho_label, tamanho_nome, label_string, len(len_label) def testa_ponteiro(fatiamento): # Analisa os dois últimos bytes da resposta se o plenultimo byte for 192 # é ponteiro, inicia fatiamneto do resto do nome CNAME PTR, offset = struct.unpack("!BB", fatiamento) return PTR, offset def dns_record_tipo_A(*args): recebe_resposta_A = d_record Type, Class, _ ,TTL, R_d_len, IPv4 = struct.unpack("!HH2HH4s", recebe_resposta_A[2:16]) print("Type: {}, Class: {}, TTL: {}, Resource_data_lenght: {}, IPv4: {}".format(Type, Class, TTL, R_d_len, inet_ntop(AF_INET, IPv4))) def dns_record_tipo_CNAME(*args): """ A variável payload carrega o buffer completo / DNS HEADER / QUESTÃO / RESPOSTA É utilizado para fatiamento com Ponteiro & offset... O Offset começa a contar a partir do campo ID do HEADER iniciando a contagem no primeiro byte com valor 0 (zero). """ recebe_payload = payload """ Recebe buffer com respostas após fatiamento... o fatiamento é feito com valores da soma total de label's QUESTÃO + 4 bytes do type e class também da QUESTÃO """ recebe_resposta_CNAME = d_record PTR, offset, Type, Class, _ ,TTL, R_d_len = struct.unpack("!BBHH2HH", recebe_resposta_CNAME[:12]) CNAME = recebe_resposta_CNAME[12:] if R_d_len > 2: join_nome_nome2 = [] nome, _, _, _, _ = decode_label(CNAME,inicio_fatiamento = 0, fim_fatiamento = None) # Analisa os dois últimos bytes da resposta se o plenultimo byte for 192 # é ponteiro, inicia fatiamneto do resto do nome CNAME PTR_CNAME, offset_CNAME = testa_ponteiro(CNAME[-2:]) if PTR_CNAME == 192: nome2, _ , _ , _ , _ = decode_label(payload,inicio_fatiamento = offset_CNAME, fim_fatiamento = None) join_nome_nome2.append(nome[:-1]) join_nome_nome2.append(nome2) print("Type: {}, Class: {}, TTL: {}, Resource_data_lenght: {}, CNAME: {}".format(Type, Class, TTL, R_d_len, "".join(join_nome_nome2))) else: print("Type: {}, Class: {}, TTL: {}, Resource_data_lenght: {}, CNAME: {}".format(Type, Class, TTL, R_d_len, nome)) elif R_d_len == 2: PTR_CNAME, offset_CNAME = testa_ponteiro(CNAME[-2:]) if PTR_CNAME == 192: nome, _ , _ , _ , _ = decode_label(payload,inicio_fatiamento = offset_CNAME, fim_fatiamento = None) print("Type: {}, Class: {}, TTL: {}, Resource_data_lenght: {}, CNAME: {}".format(Type, Class, TTL, R_d_len, nome)) def dns_record_tipo_AAA(*args): recebe_resposta_AAA = d_record Type, Class, _ ,TTL, R_d_len, IPv6 = struct.unpack("!HH2HH16s", recebe_resposta_AAA[2:28]) print("Type: {}, Class: {}, TTL: {}, Resource_data_lenght: {}, IPv6: {}".format(Type, Class, TTL, R_d_len,inet_ntop(AF_INET6, IPv6))) # As funções contidas neste dicionário são chamadas por referência chamada_funcao = { 1: dns_record_tipo_A, 5: dns_record_tipo_CNAME, 28: dns_record_tipo_AAA} # Esta tupla contém os tipos de DNS records suportados neste script DNS_record_suportado = (1, 5, 28) sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, type_ethernet, payload = ethernet_frame(raw_dados) # tipo de frame # Se for 8 vem ai pacote IP \0/ if type_ethernet == 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, payload ) = dados_pacote_ipv4(payload) # número protocolo # Se for 17 vem ai pacote UDP \0/ if protocolos == 17: porta_fonte, porta_destino, udp_len, udp_checksum, payload = dados_pacote_udp(payload) ID, flags_and_codes, question_count, answer_record_count, authority_record, additional_record_count, payload_12bytes_frente = dns_header(payload) if porta_fonte == 53 or porta_destino == 53: if question_count == 1 and answer_record_count == 0: print("-------- HEADER DNS --------") print("Identifier : {}".format(ID)) print("Flags & Codes : {}".format(flags_and_codes)) print("Question Count : {}".format(question_count)) print("Answer Record Count : {}".format(answer_record_count)) print("Authority Record : {}".format(authority_record)) print("Additional Record Count : {}\n".format(additional_record_count)) print("-------- QUESTÃO (dominio) --------") nome, soma_tamanho_label, tamanho_nome, label_string, len_label = decode_label(payload_12bytes_frente, inicio_fatiamento = 0, fim_fatiamento = None) tipo_class_questao = payload_12bytes_frente[soma_tamanho_label:] Type, Class = struct.unpack("!HH", tipo_class_questao[:4]) print("Nome Questão : {}".format(nome)) print("Tamanho do nome : {}".format(tamanho_nome)) print("Quantidade de Label's : {}".format(len_label)) print("Tipo (host address) : {}".format(Type)) print("Class : {}\n\n".format(Class)) print("################################################################################") elif question_count == 1 and answer_record_count >= 1: print("-------- HEADER DNS --------") print("Identifier : {}".format(ID)) print("Flags & Codes : {}".format(flags_and_codes)) print("Question Count : {}".format(question_count)) print("Answer Record Count : {}".format(answer_record_count)) print("Authority Record : {}".format(authority_record)) print("Additional Record Count : {}\n".format(additional_record_count)) print("-------- RESPOSTA (DNS RECORDS) --------") nome, soma_tamanho_label, tamanho_nome, label_string, len_label = decode_label(payload_12bytes_frente, inicio_fatiamento = 0, fim_fatiamento = None) print("Nome Questão : {}".format(nome)) print("Tamanho do nome : {}".format(tamanho_nome)) print("Quantidade de Label's : {}\n".format(len_label)) """ LISTA_DNS_RECORDS recebe multiplas respostas ( DNS Records ) encontradas no ciclo de repetição while que segue o buffer da resposta pode conter multiplas respostas, essas respostas ( DNS Records ) podem ser de varios tipos diferentes """ LISTA_DNS_RECORDS = [] # +4 inidica / soma o número de bytes do tipo e class da questão resposta = payload_12bytes_frente[soma_tamanho_label + 4:] while len(resposta) != 0: Type, Class, _ ,TTL, R_d_len = struct.unpack("!HH2HH", resposta[2:12]) tamanho = 12 + R_d_len LISTA_DNS_RECORDS.append(resposta[:tamanho]) resposta = resposta[tamanho:] for d_record in LISTA_DNS_RECORDS: ponteiro, offset, Type = struct.unpack("!BBH",d_record[:4]) if ponteiro == 192 and Type in DNS_record_suportado: #----- Argumentos que passam na chamada de função ----------- # payload_12bytes_frente : contém Questão e Respostas ( DNS Records ) # payload : Contém DNS Headers / Questão / Respostas ( DNS Records ) # d_record : Contém apenas Respostas ( DNS Records ) chamada_funcao[Type](d_record, payload_12bytes_frente, payload) print("##############################################################################") else: pass Resultados do script anterior O conteúdo aqui deixado é imprescindível, que seja complementado por informação contida no livro recomendado no início do post Abraço.
  18. Saudações, há uns tempos atrás andava à procura de uma aplicação para organizar o meu material de estudo e encontrei uma aplicação chamada polar-bookshelf, estou tão contente com ela que decidi recomendar porque sei que tal como eu também há por ai muito maluco da cabeça com 20 GB de pdf ( se não mais ), e sei como é foda organizar um espólio com essa grandeza. Eu vou enumerar algumas das funcionalidades da aplicação mas o melhor é mesmo visitar a página do projeto no GitHub no link que vou deixar no final para ficar a conhecer melhor esta aplicação. Com o polar-bookshelf podemos sublinhar texto no pdf adicionar comentários ao texto sublinhado, ainda podemos adicionar imagens aos comentários, podemos ter vários PDF's a ser utilizados, e o mais interessante de tudo é que podemos guardar esses PDF's em "nuvem" e transferir para outro computador se necessário apenas basta fazer login com uma conta do google, por enquanto o alojamento do ficheiros é grátis e segundo eles pretende continuar a ser, sendo pago apenas para quem quiser alojar grandes quantidades de dados no servidor, vamos ver onde isto vai dar o projeto é recente. NOTA : Outra funcionalidade interessante da aplicação é que podemos baixar uma pagina Web guarda-la e ver offline, que também é possivel guardar em "nuvem". Só coisas boas... Projeto https://github.com/burtonator/polar-bookshelf https://getpolarized.io/ https://getpolarized.io/docs/ abraço.
  19. Saudações, na data em que escrevo reparei que o canal Papo Binário, tem uma nova empresa que está a apoiar e a patrocinar o canal ( ainda bem espero que venham mais ) A questão é a seguinte.... Quem é a Spod ? Que serviços essa empresa presta? E onde a posso encontrar? E quais os benefícios dos serviços prestados por esta empresa aos seus utilizadores? Eu acho que no inicio do video de cada curso, devia ter um pequeno video com duração entre 5 a 10 segundos, a mostrar o site da empresa, produtos da empresa, e um pequeno texto publicitário descrito através de áudio com uma voz sensual :p, sobre sobre a empresa onde é referido os serviços por ela prestados e onde pode ser encontrada online e como podemos adquirir os seus serviços. Na parte da descrição dos videos dos cursos não tem nenhum link para o site da empresa nem como podemos contacta-la, pior que isso é o facto de que empresas que atualmente não fazem qualquer apoio ao canal ( peço desculpa se estou enganado ), como é o caso da Empresa Tempest, e da Empresa Clávis, mais uma vez eu não tenho a certeza do que estou a dizer, mas uma vez que essas empresas não aparecem nos videos leva-me a pensar isso, Contudo essas empresas continuam a ser referidas na descrição dos videos do "curso" exploração de binários, Excepto a empresa Spod que atualmente patrocina o mente binária, não existe qualquer contacto desta empresa nas descrições dos videos, na data em que escrevo. Seria interessante a administração fazer os seus spots publicitários de uma forma mais profissional, sendo benéfico para futuras parcerias na altura de negociar patrocínios. Abraço.
  20. Saudações, decidi fazer esta critica que espero seja compreendida como construtiva, no sentido de fazer um reparo em relação à versão do python que é utilizada para fazer conteúdo para o mente binária / Papo binário. Antes de mais temos que perceber que o python 2.7 ficou com suporte apenas por questões de portabilidade de bibliotecas de que muitos projetos estavam dependentes até que fosse dado suporte para o python na vesão 3.x, python 2.7 não é para produção de novo conteúdo ( mesmo que seja apenas alguns scripts ). Vou dar o exemplo do "Curso" exploração de binários em que os scripts com python estão a ser feitos com python 2.7 ( pelo menos dos videos que vi ), eu não estou a dizer que o conteúdo não bom antes pelo contrário, o que eu quero dizer é que o python na versão 2.7 daqui a uns 6 meses deixa de ter suporte, como pode ser visto aqui, então a pessoa que iniciar o "curso" deixa de poder seguir aquele passo a passo para o resultado seja idêntico ao do curso, é óbvio que os "cursos" deixam de ser compatíveis com as versões da linguagens, mas a questão é que o curso em si apenas tem 4 ou 5 meses, devia ter sido tido em conta que a versão da linguagem utilizada tivesse um maior período de tempo no suporte dado. abraço.
×
×
  • Create New...