Jump to content

All Activity

This stream auto-updates     

  1. Today
  2. Muito bom os artigos!!!! Realmente fica quase impossível adivinhar esses números diante de tantas possíveis combinações.
  3. 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.
  4. 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.
  5. 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.
  6. Yesterday
  7. 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_de_respostas 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.
  8. 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.
  9. Last week
  10. 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
  11. Não quer gastar mais dinheiro que o necessário (pizza é cara, hoje em dia!)? Quer comer a maior quantidade de pizza possível? Preste atenção nisso: https://bitismyth.wordpress.com/2017/09/25/o-problema-das-pizzas-ou-o-problema-da-ignorancia-da-matematica-elementar/
  12. Um artiguinho meu (e o follow up mostrando como montei o gráfico animado) - escritos em Agosto de 2017: https://bitismyth.wordpress.com/2017/08/23/estatisticamente-insignificante/ https://bitismyth.wordpress.com/2017/08/25/o-grafico-animado-dos-sorteios-howto/
  13. Obrigado, maninho! Eu não sei, mas é muito difícil eu largar tecnologia. Eu, na verdade, não queira entrar em faculdade e só vou fazer isso por pressão dos meus pais, pois enquanto existir internet eu vou estar estudando sem problema algum.
  14. Obrigado por sua opinião, cara! Me identifiquei um pouco com você, pois minha vida e historia na TI foi realmente um bagunça. Eu comecei a programar com os 13 anos e naquela tempo eu queria ser tipo um Mark Zuckerberg brasileiro (que vergonha kkk), porque queria criar uma rede social, mas hoje estou estudando Engenharia Reversa e, realmente, to gostando muito.
  15. Pessoal, desenvolvi recentemente 2 programas em C para gerar e filtrar números/combinações numéricas das loterias Dupla Sena e Lotofácil (eles podem ser adaptados facilmente para outros tipos de concursos, por exemplo). Gostaria de um feedback de vocês pois não sei se fiz da melhor forma possível. Achei a leitura do arquivo texto contendo as combinações um pouco lenta. Enfim... todas as críticas são bem-vindas pois tenho certeza que poderia ter feito ele de outra maneira mais otimizada. https://github.com/fabianofurtado/random-lottery-numbers Há, basicamente, duas formas de vocês o utilizarem: 1) Através de um arquivo texto contendo as combinações (pode ser gerada no random.org) 2) Através do parâmetro -n onde o sistema utilizará as funções srand() e rand() da libc. Valeu!
  16. Pesquisadores estão identificando um ataque remoto que pode, potencialmente, permitir uma invasão ao roteador Cisco 1001-X e comprometer dados e comandos que passam por ele. O problema é que esse roteador não é um roteador comum, que as pessoas costumam ter em casa. É muito maior e mais caro, responsável pela conectividade confiável de bolsas de valores, escritórios corporativos, shoppings, entre outros, tendo assim um papel importante em instituições, incluindo aquelas que lidam com dados hipersensíveis. De acordo com o site de notícias Wired, a empresa de segurança Red Balloon identificou duas vulnerabilidades. Uma é um bug no sistema operacional IOS da Cisco que permite ao atacante obter acesso remoto aos dispositivos. Essa falha pode ser relativamente fácil de ser resolvida através da aplicação de um patch (correção) de software. A segunda vulnerabilidade permite que os atacantes tenham acesso com privilégios administrativos, ignorando a proteção de segurança mais fundamental do roteador, o Trust Anchor. O recurso de segurança da Cisco foi implementado em quase todos os dispositivos corporativos da empresa desde 2013, só que agora foi descoberta uma maneira de contorná-lo, o que afetaria centenas de milhões de unidades Cisco em todo o mundo, desde roteadores corporativos até switches de rede e firewalls. A Cisco informou que vai disponibilizar uma atualização de software para corrigir a falha.
  17. Meu conselho: Faça um curso de alguma área que te agrade, no qual você pretenda dedicar uma vida de estudos, com prazer... No que toca o "mercado de trabalho", sempre existem oportunidades para quem tem curso superior (seja lá em que área for)... Eu, por exemplo, tenho dois colegas com formação superior em biologia e são, hoje, analistas de sistemas! Conheço gente até com curso de culinária que se encaixa nesse perfil. Se você escolher um "curso", onde você vai dedicar uns bons 4 ou 5 anos para terminar (se não tomar "pau" no meio do caminho) somente por critérios "profissionais", acredite, pode se arrepender muito.
  18. Olá @Will, Vou passar um feedback baseado no que você escreveu ok ? Desses itens que você escreveu, o curso de ADS tem haver apenas com programação. O foco do curso é para desenvolvimento de software para negócios. Não me entenda mal, não quero cortar sua empolgação de "primeira faculdade" nada disso, veja que você está tendo a chance de receber um feedback bem cedo, coisa que não tive em 2001. Respondendo as perguntas: 1. O mercado para desenvolvimento de software é bom, tem muita vaga. Mas isso não tem nada haver com fazer faculdade ou não. Sim, o curso de ADS e/ou sistemas de informação é o curso que mais se aproxima de um cargo de front-end , back-end, fullstack , developer em geral. 2. Isso depende, pra mim não, eu comecei em 2001, transferi p/ ciencia da computação em 2003, abandonei em 2006 retornei em 2017 só pra ter diploma mesmo mas em termos técnicos não me faz nem fez falta. 3. Como você está começando agora, não precisa se preocupar muito com isso, a quantidade de vagas remotas só aumentam, sem falar que você não precisa ( nem deve ) esperar se formar para tentar conseguir uma vaga. Mas dependendo da escolha da linguagem e plataforma , talvez apenas nas capitais você consiga alguma coisa ( caso não consiga emprego remoto ). Se você gosta de segurança, ou se você gosta de assembly ficar fuçando com engenharia reversa etc, eu não indicaria esse curso. Não tem nada lá relacionado com isso ( acredito que apenas a cadeira de organização de computadores mas é um lance bem básico) . Não me leve a mal, mas por questão de validação desse meu feedback vou escrever uma mini bio focada no assunto ok ? - 1997/1998 script kiddie bem mediocre enquanto fazia engenharia de pesca na federal do ceará. - 1999 tentando alterar joguinhos fracassadamente, ainda fazia engenharia de pesca na federal do ceará ( abandonei o curso de eng. de pesca ). - 2000 cursinho p/ tentar passar vestibular de computação ou sistemas de informação p/ tentar hackear os joguinhos de PC - 2001 faculdade sistemas de informação, trabalhava com suporte p/ pagar a faculdade, depois virei developer, e é um rumo totalmente diferente de hackear joguinhos e segurança, 2003 transferi p/ ciencia da computação por questões profissionais de developer mesmo 2006 abandonei motivos pessoais. Meu ultimo cargo na área de desenvolvimento foi de arquitetura técnica com foco na plataforma Java em 2015. 2016 à 2019 não faço mais applicações p/ negócio , mexo apenas com tecnologia de software. E o que isso tem haver com a pergunta sobre o curso de ADS ? Bom, minha carreira é uma prova de que o curso de ADS (que é similar ao de sistemas de informação) não é compatível com o que eu fazia entre 1997 e 1999 e que é parecido com o que você disse (que terminou o CERO e está fazendo o CEB) . O que eu estou fazendo aqui no mente binária ? Como não tenho mais condições de migrar p/ segurança (é muita coisa p/ começar do zero depois de uma boa jornada), resolvi ser um pouco teimoso e continuar com o que havia começado exatamente à 20 anos atrás (1999) , esse ano pretendo fazer um pequeno game pra atari 2600 e tentar hackear uma ROM de nintendo 8 bits. Porque a programação agrega mais ao meu background do que a parte de segurança. E tenho certeza que aqui existem pessoas que entendem bastante de assembly e engenharia reversa que podem me ajudar a não perder muito tempo durante essa minha aventura. Espero ter ajudado com esse feedback.
  19. A Microsoft tem adotado uma medida não muito comum: está lançando atualizações para versões ainda amplamente utilizadas do Windows, mas que não são mais suportadas pela empresa: XP e 2003. De acordo com o blog KrebsOnSecurity, esse movimento é para tentar corrigir uma falha que permite a propagação de um worm que a empresa diz que poderia ser usado para propagar uma ameaça ainda mais rápido, como ocorreu com os ataques do ransomware WannaCry em 2017 e que afetou cerca de 2 mil sistemas Windows em 150 países. Segundo a Microsoft, a vulnerabilidade com o código CVE-2019-0708 está no componente “serviços de área de trabalho remota” incorporado em versões ainda suportadas do Windows, incluindo o Windows 7, Windows Server 2008 R2 e Windows Server 2008, mas também presente em computadores com Windows XP e Windows 2003, que são sistemas operacionais para os quais a Microsoft parou de lançar atualizações de segurança há bastante tempo. Ainda segundo o blog, a Microsoft não detectou evidências de ataques contra a falha de segurança, mas está tentando impedir uma ameaça séria e iminente. Aqui a empresa informa quais são as atualizações de segurança disponíveis. A falha não afeta os últimos sistemas operacionais Windows 10, Windows 8.1, Windows 8, Windows Server 2019, Windows Server 2016, Windows Server 2012 R2, ou Windows Server 2012.
  20. Ótimo artigo pois hoje em dia muitas pessoas não sabem o que fazer quando tem seu celular roubado ou furtado, e esse artigo vem justamente pra dar um norte do que fazer. Parabéns!
  21. Muito bom o artigo Mercês! Parabéns! Aqui estão algumas infos sobre o Android: Para identificar o(s) IMEI(s) - código "universal"(entre aspas mesmo pois não sei se funciona em outra parte do universo 😄 ) - Digite *#06# no teclado numérico do telefone (irá aparecer uma tela com o(s) IMEI(s); Observação: Celulares de dois chips (Android) tem dois IMEI's, importante gravar os dois (um print e depois guardá-lo em seu e-mail ou Google Drive/iCloud/OneDrive como mencionado no artigo é uma boa idéia); Para configurar dois fatores de autenticação no Whatsapp (Android): Configurações > Conta > Verificação em duas etapas > Ativar Para desabilitar visualização de SMS (Android): Configurações > Tela de bloqueio > Notificações > Ocultar conteúdo [Habilitar] Depois caso tenha mais alguma config para Android, vou postando aqui. Abraço!
  22. O que é exploração de binários? Basicamente, é encontrar falhas em programas (compilados, neste caso) e conseguir explorá-las, a fim de executar código arbitrário (à sua escolha). Se isso é possível, dizemos que o software em questão possui uma falha (um bug) e, mais que isso, uma falha explorável. Como funciona? Muitos programas trabalham com dados de entrada que são controlados pelo usuário. Por exemplo, num software visualizador de imagens, as imagens (.png, .jpg, etc) que o usuário pede para o software abrir são a entrada que o usuário passa para o programa. Caso este não trate esta entrada de forma segura, pode apresentar uma falha dependendo da entrada passada e talvez ser explorado (executar código arbitrário, contido na imagem passada, que foi adicionado propositalmente pelo profissional tentando buscar as falhas). A este código adicional, damos o nome de payload. Instrutor @masterek (Fernando Fresteiro) é pentester e pesquisador. O treinamento O curso tem grande foco em BOF (Buffer Overflow) na arquitetura x86-64, mas as aulas também mostram diferentes abordagens para a arquitetura x86 (de 32-bits). São cobertos também os bypasses das principais proteções anti-exploração como randomização de memória e prevenção de execução. Pré-requisitos Para um melhor aproveitamento, recomendamos assistir o CERO, que cobre o básico de Assembly na arquitetura x86. Aulas publicadas Aula 00 - Introdução Assistir Aula 01 - Overview assembly / stack / stack frame Assistir Aula 02 - Simples Buffer Overflow Assistir Aula 03 - Simples Buffer Overflow (Parte 2) Assistir Aula 04 - Corrigindo problemas de alinhamento na stack Assistir Aula 05 - Restrição de Endereco de Retorno Assistir Aula 06 - Review e Pattern Create Assistir Aula 07 - Introdução ao NX Assistir Aula 08 - Bypass NX (Parte 1) Assistir Aula 09 - Bypass NX (Parte 2) Assistir Aula 10 - Bypass NX (Parte 3) Assistir Aula 11 - Introdução aos Gadgets Assistir Aula 12 - Entendendo Gadgets Assistir Aula 13 - Bypass de NX em arquitetura 64 bits (Parte 1) Assistir Aula 14 - Bypass de NX em arquitetura 64 bits (Parte 2) Assistir Aula 15 - Introdução ao Canary Assistir Aula 16 - Uma pausa para PwnTools Assistir
  23. Legal. Muito obrigado! Deu vontade lê-lo agora! 🙂 Abraço!
  24. Bem, como eu falei eu sou um sujeito meio chato e complicado de lidar com certos livros. Ao mesmo tempo que eu valorizo uma boa explicação, detesto aquela verborragia desnecessária que muitos livros fazem para chegar direto ao ponto - como eu falei sobre alguns livros de C++. Esse livro casou exatamente com a forma de ensino que me agrada. É um livro atual, objetivo e muito bem explicado, que reforça capítulo após capítulo o que você estuda de forma progressiva, evitando que você esqueça alguns detalhes. A sessão de exercícios dele é muito bem construída e a sessão chamada "Depuração" sempre garante alguns extras com boa riqueza de informações adicionais. É um livro fácil de digerir, ao mesmo tempo que é muito informativo e com um preço muito acessível. Talvez para quem já tenha uma experiência muito grande com python ele não impressione muito, mas para os novatos e intermediários ele vai ser uma boa ferramenta e uma boa porta de entrada para outros livros e assuntos mais específicos (sockets, por exemplo).
  25. A empresa de segurança israelense ClearSky divulgou na semana passada o vazamento de uma série de documentos de grupos iranianos de APTs - ataques dirigidos avançados persistentes. Os atacantes foram os alvos do vazamento. Os documentos vazados foram divulgados em três canais: Lab Dookhtegam, que publicou documentos relacionados ao grupo 'OilRig'; Green Leakers, que divulgou vazamentos relacionados ao grupo 'MuddyWatter'; e o Black Box, que vazou vários documentos confidenciais relacionados a atividades de grupos de atacantes iranianos. Entre os documentos vazados estão informações do Ministério da Inteligência iraniano, semelhante ao FBI ou à CIA, sobre um grupo conhecido como 'Rana'. As informações vazadas incluem listas de vítimas, estratégias de ciberataque, áreas de acesso, listas de funcionários e imagens de websites que contêm sistemas relevantes de espionagem. Segundo a ClearSky, a identidade por trás do vazamento é atualmente desconhecida, mas com base no escopo e na qualidade dos documentos e informações divulgadas, eles parecem profissionais altamente capacitados. Dessa vez, os próprios atacantes foram pegos, o que mostra que não somente as empresas estão vulneráveis a esses ataques; invasores também podem ser vítimas. 🙃
  1. Load more activity
×
×
  • Create New...