Projet 3 : Analyse avancée de code suspects

(1) L'HÔTE

Virtualiseur installé : Cuckoo.

+ Installation de toutes les librairies optionnelles pour une performance optimale :Tcpdump : pour capturer le traffic réseau et le dumper dans un fichier “pcap”.Volatility : pour fournir une visibilité supplémentaire des modifications du système d'exploitation aussi bien qu'une détection de laprésence de la technologie de rootkit. (Nécessite les librairies : PyCrypto, Distorm3, Yara, PIL, Ipython, libforensic1394).Dpkt : pour extraire des informations pertinentes des fichiers PCAP.Jinja2 : pour fournir les rapports HTML et l'interface web.Pydeep : pour calculer le ssdeep hash des fichiers.Ssdeep : pour obtenir un hash d'un fichier par morceaux. Yara and Yara Python : pour vérifier les signatures Yara.Django : pour utiliser l'interface web.

(2) LE GUEST

Configurations prises en charge pour l’analyse : Windows XP SP3 (32 bits)Logiciels installés : Internet Explorer, Adobe Reader 5.05, java 6, Libre Office 3.3.3, Live messenger 7.0, Flash Player (2010), WinZip 11.2

(3) ANALYSE DE BASE

Génération d’un rapport, format web : OUI : Voir les fichiers “report.html” et “report.json”

Surveillance activité système et réseau : OUI : Tcpdump

Requêtage de VirusTotal via son API et le condensat du code analysé : OUI

(4) ANALYSE RENFORCEE

Mise en valeur de résultats « clefs »

a/ Apprendre le Python (au moins les bases)

b/ Importer des signatures “clefs” pour renforcer l'analyse de malwares.

c/ Etudier la manière dont cuckoo gère les signatures.

d/ Regrouper les signatures “clefs” dans un champ global ( mise en valeur).→

e/ Etudier des comportements suspects (rechercher des malwares et faire pleins de tests, étudier des analyses de malwares) …

f/ … Puis écrire nos propres signatures :

_ antivirus_virustotal_5.py : "File has been identified by at least 5 AntiVirus on VirusTotal as malicious"_ creates_exe_appdata.py : "Creates a Windows executable on Appdata folder"_ creates_exe_temp.py : "Creates a Windows executable on Temp folder"_ antidebug.py : "IsDebuggerPresent checked, possibly for anti-virtualization"_ sleep.py : "The malware would like to sleep."_ autodelete.py : "Auto-deletion"

(5) ANTI-DETECTION DE LA VIRTUALISATION par le malware analysé

a/ Recherche d'un outil pour détecter la virtualisation. Outil utilisé : Pafish.exe

b/ Premier test et premières améliorations :

_ Mettre plus de 50 GB de mémoire._ Enlever les additions invitées.

c/ Nécessité de modifier le fichier “cuckoomon.dll” (qui gère le hooking des API) pour améliorer encore l'anti-détection.

_ Nouveau “cuckoomon.dll”._ VirtualBox n'est plus détecté !

d/ Certains malwares changent de comportement lorsqu'ils ne détectent pas de virtualisation ! (Voir le malware : “def.exe”)

(4) ANALYSE RENFORCEE

Mise en valeur de résultats « clefs »

b/ Importer des signatures “clefs” pour renforcer l'analyse de malwares.

Lien de téléchargement : h ttps://github.com/cuckoobox/community/archive/master.zip

