Jump to content

All Activity

This stream auto-updates     

  1. Today
  2. @Leandro Fróes blz, tudo bem mano, obg assim msm ^^
  3. PS; É claro... se quiser adicionar elementos no final da lista: void addtail( list_T *lstp, void *elemp ) { node_T *p = elemp; // esse será o último elemento! p->next = NULL; if ( ! lstp->tail ) // lista vazia? { lstp->head = lstp->tail = p; return; } // ajusta o nó tail atual para o novo nó. lstp->tail->next = p; lstp->tail = p; }
  4. A turma da OOP acredita que lidar com coisas como polimorfismo é impossível em linguagens "estruturadas". Eis um exemplo de como fazer uma lista de encadeamento simples, em C, com elementos de diversos "tipos"... Considere a palavra-reservada struct: Ela existe para juntar vários tipos em um único container e de forma ordenada. Assim, se definirmos um nó genérico como: typedef struct node_s { struct node_s *next; } node_T; // _T porque _t não deve ser usado! Podemos definir uma estrutura de controle para uma lista como: // Usado para inicializar uma estrutura de lista vazia. #define EMPTY_LIST { NULL, NULL } typedef struct list_s { node_T *head, *tail; } list_T; Podemos agora usar a regra de que todo elemento que será colocado nessa lista deve definir, primeiro, um ponteiro do tipo node_T que aponte para o próximo item da lista... Por exemplo, suponha que eu queira criar uma lista de vetores 3D (x,y,z). Posso definir os elementos como: struct vec3d_element_s { node_T *next; // isso TEM que estar aqui! // nosso vetor: double x, y, z; }; Eis uma rotina que adiciona elementos no início de uma lista: // note que elemp é ponteiro para void, aceita qualquer ponteiro! void addhead( list_T *lstp, void *elemp ) { node_T *p = elemp; p->next = lstp->head; lstp->head = p; // o elemento é a nova 'cabeça' da lista. // Se a lista estiver previamente vazia, temos um novo 'rabo'. if ( ! lstp->tail ) lstp->tail = p; } Note que, junto com a definição da estrutura de lista, defini um macro EMPTY_LIST. Isso permite o seguinte uso: // define uma lista vazia. list_T list = EMPTY_LIST; struct vec3d_element_s *elemp; // ponteiro para nosso novo elemento. elemp = malloc( sizeof *elemp ); // aloca elemento. elemp->x = 0.0; // inicializa dados do elemento. elemp->y = 1.0; elemp->z = sqrt(2.0); // adiciona elemento na lista: addhead( &list, elemp ); Note que nossa lista aceita QUALQUER estrutura que tenha, como seu primeiro membro, um ponteiro para node_T nomeado de next. Poderíamos fazer algo assim: enum vec_type { V2D, V3D, V4D }; struct vec_element_s { node_T *next; enum vec_type vtype; double v[0]; // yep... tamanho 0! }; ... list_T list = EMPTY_LIST; ... // Aloca vetor 2D, inicializa-o e coloca na lista: struct vec_element_s *v2d; v2d = malloc( sizeof *v2d + 2*sizeof( double ) ); v2d->vtype = V2D; v2d->v[0] = 1.0; v2d->v[1] = 2.0; addhead( &list, v2d ); // Aloca vetor 3D, inicializa-o e coloca na lista. struct vec_element_s *v3d; v3d = malloc( sizeof *v3d + 3*sizeof( double ) ); v3d->vtype = V3D; v3d->v[0] = 1.0; v3d->v[1] = 2.0; v3d->v[1] = 3.0; addhead( &list, v2d ); // percorre a lista e faz algo com os elementos: node_T *p; p = list.head; while ( p ) { doSomething( p ); p = p->next; } Na hora de percorrer a lista podemos usar o membro vtype para dedicir o tamanho do array v. Mas, note que a lista não se importa com o tipo do elemento, desde que ele tenha o ponteiro next como primeiro item.
  5. @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.
  6. https://bookauthority.org/books/new-networking-books E aí, concordam com a lista acima? Confesso que muitos títulos me chamaram a atenção, mas antes de fazer algum movimento imprudente ($$), gostaria de ouvir alguma opinião de alguém que possa ter tido a oportunidade de ter comprado, lido, analisado, etc., um ou mais dos títulos da lista. Se alguém puder fornecer algum pdf, mesmo que seja prévia, também serei grato. P.S: Os livros de C e Python particularmente me interessaram...
  7. @Fernando Mercês, muito obrigado pela resposta, me ajudou muito. Meu TCC será sobre engenharia reversa como técnica de forense computacional.
  8. Yesterday
  9. Obrigado Mercês, Ajudou muito. Paulo Fegueredo
  10. Bem, parte do código do DIE é fechado então teria que fazer reversa nele pra entender tudo, mas qualquer software p/ ER a gente recomenda rodar em máquina virtual mesmo, não na sua real, por vários motivos, entre eles essa desconfiança, que é cabível mesmo. Dito isso, não acredito que seja malicioso, mas não posso garantir. O histórico de detecção de "ferramentas hacker" por softwares antivírus é antigo, dadas as características destas ferramentas. Desculpe o post inconclusivo, mas não vejo maneira simples/rápida de garantir isso. Abraço!
  11. O Tor Browser, navegador criado pelo Tor Project para oferecer aos usuários acesso privado à Internet, chegou à versão beta no mundo móvel e está disponível para Android na Google Play em um lançamento estável. O Tor Browser 8.5 está disponível para download com importantes atualizações de segurança para o Firefox. A versão alfa do navegador foi lançada em setembro do ano passado, e desde então o Tor Project vem fazendo melhorias para priorizar usuários que sofrem muita vigilância e censura online, como ativistas ou jornalistas que precisam evitar o monitoramento do governo. O Tor Browser é baseado no Firefox, contendo as mesmas conveniências do navegador, como a navegação com guias, mas não se conecta diretamente a sites. Segundo o Engadget, ele usa uma rede de servidores criptografados que envia solicitações em vários links intermediários, ocultando seu endereço IP e identidade. O navegador não está disponível para o sistema iOS, por conta de restrições da Apple, mas o Tor recomenda o uso do Onion Browser para usuários de iPhone e iPad.
  12. Olá pessoal, Estou iniciando meus estudos em Analise de Malware, usando o curso CERO do Fernando Mercês como guia inicial. Baixei diretamente do site do fabricante o software para analise de executáveis Detect It Easy, e antes de executá-lo, submeti o DIE ao virus total. Pelo menos 6 engines detectaram o artefato como dropers/trojan. Alguém passou por essa experiencia com o DIE? Chegaram a analisa-lo para confirmar se está limpo? Fiquei com receio de executá-lo.
  13. Oi @R3n4to! Boa pergunta. Eu não sou especialista em forense, mas não considero uma sub-área, no entanto, engenharia reversa é uma técnica a ser aplicada em certas áreas e sem dúvida forense é uma delas, uma vez que ao analisar ambientes digitais, podem ser encontrados binários que precisão ser entendidos e normalmente o código-fonte não estará disponível. Por exemplo, ao analisar a memória ou disco de um servidor que foi comprometido, é possível encontrar um processo em execução ou binário em disco que seja considerado suspeito. O próximo passo do profissional de forense pode ser analisar tal processo/binário. Ele pode fazer isso por conta própria ou, caso conte com uma equipe, passar o trabalho para um engenheiro reverso. 😉 Grande abraço!
  14. Last week
  15. A análise forense consiste em analisar ambientes digitais (sistemas, hardwares, softwares e mídias) a fim de detectar fraudes ou fragilidades e levantar evidências que possam servir como provas de possíveis crimes. Dentro do processe de forense computacional, existe muitas técnicas. A engenharia reversa é uma dessas técnicas? É correto pensar que a engenharia reversa é um subgrupo da computação forense? Gostaria de saber mais sobre a relação Engenharia Reversa e Computação Forense.
  16. Uma variante do malware Mirai, identificada como Backdoor.Linux.MIRAI.VWIPT, foi detectada pela Trend Micro. De acordo com comunicado divulgado hoje pela companhia de segurança, a nova versão do malware, que infecta roteadores, usa 13 exploits diferentes, quase todas já utilizadas nos ataques anteriores do Mirai. Variantes típicas do Mirai possuem backdoors e capacidades para ataques distribuídos de negação de serviço (DDoS). Todavia, este caso surge como a primeira vez que uma variante usa 13 exploits juntos numa única campanha. O novo ataque ocorre apenas algumas semanas após a Trend Micro ter relatado as últimas atividades do Mirai, que afetaram diversos roteadores. Vários exploits do ataque anterior também foram usados nessa variante. O malware usou diferentes meios de propagação e também revelou o uso de três chaves XOR para criptografar dados. A companhia também identificou diferentes URLs usadas por esta variante, sendo que a primeira serviu como um servidor de comando e controle (C&C), enquanto as outras eram links de download e dropper. A Trend Micro identificou ainda como a variante se espalha. Os três primeiros exploits são scanners de vulnerabilidades específicas encontradas no framework de desenvolvimento web ThinkPHP e em alguns roteadores Huawei e Linksys. Os scanners para as outras 10 vulnerabilidades foram encontradas dentro da função exploit_worker(). A companhia divulgou uma lista dos exploits e outros ataques, sendo que 11 deles já haviam sido usados em 2018 pela variante Omni. Também foi publicada uma lista com URLs maliciosas relacionadas aos ataques.
  17. until
    Dia 02/04/2019 (terça) tivemos o lançamento oficial do Visual Studio 2019, com o anúncio de inúmeras novidades envolvendo o desenvolvimento de soluções baseadas em tecnologias como Azure DevOps, .NET Core, ASP.NET Core, C# e PowerShell. Assim como aconteceu em outras ocasiões, a Microsoft novamente fará uma parceria com comunidades técnicas através da realização de eventos locais. O DevOps Professionals em conjunto com a FC Nuvem também participa desta iniciativa, com um EVENTO PRESENCIAL e GRATUITO Programação prevista (grade sujeita a alterações): - Novos Recursos para Debugging no Visual Studio 2019 + Suporte a Docker no .NET Core 3.0 - Renato Groffe (Microsoft MVP) - Dicas e truques com Azure e Azure DevOps no Visual Studio 2019 - Vinicius Moura (Microsoft MVP) - Colaboração Contínua com o Visual Studio Live Share - Milton Câmara Gomes (Microsoft MVP) - Indo além de ambientes Windows com PowerShell Core, Linux e Visual Studio Code - Ewerton Jordão (.NET SP, SampaDevs) Acompanhe e apoie esta iniciativa, divulgando e indicando o Visual Studio 2019 Launch para amigos e colegas de trabalho! Mais informações: https://www.sympla.com.br/visual-studio-2019---lancamento---devops-professionals--fc-nuvem__525409
  18. Pra quem acompanhou a saga, graças a ajuda do @rcimatti consegui entender os pontos que faltavam pra retornar a informação que eu precisava!! Caso tenham duvida neste desafio, contem comigo pra ajudar!!! Abraço!!
  19. Uma base de dados com informações de contatos de milhões de influenciadores no Instagram, celebridades e marcas foi encontrada na Internet. Segundo o site TechCrunch, a base de dados, que é hospedada pela Amazon Web Services, foi exposta sem senha, permitindo a qualquer pessoa o acesso às informações. Foram cerca de 49 milhões de registros vazados que, segundo o TechCrunch, aumentavam a cada hora. 😬 Cada registro continha dados públicos extraídos de contas de influenciadores do Instagram, incluindo a biografia, foto do perfil, número de seguidores, se eles são verificados e a localização por cidade e país. Além disso, também foram divulgadas informações privadas, como o endereço de e-mail e o número de telefone do proprietário da conta do Instagram. O TechCrunch disse ainda que rastreou a origem da base de dados. É de uma empresa localizada em Mumbai chamada Chtrbox, que paga influenciadores para publicar conteúdo patrocinado em suas contas. Cada conta continha informações sobre o valor daquele perfil com base em número de seguidores, engajamento, alcance, likes e compartilhamentos. A métrica é utilizada para determinar quando a companhia poderia pagar uma celebridade ou influenciador para publicar um anúncio. A Chtrbox já desativou o acesso ao banco de dados. Procurada pelo TechCrunch, a empresa não respondeu ao pedido de comentários e a várias perguntas, incluindo como obteve endereços de e-mail e números de telefone privados de contas do Instagram. O caso ocorre dois anos depois o Instagram admitir que um bug de segurança na API de desenvolvimento permitiu que atacantes obtivessem endereços de e-mail e números de telefone de seis milhões de contas do Instagram. Os invasores venderam os dados em troca de bitcoins. O Facebook, dono do Instagram, enviou comunicado ao TechCrunch informando que está analisando a questão para entender se os dados descritos, incluindo e-mail e números de telefone, são do Instagram ou de outras fontes. "Também estamos questionando a Chtrbox para entender de onde esses dados vieram e como se tornaram disponíveis publicamente", acrescentou.
  20. Costumam manter essa página atualizada: https://en.wikipedia.org/wiki/Public_recursive_name_server
  21. Muito bom os artigos!!!! Realmente fica quase impossível adivinhar esses números diante de tantas possíveis combinações.
  22. A Ticketmaster está introduzindo o sistema SafeTix para proteger seus ingressos e evitar fraudes. O sistema dá ao comprador um código de barras único e criptografado que é atualizado a cada segundo. De acordo com o site SportBusiness, o sistema está pronto para ser usado em 500 locais até o final deste ano, sendo que sua implantação ocorrerá na temporada de 2019 da NFL (National Football League). O ingresso "mutante", com atualização contínua de códigos de barras criptografados, foi projetado para combater fraudes que ocorrem por meio do famoso print screen, ou seja, as capturas de tela ou outras cópias de códigos de barras estáticos. Toda vez que um ingresso for vendido ou transferido, um novo ingresso digital será emitido e vinculado à conta e ao telefone celular do destinatário, com um processo contínuo de atualização do código de barras. O plano da Ticketmaster é expandir o novo ingresso para shows de diversos artistas e introduzir a tecnologia near-field communications (NFC), conjunto de protocolos de comunicação que permite que dois dispositivos eletrônicos estabeleçam comunicação a 4cm de distância um do outro. Futuramente, o ingresso também poderá ser escaneado via Apple Wallet.
  23. 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.
  24. Um aviso: nameservers retornam a resposta em pacotes TCP se essa for maior que um determinado tamanho (ajustado no bind). A requisição da consulta pode e deve ser feita por UDP, mas a resposta pode ser UDP ou TCP, dependendo do tamanho... Exemplo: O google retorna resposta em UDP para consultas de até 512 bytes: $ dig @8.8.8.8 www.google.com ; <<>> DiG 9.11.3-1ubuntu1.7-Ubuntu <<>> @8.8.8.8 www.google.com ; (1 server found) ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10492 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags:; udp: 512 ;; QUESTION SECTION: ;www.google.com. IN A ;; ANSWER SECTION: www.google.com. 129 IN A 172.217.29.36 ;; Query time: 42 msec ;; SERVER: 8.8.8.8#53(8.8.8.8) ;; WHEN: Mon May 20 22:36:39 -03 2019 ;; MSG SIZE rcvd: 59 Note o comentário EDNS, acima... Já o cloudflare retorna em UDP pacotes com até 1452 bytes: $ dig @1.0.0.1 www.google.com ; <<>> DiG 9.11.3-1ubuntu1.7-Ubuntu <<>> @1.0.0.1 www.google.com ; (1 server found) ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 36721 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags:; udp: 1452 ;; QUESTION SECTION: ;www.google.com. IN A ;; ANSWER SECTION: www.google.com. 41 IN A 216.58.202.164 ;; Query time: 38 msec ;; SERVER: 1.0.0.1#53(1.0.0.1) ;; WHEN: Mon May 20 22:38:46 -03 2019 ;; MSG SIZE rcvd: 59 O "default" do bind é 4096 bytes. Quando o nameserver recursivo retorna respostas tão grandes? Quando existem muitos nomes associados à resposta! Um exemplo é o google.com, se pedirmos qualquer registro: $ dig +noall +answer www.google.com any www.google.com. 288 IN AAAA 2800:3f0:4001:814::2004 www.google.com. 161 IN A 172.217.29.228 Aqui só tem 2, mas poderiam ter vários registros A, vários AAAA, vários CNAMEs, ... consultas que também retornam a autoridade, e adicionais.
  25. 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.
  26. O Stack Overflow, famoso site de perguntas e repostas para programadores, informou que está investigando ataques ocorridos desde o dia 5 de maio em uma camada de desenvolvimento do site (stackoverflow.com). De acordo com comunicado divulgado pela VP de Engenharia do Stack Overflow, Mary Ferguson, o bug permitiu ao atacante entrar na camada de desenvolvimento do site e estender seu acesso à versão de produção do stackoverflow.com. Entre os dias 5 e 11 de maio, o invasor se manteve escondido, moderando suas atividades de invasão. A partir do dia 11 de maio, contudo, o atacante fez uma modificação no sistema do Stack Overflow, conseguindo acesso privilegiado no ambiente de produção, o que foi rapidamente identificado pela equipe do site. "Nós revogamos o acesso do invasor em toda nossa rede, começamos a investigar o ataque e demos os primeiros passos para remediar o problema", diz o comunicado. Como procedimento de segurança do site para proteger dados confidenciais de clientes, o Stack Overflow mantém infraestrutura de redes separadas para clientes dos produtos Teams, Business e Enterprise. "Não encontramos nenhuma evidência que esses sistemas e dados de clientes foram acessados". O site diz ainda que as áreas de Advertising e Talent também não foram afetadas. Embora o banco de dados não tenha sido comprometido, o site alerta que foram identificadas requisições web do invasor que podem ter retornado endereços IP, nomes ou e-mails de cerca de 250 usuários da rede pública do Stack Exchange. Os usuários afetados serão notificados.
  27. Earlier
  28. Estamos a procura de desenvolvedor(a) de software para atuar na comunidade open source em uma empresa de Floripa. As principais atividades que você desenvolverá são: – Desenvolver programas em C e C++ open source, sob demanda. Diferencial: – JavaScript; – C#; – Conhecimento em Enlightenment Foundation Libraries. Os requisitos necessários para você desempenhar suas atividades são: – Experiência de pelo menos dois anos com C e C++. Sua jornada de trabalho será em horário comercial, de segunda à sexta-feira. Além da remuneração fixa oferecem benefícios como va, vt, plano de saúde e plano odontológico. Se identificou com a oportunidade? Prepare um cv bem caprichado e encaminhe para nossa equipe de triagem 🙂 Contato: cvbanco em peopleti.com.br
  1. Load more activity
×
×
  • Create New...