Ir para conteúdo
  • Cadastre-se

gnoo

Membros
  • Total de itens

    98
  • Registro em

  • Última visita

Reputação

49 Excellent

Últimos Visitantes

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

  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.
×