Signatures clefs (http://cyberwarzone.com/cuckoo-sandbox-plugins-malware-analysis/):

bypass_firewall.py : "Operates on local firewall's policies and settings"injection_createremotethread.py  "Code injection with CreateRemoteThread in a remote process"antidbg_devices.py  : "Checks for the presence of known devices from debuggers and forensic tools"antivirus_virustotal.py : "File has been identified by at least one AntiVirus on VirusTotal as malicious"antivm_generic_bios.py  : "Checks the version of Bios, possibly for anti­virtualization"antivm_generic_disk.py  : "Queries information on disks, possibly for anti­virtualization"antivm_vbox_devices.py  : "Detects VirtualBox through the presence of a device"antivm_vbox_files.py  : "Detects VirtualBox through the presence of a files"infostealer_browser.py  : "Steals private information from local Internet browsers"persistence_autorun.py : "Installs itself for autorun at Windows startup"recon_systeminfo.py  : "Collects information on the system (ipconfig, netstat, systeminfo)"antidbg_windows.py antiemu_wine.py antisandbox_mouse_hook.py antisandbox_productid.py antisandbox_unhook.py antivm_generic_ide.py antivm_generic_scsi.py antivm_generic_services.py antivm_vbox_acpi.py antivm_vbox_keys.py antivm_vbox_libs.py antivm_vbox_window.py exec_crash.py infostealer_ftp.py 

c/ Etudier la manière dont cuckoo gère les signatures.

Comprendre comment est checkée/vérifiée une signature.

(Le dossier “cuckoo” est le dossier courant, celui où se trouve le script python lancé par la commande qui lance le serveur : python cuckoo.py &).

Dans le fichier “cuckoo/utils/process”, on peut lire les imports suivants :

from lib.cuckoo.core.plugins import RunProcessing, RunSignatures, RunReporting

donnant lieux aux appels suivants :

results = RunProcessing(task_id=aid).run() RunSignatures(results=results).run()

Autrement dit, dans le fichier “cuckoo/lib/cuckoo/core/plugins.py”, se trouve la définition de la classe RunSignatures, instanciée ici avec pour argumentle résultats results renvoyé par la fonctions RunProcessing(task_id=aid).run() qui a analysée le malware.Pour analyser ce qui se passe alors, il faut commencer par se rendre à la méthode constructeur __init__(self, results), puis à la fonction appelée run(self).

class RunSignatures(object): """Run Signatures."""

# Le constructeurdef __init__(self, results):

self.results = results

# La fonction appelée run()def run(self):

# This will contain all the matched signatures. matched = []

# Link this into the results already at this point, so non-evented signatures can use it self.results["signatures"] = matched

complete_list = list_plugins(group="signatures")

for signature in complete_list:

match = self.process(signature) # If the signature is matched, add it to the list. if match:

matched.append(match)

# Sort the matched signatures by their severity level. matched.sort(key=lambda key: key["severity"])

def process(self, signature): """Run a signature. @param signature: signature to run. @param signs: signature results dict. @return: matched signature. """

# Initialize the current signature. current = signature(self.results)

# Run the signature and if it gets matched, extract key information # from it and append it to the results container. if current.run():

log.debug("Analysis matched signature \"%s\"", current.name) # Return information on the matched signature.

return current.as_result()

Si une signature est vérifée, le retour de la fonction match = self.process(signature) est un dictionnaire* de la forme :

{'families': [], 'description': 'File has been identified by at least one AntiVirus on VirusTotal as malicious', 'severity': 2, 'references': [], 'alert': False, 'data': [], 'name':'antivirus_virustotal'}

{'families': [], 'description': 'Performs some HTTP requests', 'severity': 2, 'references': [], 'alert': False, 'data': [], 'name': 'network_http'}

{'families': [], 'description': 'The binary likely contains encrypted or compressed data.', 'severity': 2, 'references': ['http://www.forensickb.com/2013/03/file-entropy-explained.html','http://virii.es/U/Using%20Entropy%20Analysis%20to%20Find%20Encrypted%20and%20Packed%20Malware.pdf'], 'alert': False, 'data': [{'section': {'size_of_data': '0x00073200','virtual_address': '0x00038000', 'entropy': 7.876037394358108, 'name': '.rsrc', 'virtual_size': '0x00073020'}}], 'name': 'packer_entropy'}

{'families': [], 'description': 'Installs itself for autorun at Windows startup', 'severity': 3, 'references': [], 'alert': False, 'data': [], 'name': 'persistence_autorun'}

Comme le montre l'instruction matched.append(match), lorsqu'une signature est vérifée, ces strings JSON vont être ajoutées au tableau matched qui

aura donc au final cette forme : self.results["signatures"] = matched :

"signatures": [ { "families": [], "description": "File has been identified by at least one AntiVirus on VirusTotal as malicious", "severity": 2, "references": [], "alert": false, "data": [], "name": "antivirus_virustotal" }, { "families": [], "description": "Performs some HTTP requests", "severity": 2, "references": [], "alert": false, "data": [], "name": "network_http" }, { "families": [], "description": "The binary likely contains encrypted or compressed data.", "severity": 2, "references": [ "http://www.forensickb.com/2013/03/file-entropy-explained.html", "http://virii.es/U/Using%20Entropy%20Analysis%20to%20Find%20Encrypted%20and%20Packed%20Malware.pdf" ], "alert": false, "data": [ { "section": { "size_of_data": "0x00073200", "virtual_address": "0x00038000", "entropy": 7.876037394358108, "name": ".rsrc", "virtual_size": "0x00073020" } } ], "name": "packer_entropy" }, { "families": [], "description": "Installs itself for autorun at Windows startup",

"severity": 3, "references": [], "alert": false, "data": [], "name": "persistence_autorun" } ],

Par la suite, le tableau self.results va s'étoffer, et aura plusieurs champs : "signatures", "virustotal", "static", "dropped", "network" etc.

--------------------

dictionnaire*Plus spécifiquement, ce qui est rétourné ici par la fonction process match = self.process(signature) n'est pas un objet Signature, mais un objetDictionnaire. Lorsqu'une signature est vérifiée, le dictionnaire retournée est celui généré par la méthode as_result() de l'object Signature :

Pour cela, il faut aller voir du côté de la classe Signature, qui se trouve, d'après l'import “from lib.cuckoo.common.abstracts import Report, Signature”,dans le fichier “cuckoo/lib/cuckoo/common/abstracts.py”.http://cuckoo.readthedocs.org/en/latest/customization/signatures/

class Signature(object): """Base class for Cuckoo signatures."""

name = "" description = "" severity = 1 categories = [] families = [] authors = [] references = [] alert = False enabled = True

def as_result(self): """Properties as a dict (for results). @return: result dictionary. """ return dict(

name=self.name, description=self.description, severity=self.severity, references=self.references,

data=self.data, alert=self.alert, families=self.families

)

d/ Regrouper les signatures “clefs” dans un champ global ( mise en valeur).→ # The suspicious signatures names are extracted from a file and put in the suspiciousSignaturesList list : 

with open('lib/cuckoo/core/suspiciousSignaturesList.txt') as file :      suspiciousSignaturesList = file.read().splitlines() 

 # All the suspicious signatures matched are put in the suspiciousSignaturesMatched list : 

suspiciousSignaturesMatched = [] 

for signatureDict in matched: if signatureDict["name"] in suspiciousSignaturesList: 

suspiciousSignaturesMatched.append(signatureDict["description"])  # If at least one suspicious signatures is matched, the user is warned : 

if suspiciousSignaturesMatched:  

referencesTemp=[ "http://cyberwarzone.com/cuckoo­sandbox­plugins­malware­analysis/"] 

descriptionTemp = '!!! SUSPICIOUS SIGNATURES, BE CAREFUL !!!' descriptionTemp += '  <<<>>>  ' descriptionTemp += '  <<<>>>  '.join(suspiciousSignaturesMatched) 

 suspiciousSignatures = dict( 

name="suspicious_signatures", description=descriptionTemp, severity=5, references=referencesTemp, data=suspiciousSignaturesMatched, alert="true", authors="Florent FAUVIN, Zhenxiu ZHENG" 

) 

matched.append(suspiciousSignatures) 

e/ Etudier des comportements suspects (rechercher des malwares et faire pleins de tests, étudier des analyses demalwares) …

Télécharger des Virus et Malwares :

VirusShare : http://virusshare.com/torrents.4n6 , Username: Cage , Password: o9zK9Wb5bkmk

http://www.malwaredomainlist.com/update.phphttp://malwareurls.joxeankoret.com/https://anubis.iseclab.org/http://totalhash.com/

http://www.joesecurity.org/joe-sandbox-reportsWindows, Android, MacOSX, documents VmWare / VirtualBox Analyse hybride : statique + dynamique

Autres sites :clean-mx.de malc0de.com malwareblacklist.com malwaredomainlist.com malwareurl.com

Etudier des analyses de malwares :

http://www.behindthefirewalls.com/2013/10/tatic-analysis-packed-malware-cuckoo.htmlhttp://www.coyotus.com/repo/pdf/hacking/misc_cuckoo.pdfhttp://piratercommeunnul.wordpress.com/2013/03/31/analyser-un-logiciel-malveillant-comme-un-null-22/misc_cuckoo.pdfAnalyse de code malveillant.pdfSSTIC08-article-Charpentier_Hamon-Autopsie_Observations_Banker.pdf (le début)http://www.securite-informatique.gouv.fr/gp_article636.html

Comportements suspects :

Créer un program.exe dans le dossier Appdata / Temp.

Code obfusqué (mais difficile à repérer par une signature...)

Fichiers chiffrés.

Library KERNEL32.DLLThe VirtualAllocEx, WriteProcessMemory imports would be a hint of it will lead with some form of process injection.

IsDebuggerPresent This API detects if the program is being debugged and if it is, it can change its behaviour... It is common to find this APIin malware samples... With this technique the malware developers are trying to make the malware analyst’s task more difficult.

Library ADVAPI32.dllHere we can see that the program call to the functions below in order to create, edit or remove register keys:RegEnumValueW, RegDeleteValueW, RegDeleteKeyW, RegEnumKeyExW, RegSetValueExW, RegCreateKeyExW, RegConnectRegistryW, RegOpenKeyExW, RegQueryValueExW, RegCloseKey.

Pour se répandre, un code malveillant a besoin d’être lancé d’une façon ou d’une autre, soit en exécutant le fichier malveillant ou encliquant sur un lien web malveillant ou depuis l’option autorun disponible dans le registre Windows. Les malwares modernes utilisentdiverses techniques de social engineering afin de manipuler les utilisateurs à non seulement l’exécuter la première fois mais aussi pourl'exécuter à chaque fois que l’ordinateur démarre. Ils créent à cette fin des entrées registre.HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

UPX : http://fr.wikipedia.org/wiki/UPXCe processus permet de compresser un fichier exécutable, capable quand il est lancé de se décompresser lui-même.

f/ … Puis écrire nos propres signatures :_ antivirus_virustotal_5.py : "File has been identified by at least 5 AntiVirus on VirusTotal as malicious"_ creates_exe_appdata.py : "Creates a Windows executable on Appdata folder"_ creates_exe_temp.py : "Creates a Windows executable on Temp folder"_ antidebug.py : "IsDebuggerPresent checked, possibly for anti-virtualization"_ sleep.py : "The malware would like to sleep."_ autodelete.py : "Auto-deletion"

class AutoDelete(Signature): name = "AutoDelete" description = "Auto-deletion" severity = 4 authors = ["Florent FAUVIN, Zhenxiu ZHENG"] minimum = "0.5" evented = True # Nécessaire, cette signature doit dans la liste evented_list, # sinon sa méthode on_call ne sera pas appelee. # (On est obligé de faire comme ca car elle n'a pas de méthode run().

def __init__(self, *args, **kwargs): Signature.__init__(self, *args, **kwargs) # Liste des processus self.ListProcessNames = []

def on_call(self,call,process):

# A chaque appel de cet objet Signature "autodelete", # on complète la liste des processus créés par le programme analysé. if process["process_name"] not in self.ListProcessNames :

self.ListProcessNames.append(process["process_name"])

# Si l'API actuellement checkée est une API pour supprimer des fichiers, # On vérifie si elle a été appelée pour supprimer l'un des processus créés par le programme analysé. if call["api"] == "DeleteFile" or call["api"] == "NtDeleteFile" or call["api"] == "ZwDeleteFile" :

# Recherche du processus dans notre liste for file in self.ListProcessNames :

if re.search(str(file).lower(),str(self.get_argument(call,"FileName")).lower()) != None : return True

(5) ANTI-DETECTION DE LA VIRTUALISATION par le malware analysé

a/ Recherche d'un outil pour détecter la virtualisation. Outil utilisé : Pafish.exe

https://www.alienvault.com/open-threat-exchange/blog/hardening-cuckoo-sandbox-against-vm-aware-malwarehttps://github.com/a0rtega/pafishhttp://www.behindthefirewalls.com/2014/02/hiding-your-cuckoo-sandbox-v10-from-malware.htmlhttps://github.com/jaimeblasco/AlienvaultLabs/blob/master/cuckoomon_hardened/cuckoomon_vbox_hardened.patch

b/ Premier test et premières améliorations :

_ Mettre plus de 50 GB de mémoire._ Enlever les additions invitées.

c/ Nécessité de modifier le fichier “cuckoomon.dll” (qui gère le hooking des API) pour améliorer encore l'anti-détection.

_ Nouveau “cuckoomon.dll”._ VirtualBox n'est plus détecté !

Analyse 103 : avec l'ancien cuckoomon./utils/submit.py --package exe --options arguments=--dosomething ~/Documents/LINUX_SAUVEGARDE/Pour_aller_plus_loin/VirtualBox/DossiersPartagesVirtualBox/WinXP/DownloadFromXP/pafish.exe

Analyse 106 : avec le cickoomon harder (harder2)

http://pascalbout.chez.com/bder_machine.htm

d/ Certains malwares changent de comportement lorsqu'ils ne déctectent pas de virtualisation !

Malxare “def.exe”.

AVANT : Analyse 22

APRES : Analyse 109

Analyses pertinentes : 118 ; 120 ; 128 ; 130 ; 131

on_call est une méthode abstraite. On peut lire dans la classe Signature :

def on_call(self, call, process):         """Notify signature about API call. Return value determines         if this signature is done or could still match.         @param call: logged API call.         @param process: process doing API call.         @raise NotImplementedError: this method is abstract.         """        raise NotImplementedError

Cette méthode est appelée dans la méthode run() de la classe RunSignatures :

  # Iterate calls and tell interested signatures about them             for proc in self.results["behavior"]["processes"]:                 for call in proc["calls"]: 

# Loop through active evented signatures.                     for sig in evented_list:                        try:                             result = sig.on_call(call, proc)                         except NotImplementedError:

Regardez la nature des variables proc et call : →