Jump to content
  • Como remover malware de pen drive

       (0 reviews)

    É notória a quantidade de pen drives e cartões de memória infectados com vírus. Freqüentemente nos deparamos com vírus novos, que os antivírus não conhecem (a vacina é criada depois de certo tempo). Essas pragas disseminadas por pen drives são tão perigosas quanto as disseminadas pela internet e às vezes até mais destruidoras, ou seja, o cuidado deve ser redobrado. Veja neste artigo como se defender de um pen drive ou cartão de memória infectado e saiba como remover o vírus destes dispositivos.

    O primeiro ponto a entender é como um vírus infecta um pen drive. Sabemos que vírus são programas (executáveis) e a infecção de um pen drive acontece quando o inserimos em um PC infectado (ou quando o PC infectado já possui um pen drive inserido na porta USB). Se o pen drive infectado é inserido em PC saudável e sem proteção adequada, este PC é infectado e passa a infectar todos os pen drives inseridos nele posteriormente, ou seja, a disseminação da praga fica fora de controle.

    Infelizmente, tudo funciona muito bem graças a uma ajudinha da arquitetura e controle de permissões do Windows. Acontece que normalmente o usuário logado num sistema Windows pertence ao grupo “Administradores”, isto é, possui todas as permissões de escrita e leitura em praticamente todo o disco rígido e áreas de memória. Para um vírus, isto é um prato cheio. Da mesma maneira que um programa de instalação qualquer pode ser executado com sucesso pelo usuário logado (copiando arquivos para diretórios de sistema e criando processos privilegiados), um vírus também pode, pois rodará com as permissões do usuário, que são as de administrador do sistema (as máximas).

    Quando o usuário incauto executa um vírus, este normalmente carrega-se em memória, copia-se para vários locais (backup), tenta infectar outras máquinas na rede e faz com que seja inicializado a cada reinicialização do sistema. É mais ou menos a definição de um worm. Tratamos de algumas técnicas manuais utilizadas para remover estes vírus no artigo Remoção manual de malware no Windows.

    Assim que um pen drive sadio é inserido na porta USB, a praga copia-se para ele. Até aí, nenhuma novidade. Mas como, ao inserir este pen drive em outro computador, ocorre a infecção? Acontece que o Windows possui uma facilidade chamada autorun (ou auto-inicialização) para drives montados e com letra atribuída. Como os pen drives são reconhecidos como uma unidade de disco (recebem inclusive uma letra disponível para serem acessados, por exemplo, F:), esta facilidade pode ser usada nestes dispositivos.

    Funcionamento da auto-inicialização:

    O autorun serve para executar algum aplicativo assim que o drive é montado. O exemplo clássico são os CD-ROMs que, ao serem inseridos no drive de CD, abrem uma aplicação com menus e outros recursos. A questão é que o autorun pode ser utilizado em qualquer drive, seja uma partição do disco, CD-ROM, DVD, pen-drive, câmera digital, etc.

    Para usar esta facilidade, basta adicionar um arquivo chamado autorun.inf no diretório raiz do drive em questão. Neste arquivo são escritas rotinas que o Windows deverá seguir quando assim que o drive for montado. Veja um exemplo:

    [autorun]
    open=menu.exe
    icon=menu.ico

    Se você salvar o conteúdo do exemplo acima num arquivo de texto, nomeá-lo autorun.inf e movê-lo para o diretório raiz de um drive, ao montar ou acessar este drive, as instruções contidas neste arquivo serão executadas.

    Creio que as instruções sejam auto-explicativas. Basicamente o ícone do drive exibirá agora o ícone menu.ico, contido no diretório raiz do drive (do CD-ROM, por exemplo) e a aplicação menu.exe será carregada.

    À esta altura você deve imaginar como o vírus de pen-drive é executado assim que ele é inserido. Isso mesmo, usando essa técnica. Todos os pen-drives infectados que analisei continham um arquivo autorun.inf, com instruções para execução do vírus.

    Evitando a contaminação:

    Ficar imune é impossível. Nunca poderemos prever as técnicas de contaminação que serão inventadas. Aliás, cá entre nós, são muito “boas”. No entanto, algumas medidas podem ser tomadas para diminuir os riscos de contaminação. São elas:

    1. Desabilitar a auto-reprodução em unidades removíveis.

    No registro, navegue até a chave HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionpoliciesExplorer e sete o valor NoDriveTypeAutoRun para 4. Isso desabilitará a auto-reprodução em unidades removíveis. Se quiser desabilitar em qualquer tipo de unidade (recomendo), utilize o valor ff.

    2. Sempre abrir a unidade removível (pen-drive, cartão de memória, etc) pelo Windows Explorer, ao invés de dar duplo-clique no ícone.

    Basta clicar com o botão direito na unidade e escolher “Explorar” ou abrir o Windows Explorer e clicar sobre a unidade.

    3. Desabilitar a execução do arquivo autorun.inf, geralmente responsável pela infecção.Copie e cole as linhas abaixo para o Bloco de Notas e salve como inf.reg:

    REGEDIT4
    [HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionIniFileMappingAutorun.inf]
    @=”@SYS:DoesNotExistSEUNOME”

    Substitua SEUNOME pelo seu primeiro nome (sem acento ou espaços). Depois basta executar este inf.reg que você gerou.

    Para facilitar as coisas, escrevi um software que faz este trabalho. Chamei-o de USBForce. Funciona assim:

    Na primeira vez que é executado na máquina, o USBForce:

    • Desabilita a auto-reprodução em todas as unidades.
    • Desabilita o reconhecimento de arquivos autorun.inf.
    • Habilita sua proteção.

    A partir deste momento, ao inserir um pen-drive, cartão de memória ou qualquer dispositivo removível, o Windows o reconhecerá mas nenhuma tela será aberta. Você deve então clicar no ícone do USBForce em sua área de trabalho. Ele abrirá o dispotivo pra você e tentará detectar se existe algum vestígio de infecção de vírus no dispositivo. Em caso afirmativo, ele tentará localizar o vírus e deletar (você será avisado antes).

    Naturalmente é interessante colocá-lo em alguma pasta e criar um atalho pra ele na área de trabalho, para facilitar o acesso.


    User Feedback

    Join the conversation

    You can post now and register later. If you have an account, sign in now to post with your account.
    Note: Your post will require moderator approval before it will be visible.

    Guest

    • This will not be shown to other users.
    • Add a review...

      ×   Pasted as rich text.   Paste as plain text instead

        Only 75 emoji are allowed.

      ×   Your link has been automatically embedded.   Display as a link instead

      ×   Your previous content has been restored.   Clear editor

      ×   You cannot paste images directly. Upload or insert images from URL.


  • Similar Content

    • By Bruna Chieco
      Um novo ladrão de informações chamado Panda Stealer, entregue por meio de e-mails de spam, foi identificado pela Trend Micro no início de abril. Os e-mails normalmente se apresentam como solicitações de orçamento comercial para atrair vítimas para a abertura de arquivos Excel maliciosos. Com base na telemetria da empresa de segurança, Estados Unidos, Austrália, Japão e Alemanha foram os países mais afetados em onda recente do spam. 
      Em uma das cadeias de infecção, um anexo .XLSM contém macros que baixam um carregador, que baixa e executa o ladrão principal. Outra cadeia de infecção envolve um arquivo .XLS anexado contendo uma fórmula do Excel que utiliza um comando do PowerShell para acessar paste.ee, uma alternativa do Pastebin, que acessa um segundo comando criptografado do PowerShell.
      Depois de instalado, o Panda Stealer pode coletar detalhes como chaves privadas e registros de transações anteriores de várias carteiras de moeda digital de sua vítima, incluindo Dash, Bytecoin, Litecoin e Ethereum. Além de ter como alvo carteiras de criptomoedas, ele pode roubar credenciais de outros aplicativos, como NordVPN, Telegram, Discord e Steam. O Panda Stealer também é capaz de fazer capturas de tela do computador infectado e exfiltrar dados de navegadores como cookies, senhas e cartões.
      O Panda Stealer é uma variante do Collector Stealer, que foi vendido em alguns clandestinos e em um canal do Telegram. Os pesquisadores encontraram ainda 264 arquivos semelhantes ao Panda Stealer no VirusTotal. Mais de 140 servidores C&C e mais de 10 sites de download foram usados por essas amostras. Alguns dos sites de download eram do Discord, contendo arquivos com nomes como build.exe, indicando que os agentes de ameaças podem estar usando o Discord para compartilhar a compilação do Panda Stealer.
    • By Bruna Chieco
      O aplicativo de mensagens Telegram está sendo utilizado para distribuir um cavalo de Tróia de acesso remoto (RAT) denominado ToxicEye. O malware pode assumir o controle de sistemas de arquivos, instalar ransomware e vazar dados dos computadores das vítimas, de acordo com pesquisadores da Check Point Software Technologies que rastrearam mais de 130 ataques cibernéticos nos últimos três meses que alavancaram o ToxicEye. Os invasores usam o Telegram para se comunicar com seu próprio servidor, exfiltrando dados para ele.
      A plataforma de mensagens instantâneas baseada na nuvem teve um aumento na popularidade devido a mudanças polêmicas nas configurações de privacidade do seu rival, o WhatsApp, sendo o aplicativo mais baixado em todo o mundo em janeiro de 2021, com mais de 63 milhões de instalações, ultrapassando os 500 milhões de usuários ativos mensais, diz a Check Point. 
      Essa popularidade também se estende à comunidade cibercriminosa, que utiliza o Telegram como um sistema de comando e controle (C&C) pronto para seus produtos maliciosos. Mas por que o Telegram tem sido cada vez mais utilizado para atividades cibercriminosas?
      Segundo a CheckPoint, o Telegram é um serviço legítimo, fácil de usar e estável, e não é bloqueado por mecanismos antivírus corporativos, nem por ferramentas de gerenciamento de rede. Além disso, os invasores podem permanecer anônimos, pois o processo de registro requer apenas um número de celular.
      Os recursos de comunicação exclusivos do Telegram permitem que os invasores facilmente exfiltrem dados dos computadores das vítimas ou transfiram novos arquivos maliciosos para máquinas infectadas. O Telegram também permite que os invasores usem seus dispositivos móveis para acessar computadores infectados de quase qualquer local do mundo.
      ToxicEye – No caso do ToxicEye, malware mais recente monitorado pela Ckeck Point, o invasor cria uma conta 'bot' do Telegram, que é uma conta remota especial com a qual os usuários podem interagir pelo chat do Telegram, adicionando-os a grupos ou enviando solicitações diretamente do campo de entrada digitando o nome de usuário. 
      A bot é incorporada ao arquivo de configuração RAT do ToxicEye e compilada em um arquivo executável. Qualquer vítima infectada com essa carga maliciosa pode ser atacada por meio da bot do Telegram, que conecta o dispositivo do usuário de volta ao C&C do atacante via Telegram. O trojan também pode ser baixado e executado abrindo um documento malicioso.
      A Check Point identificou uma série de recursos-chave que caracterizam a maioria dos ataques recentes: recursos de roubo de dados; controle do sistema de arquivos; captura de entrada e saída; e recursos de ransomware, com a capacidade de criptografar e descriptografar arquivos das vítimas.
      "Dado que o Telegram pode ser usado para distribuir arquivos maliciosos, ou como um canal C&C para malware controlado remotamente, esperamos que ferramentas adicionais que exploram esta plataforma continuem a ser desenvolvidas no futuro", diz a Check Point.
    • By Bruna Chieco
      Pesquisadores descobriram um novo conjunto de aplicativos falsos para Android na Google Play Store. Os apps sequestram notificações de mensagens SMS para realizarem fraudes de faturamento, segundo informações do The Hacker News.
      Os aplicativos em questão tem como alvo principal usuários no sudoeste da Ásia e na Península Arábica, atraindo um total de 700 mil downloads antes de serem descobertos e removidos da plataforma. As descobertas foram relatadas de forma independente pelas empresas de segurança Trend Micro e McAfee.
      Se passando por apps de editores de fotos, papéis de parede, quebra-cabeças, e outros aplicativos relacionados a câmeras, eles possuem um malware embutido que sequestra notificações de mensagens SMS e, em seguida, faz compras não autorizadas, disseram pesquisadores.
      Os aplicativos falsos aparentemente pertencem ao malware Joker (também conhecido como Bread). A McAfee, no entanto, está rastreando a ameaça com um apelido separado chamado Etinu. O malware é conhecido por realizar fraudes de faturamento, roubando de mensagens SMS, listas de contato e informações do dispositivo. 
      Os autores de malware normalmente empregam uma técnica chamada controle de versão, que se refere ao upload de uma versão limpa do aplicativo na Play Store para criar confiança entre os usuários e, em seguida, adicionam sorrateiramente um código malicioso por meio de atualizações do aplicativo, em uma tentativa de escapar do processo de revisão do app na loja.
    • By Bruna Chieco
      Uma família de malware específica que foca em roubo de criptomoedas, chamada HackBoss, está sendo estudada por pesquisadores da Avast. O malware é considerado simples, mas muito eficaz, tendo possivelmente roubado mais de US$ 560 mil das vítimas até agora. 
      Transmitido principalmente via Telegram, o HackBoss tem um ganho monetário significativo, segundo a Avast, sendo que os autores do malware possuem um canal de Telegram usado como a principal fonte para espalhá-lo. Ele é promovido como uma fonte de fornecimento "do melhor software para hackers (hack bank/dating/bitcoin)". 
      Embora seja prometido que cada aplicativo promovido no canal seja de hacker ou cracker, a verdade é que cada postagem publicada contém apenas um malware para roubo de criptomoedas oculto como um aplicativo de hacking ou cracking. Além disso, nenhum aplicativo postado neste canal oferece o comportamento prometido, ou seja, todos são falsos.
      O canal Hack Boss do Telegram foi criado em 26 de novembro de 2018, diz a Avast, e tem mais de 2,5 mil assinantes até o momento, fazendo uma média de 7 postagens por mês. As publicações geralmente contêm um link para armazenamento de arquivos criptografados ou anônimos a partir do qual o aplicativo pode ser baixado, além de uma descrição falsa da suposta funcionalidade do aplicativo e capturas de tela. 
      Depois de baixar o aplicativo como um arquivo .zip, é possível executar o arquivo .exe, e uma user interface simples será exibida, sendo somente ela que pode abrir um diretório de arquivo ou pop-up de uma janela. Sua funcionalidade principal e maliciosa é acionada quando a vítima clica em qualquer botão. Depois disso, uma carga maliciosa é descriptografada e executada.
      A carga maliciosa verifica regularmente o conteúdo da área de transferência em busca de um formato de carteira de criptomoeda e, se houver um endereço de carteira, ele a substitui por uma de suas próprias carteiras. A carga maliciosa continua em execução no computador da vítima mesmo depois que o aplicativo é fechado. 
      Uma lista de mais de 100 endereços de carteira criptomoeda pertencentes aos autores do HackBoss foi identificada pelos pesquisadores da Avast, que afirmam que as criptomoedas são Bitcoin, Ethereum, Dogecoin, Litecoin e Monero. 
    • By Felipe.Silva
      Injeção de código é uma técnica que consiste em adicionar instruções extras em um executável. Essas instruções podem ser adicionadas em vários lugares do programa, inclusive executar antes do entry point original.
      O uso mais comum para injeção de código é para fins maliciosos, onde um shellcode poderia ser inserido no executável e dar acesso remoto para um atacante. Mas um exemplo de uso "justo" para essa técnica é para fins de patching no executável quando você quer que algo seja alterado em tempo de execução no binário.
      Se você já tentou injetar código em um executável manualmente deve saber que não é uma tarefa tão divertida. Pensando neste tipo de impasse, imaginei que seria interessante ter uma ferramenta para automatizar esse tipo de manipulação de um executável. Por esse motivo criei o pei, uma ferramenta para automatizar injeção de código e outros tipos de manipulações em executáveis PE de 32-bit e 64-bit.
      O pei foi programado pensando na automação e por isso é fácil usar a ferramenta a partir de um script. Com ela você pode obter e modificar valores no executável, e é claro, injetar código.
      Antes de qualquer coisa você pode instalar o pei em seu Linux rodando os comandos abaixo:
      git clone https://github.com/Silva97/pei cd pei make sudo make install Nota: Caso use Windows e não esteja usando WSL ou um MSYS2 da vida, você pode compilar o projeto instalando o make e o MinGW (recomendo usar o Chocolatey). No entanto, o “sudo make install” não vai funcionar no Windows, você vai ter que adicionar o executável ao PATH manualmente.
      Se você não estiver a fim de compilar o executável, fiz o favor de adicionar o binário da ferramenta compilado para Windows nos releases dela. Você pode baixá-lo no link https://github.com/Silva97/pei/releases/latest.
      O uso básico da ferramenta segue o seguinte formato:
      pei [opções] <operação> <executável> [argumento] Se você quiser ver mais detalhes de como usar a ferramenta você pode rodar “pei -h”.
      Operações
      As operações são o que determinam o que a ferramenta irá fazer com o executável, indo desde exibir informações sobre ele até modificar campos dos cabeçalhos.
      show
      A operação show serve para exibir informações sobre o executável e campos dos cabeçalhos. Se você não passar argumentos para a operação por padrão ela irá exibir informações básicas do executável:

      Você também pode especificar uma combinação de letras para escolher quais campos serão exibidos, dentre elas: c (COFF header), o (optional header), d (data directories) e s (section). Exemplo:
      $ pei show test.exe co Esse comando, por exemplo, exibe o COFF header e optional header do executável.
      get
      A operação get pega o valor de um campo individual de um dos cabeçalhos (coff, optional ou section) do executável.
      Seguindo uma notação com pontos, semelhante à acessar campos de estruturas em C, você pode especificar o cabeçalho e o nome do campo para ser obtido. Por exemplo, para obter o entry point do executável o comando ficaria:
      $ pei get executavel.exe optional.entry_point '%x' 14f0 Dica: Veja o nome dos campos dos cabeçalhos usando a operação show.
      O argumento após o nome do campo é uma string de formatação idêntica a da função printf() da libc, que aceita quaisquer flags de formatação disponíveis para a função.
      Para acessar os campos de uma seção é necessário especificar o número da seção também, como demonstrado no print abaixo:

      edit
      A operação edit serve para modificar o valor de campos, onde o nome do campo é especificado de maneira idêntica à operação get.
      Você pode utilizar os operadores `=`, `|=` e `&=` que fazem exatamente a mesma coisa que na linguagem C. Exemplos:
      $ pei edit executavel.exe section.0.name = .code $ pei edit executavel.exe optional.entry_point = 0xabcd1234 Esta operação aceita números em decimal, hexadecimal ou octal na hora de definir o valor de campos numéricos.
      zeros
      Esta operação simplesmente exibe uma lista das maiores sequências de bytes nulo em cada seção do executável. É este espaço que é utilizado para injetar o código, tornando a operação útil para você poder escolher em qual seção injetar o código.
      $ pei zeros executavel.exe Section #0 '.text': 0x00000000000022fb of 13 bytes Section #1 '.data': 0x000000000000242c of 1012 bytes Section #2 '.rdata': 0x0000000000002a5b of 37 bytes Section #6 '.idata': 0x0000000000003a26 of 22 bytes Section #7 '.CRT': 0x000000000000420b of 21 bytes Section #9 '/4': 0x0000000000004649 of 23 bytes Section #10 '/19': 0x0000000000004cbe of 10 bytes Section #12 '/45': 0x000000000003e2fc of 5 bytes Section #13 '/57': 0x0000000000041019 of 8 bytes Section #15 '/81': 0x0000000000043c33 of 44 bytes Section #16 '/92': 0x0000000000045509 of 23 bytes inject - A cereja do bolo 🙂
      Esta é a operação que injeta o código. Você pode usar a opção -f para especificar o arquivo contendo o código a ser injetado, que seria um raw binary. Onde esse arquivo deve conter apenas as instruções de código de máquina a ser injetado, como um shellcode por exemplo.
      Opcionalmente, você pode usar a opção -s para especificar o número da seção que você quer injetar o código. Se a opção não for especificada, por padrão o pei vai injetar onde houver mais espaço disponível.
      $ pei -f my_code.bin inject executavel.exe Writed code of 12 bytes on offset 0x0000000000043924 of section #15 '/81' Após o código injetado, o pei insere um jump absoluto para o entry point original do executável, fazendo com que após o código injetado ser executado o fluxo de execução do programa continue normalmente.
      Outra modificação que o pei faz é desabilitar o dynamic base do executável, para evitar que o jump aponte para o endereço errado.
      Dica: Injetando Código Muito Grande
      Se você precisar injetar um código maior do que o espaço disponível apontado pela operação zeros, você pode dividir o código a ser injetado em várias partes e injetar cada parte por vez, seguindo a ordem da última até a primeira parte. Isso funciona porque o pei irá adicionar um jump no final do código para o endereço que está sendo indicado como entry point. Se você já injetou código antes, esse endereço é o endereço do código anteriormente injetado. 🙂
      Dessa forma você pode fazer um chain de saltos da primeira parte até a última e então saltar para o entry point original. Exemplo:
      $ pei inject -f parte-3.bin executavel.exe Writed code of 87 bytes on offset 0x0000000000043833 of section #15 '/81' $ pei inject -f parte-2.bin executavel.exe Writed code of 80 bytes on offset 0x0000000000044924 of section #11 '/23' $ pei inject -f parte-1.bin executavel.exe Writed code of 32 bytes on offset 0x0000000000401a15 of section #1 '.text' Isso irá criar a seguinte ordem de execução: parte-1.bin -> parte-2.bin -> parte-3.bin -> entry point. Onde as setas “->” representam os saltos.
      diff
      Esta operação exibe diferenças entre dois executáveis. Ela compara cada campo dos cabeçalhos do executável e o conteúdo das seções, e depois exibe estas diferenças no terminal. Você pode usar a opção -c (ou --color) para que a saída da operação seja colorida:

      Em vermelho são os valores no executável original que foram modificados e em verde são os valores novos no executável modificado.
      patch
      Essa operação lê um texto de entrada no mesmo formato que a saída da operação diff e replica as mesmas modificações no executável. Exemplo:
      $ pei patch executavel2.exe diff-output.txt Caso você não especifique um patch file, o pei irá ler de stdin. Assim, é possível que você faça um pipe entre uma operação de diff e patch:
      $ pei diff original.exe mod.exe | pei patch outro.exe A diferença de fazer isto e simplesmente fazer uma cópia do executável modificado, é que a ideia é replicar somente as diferenças entre os executáveis. Quaisquer outros campos não são tocados pela operação patch, o que te permite salvar alterações e replicá-las por meio de um script. 🙂
      Se você quiser, também é possível escrever um patch file manualmente, bastando imitar a saída de diff. Uma dica é que os valores dos campos originais (em vermelho) não são necessários para a operação patch, então você pode inserir somente os valores novos. Seguindo o print da saída do diff que utilizamos agora pouco como exemplo:
      optional.entry_point xxx 0x4ca33 section.0.name xxx .code section.15.characteristics xxx 0x62100040 // @O texto não faz diferença, só importa o @ no início da linha // Daqui para baixo qualquer linha que não inicie com + será ignorada. +0x43830 00 30 9f 61 62 63 0a b8 f0 14 40 00 ff e0 00 00 // O formato é: +0xoffset bytes em hexadecimal Nota: Onde há o “xxx” seriam os campos dos valores originais (em vermelho) que não são lidos pelo pei porém são necessários para imitar a saída da operação diff. Você pode colocar qualquer valor aí que não dará erro já que são ignorados.
      Você pode usar a operação patch em scripts para automatizar várias modificações em um executável ao mesmo tempo, inclusive em bytes de um determinado offset.
×
×
  • Create New...