¶ Qu'est ce que Yara ?
"Le couteau suisse de recherche de modèles pour les chercheurs en logiciels malveillants (et tout le monde)" ( Virustotal., 2020 )
Avec une citation aussi appropriée, Yara peut identifier des informations basées à la fois sur des modèles binaires et textuels, tels que l'hexadécimal et les chaînes contenues dans un fichier.
Des règles sont utilisées pour étiqueter ces modèles. Par exemple, les règles Yara sont fréquemment écrites pour déterminer si un fichier est malveillant ou non, en fonction des fonctionnalités (ou modèles) qu'il présente. Les chaînes sont un composant fondamental des langages de programmation. Les applications utilisent des chaînes pour stocker des données telles que du texte.
Par exemple, l'extrait de code ci-dessous imprime « Hello World » en Python. Le texte « Hello World » serait stocké sous forme de chaîne.
print("Hello World!")
Nous pourrions écrire une règle Yara pour rechercher « hello world » dans chaque programme de notre système d'exploitation si nous le souhaitons.
Pourquoi les logiciels malveillants utilisent-ils des chaînes ?
Les logiciels malveillants, tout comme notre application « Hello World », utilisent des chaînes pour stocker des données textuelles. Voici quelques exemples de données que divers types de logiciels malveillants stockent dans des chaînes :
| Taper | Données | Description |
| Rançongiciel | 12t9YDPgwueZ9NyMgw519p7AA8isjr6SMw | Portefeuille Bitcoin pour le paiement des rançons |
| Réseau de robots | 12.34.56.7 | L'adresse IP du serveur de commande et de contrôle (C&C) |
Avertissement : analyse des logiciels malveillants
Expliquer la fonctionnalité des logiciels malveillants est largement hors de portée de cette salle en raison de l'ampleur du sujet. J'ai couvert les cordes beaucoup plus en détail dans la "Tâche 12 - Cordes" de mon MAL : Salle d'introduction . En fait, je crée tout un parcours d’apprentissage pour cela. Si vous souhaitez avoir un avant-goût tout en apprenant les bases, je vous recommande ma chambre.
¶ Règles Yara
Le langage propriétaire que Yara utilise pour les règles est assez simple à apprendre, mais difficile à maîtriser. En effet, votre règle n’est efficace que dans la mesure où vous comprenez les modèles que vous souhaitez rechercher.
Utiliser une règle Yara est simple. Chaque yaracommande nécessite deux arguments pour être valide, à savoir :
1) Le fichier de règles que nous créons
2) Le nom du fichier, du répertoire ou de l'ID de processus pour lequel utiliser la règle.
Chaque règle doit avoir un nom et une condition.
Par exemple, si nous voulions utiliser « marule.yar » sur le répertoire « somedirectory», nous utiliserions la commande suivante :
yara myrule.yar somedirectory
Notez que .yar est l'extension de fichier standard pour toutes les règles Yara. Nous établirons ci-dessous l’une des règles les plus élémentaires que vous puissiez établir.
1. Créez un fichier nommé " somefile " via touch somefile
2. Créez un nouveau fichier et nommez-le " myfirstrule.yar " comme ci-dessous :
Création d'un fichier nommé somefile
cmnatic@thm:~$ touch somefile
Création d'un fichier nommé myfirstrule.yar
cmnatic@thm touch myfirstrule.yar
3. Ouvrez "myfirstrule.yar" à l'aide d'un éditeur de texte tel que, nanosaisissez l'extrait ci-dessous et enregistrez le fichier :
rule examplerule {
condition: true
}
Saisir notre premier extrait dans "myfirstrule.yar" en utilisant nano
cmnatic@thm nano myfirstrule.yar GNU nano 4.8 myfirstrule.yar Modified
rule examplerule {
condition: true
}
Le nom de la règle dans cet extrait est examplerule, où nous avons une condition - dans ce cas, la condition est condition. Comme indiqué précédemment, chaque règle nécessite à la fois un nom et une condition pour être valide. Cette règle satisfait à ces deux exigences.
Simplement, la règle que nous avons établie vérifie si le fichier/répertoire/PID que nous spécifions existe via condition: true. Si le fichier existe, nous obtenons le résultat de examplerule
Essayons ceci sur le fichier "somefile" que nous avons créé à la première étape :
yara myfirstrule.yar somefile
Si "somefile" existe, Yara dira exampleruleparce que le modèle a été respecté - comme nous pouvons le voir. ci-dessous:
Vérifier que notre exemple de règle est correct
cmnatic@thm:~$ yara myfirstrule.yar somefile
examplerule somefile
Si le fichier n'existe pas, Yara affichera une erreur telle que celle ci-dessous :
Yara se plaint que le fichier n'existe pas
cmnatic@thm:~$ yara myfirstrule.yar sometextfile
error scanning sometextfile: could not open file
¶ Conditions Yara
onditions Yara (suite)...
Vérifier si un fichier existe ou non n'est pas très utile. Après tout, nous pouvons le découvrir par nous-mêmes... En utilisant de bien meilleurs outils pour le travail.
Yara a quelques conditions, que je vous encourage à lire ici à votre guise. Cependant, je vais en détailler quelques-uns ci-dessous et expliquer leur objectif.
| Mot-clé |
| Description |
| Méta |
| Cordes |
| Conditions |
| Poids |
¶ Méta
Cette section d'une règle Yara est réservée aux informations descriptives par l'auteur de la règle. Par exemple, vous pouvez utiliser desc, abréviation de description, pour résumer ce que votre règle vérifie. Tout ce qui se trouve dans cette section n'influence pas la règle elle-même. Semblable au commentaire de code, il est utile de résumer votre règle.
¶ Cordes
Vous vous souvenez de notre discussion sur les chaînes dans la tâche 2 ? Eh bien, c'est parti. Vous pouvez utiliser des chaînes pour rechercher du texte spécifique ou hexadécimal dans des fichiers ou des programmes. Par exemple, disons que nous voulions rechercher dans un répertoire tous les fichiers contenant « Hello World ! », nous créerions une règle telle que ci-dessous :
rule helloworld_checker{
strings:
$hello_world = "Hello World!"
}
Nous définissons le mot-clé Stringsoù se trouve la chaîne que nous voulons rechercher, c'est-à-dire "Hello World!" est stocké dans la variable. $hello_world
Bien sûr, nous avons besoin d'une condition ici pour rendre la règle valide. Dans cet exemple, pour faire de cette chaîne la condition, nous devons utiliser le nom de la variable. Dans ce cas, $hello_world :
rule helloworld_checker{
strings:
$hello_world = "Hello World!"
condition:
$hello_world
}
Essentiellement, si un fichier contient la chaîne « Hello World ! » alors la règle correspondra. Cependant, cela signifie littéralement que cela ne correspondra que si « Hello World ! » est trouvé et ne correspondra pas si " hello world " ou " HELLO WORLD ".
Pour résoudre ce problème, la condition any of thempermet de rechercher plusieurs chaînes, comme ci-dessous :
rule helloworld_checker{
strings:
$hello_world = "Hello World!"
$hello_world_lowercase = "hello world"
$hello_world_uppercase = "HELLO WORLD"
condition:
any of them
}
Maintenant, n'importe quel fichier avec les chaînes de :
1. Bonjour tout le monde !
2. bonjour tout le monde
3. BONJOUR LE MONDE
Va maintenant déclencher la règle.
¶ Conditions
Nous avons déjà utilisé la condition trueand any of them. Tout comme la programmation classique, vous pouvez utiliser des opérateurs tels que :
<= inférieur ou égal à
>= supérieur ou égal à
!= différent de
Par exemple, la règle ci-dessous aurait les effets suivants :
rule helloworld_checker{
strings:
$hello_world = "Hello World!"
condition:
#hello_world <= 10
}
La règle va désormais :
1. Recherchez le message « Hello World ! » chaîne
2. Dites uniquement que la règle correspond s'il y a moins ou égal à dix occurrences du message « Hello World ! » chaîne
¶ Combinaison de mots-clés
De plus, vous pouvez utiliser des mots-clés tels que :
and
not
or
Pour combiner plusieurs conditions. Dites que si vous souhaitez vérifier si un fichier contient une chaîne et est d'une certaine taille (dans cet exemple, l'exemple de fichier que nous vérifions fait moins de <10 Ko et contient "Hello World!", vous pouvez utiliser une règle comme ci-dessous :
rule helloworld_checker{
strings:
$hello_world = "Hello World!"
condition:
$hello_world and filesize < 10KB
}
La règle ne correspondra que si les deux conditions sont vraies. Pour illustrer : ci-dessous, la règle que nous avons créée, dans ce cas, ne correspond pas car bien que le fichier contienne "Hello World!", sa taille est supérieure à 10 Ko :
Yara ne parvient pas à faire correspondre le fichier mytextfile car il fait plus de 10 Ko
cmnatic@thm:~$ <output intentionally left blank>
Cependant, la règle correspondait cette fois car le fichier contenait à la fois "Hello World!" et une taille de fichier inférieure à 10 Ko .
Yara a réussi à faire correspondre le fichier mytextfile car il contient "Hello World" et une taille de fichier inférieure à 10 Ko
cmnatic@thm:~$ yara myfirstrule.yar mytextfile.txt
helloworld_textfile_checker mytextfile.txt
N'oubliez pas que le texte dans la case rouge est le nom de notre règle et que le texte dans la case verte est le fichier correspondant.
Anatomie d'une règle Yara
Le chercheur en sécurité de l'information "fr0gger_" a récemment créé une aide-mémoire pratique qui décompose et visualise les éléments d'une règle YARA (illustré ci-dessus, tous les crédits d'image lui reviennent). C'est un excellent point de référence pour commencer !
¶ Modules Yara
Intégration avec d'autres bibliothèques
Des frameworks tels que le Cuckoo Sandbox ou le module PE de Python vous permettent de décupler la technicité de vos règles Yara.
¶ Coucou
Cuckoo Sandbox est un environnement d'analyse automatisé des logiciels malveillants. Ce module vous permet de générer des règles Yara basées sur les comportements découverts dans Cuckoo Sandbox. À mesure que cet environnement exécute des logiciels malveillants, vous pouvez créer des règles sur des comportements spécifiques tels que les chaînes d'exécution, etc.
¶ PythonPE _
Le module PE de Python vous permet de créer des règles Yara à partir des différentes sections et éléments de la structure Windows Portable Executable (PE).
Expliquer cette structure est hors de portée car elle est couverte dans ma salle d'introduction aux logiciels malveillants . Cependant, cette structure constitue le formatage standard de tous les exécutables et fichiers DLL sous Windows. Y compris les bibliothèques de programmation utilisées.
L'examen du contenu d'un fichier PE est une technique essentielle dans l'analyse des logiciels malveillants ; en effet, des comportements tels que la cryptographie ou le vermifugation peuvent être largement identifiés sans ingénierie inverse ni exécution de l'échantillon.
¶ Autres outils et Yara
Savoir comment créer des règles Yara personnalisées est utile, mais heureusement, vous n'avez pas besoin de créer de nombreuses règles à partir de zéro pour commencer à utiliser Yara pour rechercher le mal. Il existe de nombreuses ressources GitHub et outils open source (ainsi que des produits commerciaux) qui peuvent être utilisés pour tirer parti de Yara dans le cadre d'opérations de chasse et/ou de missions de réponse aux incidents.
¶ LOKI (Quoi, pas qui, est Loki ?)
LOKI est un scanner IOC ( Indicator of Compromise ) open source gratuit créé/écrit par Florian Roth.
Basée sur la page GitHub, la détection repose sur 4 méthodes :
- Nom du fichier Vérification IOC
- Vérification des règles Yara (nous sommes ici)
- Vérification du hachage
- Vérification de la connexion arrière C2
Il existe des contrôles supplémentaires pour lesquels LOKI peut être utilisé. Pour un aperçu complet, veuillez consulter le fichier readme de GitHub .
LOKI peut être utilisé sur les systèmes Windows et Linux et peut être téléchargé ici .
Veuillez noter que vous n’êtes pas censé utiliser cet outil dans cette salle.
######################## Affichage du menu d'aide de Loki #############################
cmnatic@thm:~/Loki$ python3 loki.py -h
usage: loki.py [-h] [-p path] [-s kilobyte] [-l log-file] [-r remote-loghost]
[-t remote-syslog-port] [-a alert-level] [-w warning-level]
[-n notice-level] [--allhds] [--alldrives] [--printall]
[--allreasons] [--noprocscan] [--nofilescan] [--vulnchecks]
[--nolevcheck] [--scriptanalysis] [--rootkit] [--noindicator]
[--dontwait] [--intense] [--csv] [--onlyrelevant] [--nolog]
[--update] [--debug] [--maxworkingset MAXWORKINGSET]
[--syslogtcp] [--logfolder log-folder] [--nopesieve]
[--pesieveshellc] [--python PYTHON] [--nolisten]
[--excludeprocess EXCLUDEPROCESS] [--force]
Loki - Simple IOC Scanner
optional arguments:
-h, --help show this help message and exit
¶ THOR ( programmes nommés de super-héros pour un teamer bleu de super-héros)
THOR Lite est le tout nouveau scanner multiplateforme IOC ET YARA de Florian. Il existe des versions précompilées pour Windows, Linux et macOS. Une fonctionnalité intéressante de THOR Lite est sa limitation d'analyse pour limiter les ressources CPU épuisantes. Pour plus d'informations et/ou pour télécharger le binaire, commencez ici . Vous devez vous inscrire à leur liste de diffusion pour obtenir une copie du binaire. A noter que THOR s'adresse aux clients entreprises . THOR Lite est la version gratuite.
Veuillez noter que vous n’êtes pas censé utiliser cet outil dans cette salle.
#############################Affichage du menu d'aide de Thor Lite#############################
cmnatic@thm:~$ ./thor-lite-linux-64 -h
Thor Lite
APT Scanner
Version 10.7.3 (2022-07-27 07:33:47)
cc) Nextron Systems GmbH
Lite Version
> Scan Options
-t, --template string Process default scan parameters from this YAML file
-p, --path strings Scan a specific file path. Define multiple paths by specifying this option multiple times. Append ':NOWALK' to the path for non-recursive scanning (default: only the system drive) (default [])
--allhds (Windows Only) Scan all local hard drives (default: only the system drive)
--max_file_size uint Max. file size to check (larger files are ignored). Increasing this limit will also increase memory usage of THOR. (default 30MB)
> Scan Modes
--quick Activate a number of flags to speed up the scan at cost of some detection.
This is equivalent to: --noeventlog --nofirewall --noprofiles --nowebdirscan --nologscan --noevtx --nohotfixes --nomft --lookback 3 --lookback-modules filescan
¶ FENRIR (convention de nommage toujours à thème mythique)
Il s'agit du 3ème outil créé par Neo23x0 (Florian Roth). Tu l'as deviné; les 2 précédents sont nommés ci-dessus. La version mise à jour a été créée pour résoudre le problème de ses prédécesseurs, où les conditions doivent être remplies pour qu'ils fonctionnent. Fenrir est un script bash ; il fonctionnera sur n'importe quel système capable d'exécuter bash (aujourd'hui même Windows).
Veuillez noter que vous n’êtes pas censé utiliser cet outil dans cette salle.
#############################Exécuter Fenrir#############################
cmnatic@thm-yara:~/tools$ ./fenrir.sh
##############################################################
____ _
/ __/__ ___ ____(_)___
/ _// -_) _ \/ __/ / __/
/_/ \__/_//_/_/ /_/_/
v0.9.0-log4shell
Simple Bash IOC Checker
Florian Roth, Dec 2021
##############################################################
¶ YAYA ( Encore un autre automate Yara )
YAYA a été créé par l' EFF ( Electronic Frontier Foundation ) et publié en septembre 2020. D'après leur site Web, « YAYA est un nouvel outil open source pour aider les chercheurs à gérer plusieurs référentiels de règles YARA. YAYA commence par importer un ensemble de règles de haute qualité. YARA règles et permet ensuite aux chercheurs d'ajouter leurs propres règles, de désactiver des ensembles de règles spécifiques et d'exécuter des analyses de fichiers. "
Remarque : Actuellement, YAYA ne fonctionnera que sur les systèmes Linux .
#############################Lancer YAYA#############################
cmnatic@thm-yara:~/tools$ yaya
YAYA - Yet Another Yara Automaton
Usage:
yaya [-h]
-h print this help screen
Commands:
update - update rulesets
edit - ban or remove rulesets
add - add a custom ruleset, located at
scan - perform a yara scan on the directory at
Dans la section suivante, nous examinerons LOKI plus en détail...
¶ Utiliser LOKI
En tant qu'analyste de sécurité, vous devrez peut-être rechercher divers rapports de renseignements sur les menaces, articles de blog, etc. et recueillir des informations sur les dernières tactiques et techniques utilisées dans la nature, passées ou présentes. Généralement, dans ces lectures, les IOC (hachages, adresses IP, noms de domaine, etc.) seront partagés afin que des règles puissent être créées pour détecter ces menaces dans votre environnement, ainsi que les règles Yara. D'un autre côté, vous pourriez vous retrouver dans une situation où vous avez rencontré quelque chose d'inconnu , que votre pile d'outils de sécurité ne peut pas/n'a pas détecté. À l'aide d'outils tels que Loki, vous devrez ajouter vos propres règles en fonction de vos collectes de renseignements sur les menaces ou des résultats d'un engagement de réponse aux incidents (criminalistique).
Comme mentionné précédemment, Loki dispose déjà d'un ensemble de règles Yara dont nous pouvons bénéficier et commencer immédiatement à rechercher le mal sur le point final.
Accédez au répertoire Loki. Loki est situé dans le tools.
#############################Liste du répertoire des outils#############################
cmnatic@thm-yara:~/tools$ ls
Loki yarGen
Exécutez python loki.py -h pour voir quelles options sont disponibles.
Si vous exécutez Loki sur votre propre système, la première commande que vous devez exécuter est --update. Cela ajoutera le signature-base répertoire que Loki utilise pour rechercher le mal connu. Cette commande a déjà été exécutée dans la VM attachée.
#############################Liste du répertoire de base de signature de Loki#############################
cmnatic@thm-yara:~/tools/Loki/signature-base$ ls
iocs misc yara
Accédez au yararépertoire. N'hésitez pas à inspecter les différents fichiers Yara utilisés par Loki pour avoir une idée de ce que ces règles vont rechercher.
Pour exécuter Loki, vous pouvez utiliser la commande suivante ( notez que j'appelle Loki depuis le répertoire file 1 )
#############################Demander à Loki d'analyser le fichier suspect#############################
cmnatic@thm-yara:~/suspicious-files/file1$ python ../../tools/Loki/loki.py -p .
Scénario : Vous êtes l'analyste de sécurité pour un cabinet d'avocats de taille moyenne. Un collègue a découvert des fichiers suspects sur un serveur Web au sein de votre organisation. Ces fichiers ont été découverts lors de mises à jour du site Web de l'entreprise. Les fichiers ont été copiés sur votre machine pour analyse. Les fichiers se trouvent dans le suspicious-filesrépertoire.
¶ Créer des règles Yara avec yarGen
À partir de la section précédente, nous avons réalisé que nous avions un fichier sur lequel Loki n’avait pas signalé. À ce stade, nous ne pouvons pas exécuter Loki sur d’autres serveurs Web, car si le fichier 2 existe sur l’un des serveurs Web, il ne sera pas détecté.
Nous devons créer une règle Yara pour détecter ce shell Web spécifique dans notre environnement. C'est généralement ce qui est fait en cas d'incident, c'est-à-dire un événement qui affecte/impacte l'organisation de manière négative.
Nous pouvons ouvrir manuellement le fichier et tenter de parcourir lignes après lignes de code pour trouver des chaînes possibles pouvant être utilisées dans notre règle Yara nouvellement créée.
Vérifions le nombre de lignes de ce fichier particulier. Vous pouvez exécuter ce qui suit : strings <file name> | wc -l.
#############################Utiliser wc pour compter le nombre de lignes dans le fichier#############################
cmnatic@thm-yara:~/suspicious-files/file2$ strings 1ndex.php | wc -l
3580
Si vous essayez de parcourir manuellement chaque chaîne, ligne par ligne, vous comprendrez rapidement que cela peut être une tâche ardue.
#############################Récupérer la sortie de 1ndex.php#############################
if(res=='error'){
$('.ulProgress'+ulType+i).html('( failed )');
}
else{
$('.ulRes'+ulType+i).html(res);
}
loading_stop();
},
error: function(){
loading_stop();
$('.ulProgress'+ulType+i).html('( failed )');
$('.ulProgress'+ulType+i).removeClass('ulProgress'+ulType+i);
$('.ulFilename'+ulType+i).removeClass('ulFilename'+ulType+i);
}
});
}
function ul_go(ulType){
ulFile = (ulType=='comp')? $('.ulFileComp'):$('.ulFileUrl');
ulResult = (ulType=='comp')? $('.ulCompResult'):$('.ulUrlResult');
ulResult.html('');
ulFile.each(function(i){
if(((ulType=='comp')&&this.files[0])||((ulType=='url')&&(this.value!=''))){
file = (ulType=='comp')? this.files[0]: this.value;
filename = (ulType=='comp')? file.name: file.substring(file.lastIndexOf('/')+1);
ulSaveTo = (ulType=='comp')? $('.ulSaveToComp')[i].value:$('.ulSaveToUrl')[i].value;
ulFilename = (ulType=='comp')? $('.ulFilenameComp')[i].value:$('.ulFilenameUrl')[i].value;
--snippet cropped for brevity--
Heureusement , nous pouvons utiliser yarGen (oui, un autre outil créé par Florian Roth) pour nous aider dans cette tâche.
Qu’est-ce que yarGen ? yarGen est un générateur de règles YARA.
Extrait du README - " Le principe principal est la création de règles yara à partir des chaînes trouvées dans les fichiers malveillants tout en supprimant toutes les chaînes qui apparaissent également dans les fichiers goodware. Par conséquent, yarGen inclut une grande base de données de chaînes goodware et d'opcodes sous forme d'archives ZIP qui doivent être extraites. avant la première utilisation ."
Accédez au yarGenrépertoire qui se trouve dans tools. Si vous exécutez yarGen sur votre propre système, vous devez d'abord le mettre à jour en exécutant la commande suivante : python3 yarGen.py --update.
Cela mettra à jour les bases de données good-opcodes et good-strings du référentiel en ligne. Cette mise à jour prendra quelques minutes.
Une fois la mise à jour réussie, vous verrez le message suivant à la fin de la sortie.
#############################Mise à jour de yarGen#############################
cmnatic@thm-yara:~/tools/yarGen$ python3 yarGen.py --update
------------------------------------------------------------------------
_____
__ _____ _____/ ___/__ ___
/ // / _ `/ __/ (_ / -_) _ \
\_, /\_,_/_/ \___/\__/_//_/
/___/ Yara Rule Generator
Florian Roth, July 2020, Version 0.23.3
Note: Rules have to be post-processed
See this post for details: https://medium.com/@cyb3rops/121d29322282
------------------------------------------------------------------------
Downloading good-opcodes-part1.db from https://www.bsk-consulting.de/yargen/good-opcodes-part1.db ...
Pour utiliser yarGen afin de générer une règle Yara pour le fichier 2, vous pouvez exécuter la commande suivante :
python3 yarGen.py -m /home/cmnatic/suspicious-files/file2 --excludegood -o /home/cmnatic/suspicious-files/file2.yar
Une brève explication des paramètres ci-dessus :
-mest le chemin d'accès aux fichiers pour lesquels vous souhaitez générer des règles--excludegoodforcer à exclure toutes les chaînes de goodware ( ce sont des chaînes trouvées dans des logiciels légitimes et peuvent augmenter les faux positifs )-oemplacement et nom avec lesquels vous souhaitez afficher la règle Yara
Si tout va bien, vous devriez voir le résultat suivant.
Utiliser yarGen pour générer une règle pour le fichier2
[=] Generated 1 SIMPLE rules.
[=] All rules written to /home/cmnatic/suspicious-files/file2.yar
[+] yarGen run finished
En règle générale, vous examinerez la règle Yara et supprimerez toutes les chaînes qui, selon vous, pourraient générer des faux positifs. Pour cet exercice, nous laisserons la règle Yara générée telle quelle et testerons pour voir si Yara signalera le fichier 2 ou non.
Remarque : Un autre outil créé pour vous aider s'appelle yarAnalyzer (vous l'aurez deviné - créé par Florian Roth). Nous n'examinerons pas cet outil dans cette salle, mais vous devriez le lire, surtout si vous décidez de commencer à créer vos propres règles Yara.
Lectures complémentaires sur la création de règles Yara et l'utilisation de yarGen :
-
https://www.bsk-consulting.de/2015/02/16/write-simple-sound-yara-rules/
-
https://www.bsk-consulting.de/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/
-
https://www.bsk-consulting.de/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/
¶ Valhalla
Valhalla est un flux Yara en ligne créé et hébergé par Nextron-Systems (euh, Florian Roth). À présent, vous devriez être conscient du temps et de l’énergie ridicules que Florian a consacrés à la création de ces outils pour la communauté. Peut-être aurions-nous dû simplement appeler cela la salle Florian Roth. (mdr)
Selon le site Web, " Valhalla améliore vos capacités de détection grâce à la puissance de milliers de règles YARA de haute qualité fabriquées à la main. "
À partir de l'image ci-dessus, nous devons indiquer que nous pouvons effectuer des recherches basées sur un mot-clé, une balise, une technique ATT&CK, sha256 ou un nom de règle.
Remarque : Pour plus d'informations sur ATT&CK, veuillez visiter la salle MITRE .
En examinant les données qui nous ont été fournies, examinons la règle dans la capture d'écran ci-dessous :
Nous recevons le nom de la règle, une brève description, un lien de référence pour plus d'informations sur la règle, ainsi que la date de la règle.
N'hésitez pas à regarder quelques règles pour vous familiariser avec l'utilité du Valhalla. La meilleure façon d’apprendre le produit est de se lancer directement.
En reprenant notre scénario, à ce stade, vous savez que les 2 fichiers sont liés. Même si Loki a classé les fichiers comme suspects, vous savez au fond de votre instinct qu’ils sont malveillants. D'où la raison pour laquelle vous avez créé une règle Yara en utilisant yarGen pour la détecter sur d'autres serveurs Web. Mais imaginons en outre que vous n'êtes pas doué en code (pour information, tous les professionnels de la sécurité ne savent pas comment coder/scripter ou le lire). Vous devez effectuer des recherches plus approfondies concernant ces fichiers pour recevoir l’autorisation de les éradiquer du réseau.
Il est temps d'utiliser Valhalla pour collecter des renseignements sur les menaces...