cyberchef recipes
1.0.0
CyberChef est le soi-disant « cyber-couteau suisse » créé par le GCHQ. C'est un outil fantastique pour la transformation, l'extraction et la manipulation de données dans votre navigateur Web.
Crédit complet à @GCHQ pour la production de l'outil. Voir : https://gchq.github.io/CyberChef/
La maîtrise des expressions régulières est essentielle pour tirer le meilleur parti de la manipulation des données dans CyberChef (ou dans tout autre travail DFIR). Vous trouverez ci-dessous quelques expressions régulières auxquelles je reviens sans cesse.
Extraire Base64 : [a-zA-Z0-9+/=]{30,}
Extraire l'hexadécimal : [a-fA-F0-9]{10,}
Extraire les codes de caractères : [d]{2,3}(,|')
(?<=foo)(.*)^.*(?=bar)(?<=')(.*?)(?=')
CyberChef propose une opération HTTP Request (voir recette 22) qui permet les requêtes HTTP vers des ressources externes. En raison de la politique de même origine (SOP) ou du manque de configuration du partage de ressources entre origines croisées, beaucoup ne fonctionnent pas. SOP est une mesure de sécurité dans les navigateurs modernes qui vous empêche de lire les réponses intersites de serveurs qui ne l'autorisent pas explicitement via CORS. Consultez la conférence de @GlassSec sur CyberChef qui comprend des conseils pour démarrer Chrome sans sécurité Web afin d'activer les requêtes HTTP vers des API autrement restreintes (comme Virus Total)
Quelques exemples de recettes CyberChef :
Recette 1 : Extraire la base64, gonfler et embellir cru
Recette 2 : Invoquer l’obscurcissement
Recette 3 : à partir de CharCode
Recette 4 : Déchiffrement du mot de passe des préférences de stratégie de groupe
Recette 5 : Utiliser des boucles et des étiquettes
Recette 6 : horodatages Google ei
Recette 7 : Scriptlet COM en plusieurs étapes vers un assemblage x86
Recette 8 : Extraire le format hexadécimal, le convertir en hexadécimal pour le fichier PE intégré
Recette 9 : chaînes inversées, substitution de caractères, à partir de base64
Recette 10 : Extraire l'objet du cache proxy Squid
Recette 11 : Extraire les coordonnées GPS vers les URL de Google Maps
Recette 12 : Traitement des grands nombres
Recette 13 : Analyse des enregistrements DNS PTR avec des registres
Recette 14 : Décoder les exécutables POSHC2
Recette 15 : Analyse des horodatages $MFT $SI
Recette 16 : Décoder les webshells PHP gzinflate et base64
Recette 17 : Extraction du shellcode d'un script TCP inversé Powershell Meterpreter
Recette 18 : Analyseur de corbeille avec sous-sections et fusions
Recette 19 : Identifier le Base64 obscurci avec la mise en évidence des expressions régulières
Recette 20 : Utilisation des règles Yara avec des scripts malveillants désobscurcis
Recette 21 : Déobscurcissement en ligne d'un script VBE codé en hexadécimal attaché à un fichier LNK malveillant
Recette 22 : Recherche API JA3 avec requête HTTP et registres
Recette 23 : Vaincre DOSfuscation intégré dans un fichier DOC malveillant avec des groupes de capture d'expressions régulières
Recette 24 : Choisir une lettre aléatoire dans une chaîne de six octets
Recette 25 : Créer un code QR Wifi
Recette 26 : Extraction et décodage d'un Webshell PHP à plusieurs étapes
Recette 27 : Décoder un script PHP Auto Visitor
Recette 28 : Désobscurcissement de la balise de frappe au cobalt à l'aide de sauts conditionnels pour obtenir le shellcode
Recette 29 : Manipulation de l'horodatage des fichiers journaux avec des sous-sections et des registres
Recette 30 : Chargeur PowerShell obscurci par CharCode pour une balise Cobalt Strike
Recette 31 : Désobscurcir les chaînes codées dans le binaire .NET
Recette 32 : Extraire la DLL Gootkit malveillante des données de registre obscurcies
Recette 33 : Identifier les URL intégrées dans le script Emotet PowerShell
Recette 34 : Analyse des fichiers OOXML pour les URL
Recette 35 : Décryptage d'un exemple de ransomware REvil PowerShell
Recette 36 : Créer un générateur de mots de passe CyberChef
Recette 37 : De l'e-mail compressé Sandbox à l'URL malveillante
Recette 38 : Avions, crânes et enveloppes – Live and Let PowerShell
Recette 39 : Décrypter les fichiers de configuration cryptés de GoldMax, alias Sunshutte
Recette 40 : La folie du code Morse
Recette 41 : Codage PHP mixte hexadécimal et octal
Recette 42 : PHP Webshell avec obscurcissement en couches
Recette 43 : Déobscurcissement du skimmer Magento
Recette 44 : Décrypter le ransomware JobCrypter
Recette 45 : Conversion de l'horodatage du journal du proxy Sqiud
Recette 46 : Adapter votre regex à la situation
Recette 47 : Script Trickbot Visual Basic
Recette 48 : vjw0rm Emoji Madness
Recette 49 : Démonter un fichier de test EICAR
Recette 50 : Analyser la sortie du langage de définition du descripteur de sécurité
Recette 51 : Décodeur Base-45
Recette 52 : Randomiser la liste des éléments
Recette 53 : Sortie Olevba vers Powershell
Recette 54 : hachages de l'ID d'événement Windows 1029
Recette 55 : Débofuscation de BazarLoader alias TA551 maldoc
Recette 56 : Calculer et rechercher les valeurs de hachage JA3 ou JA3S à partir d'un PCAP
Recette 57 : Créez un mème avec CyberChef
Recette 58 : Extraire l'URL de deuxième étape IcedID d'un maldoc
Recette 59 : Analyser la configuration de la balise Cobalt Strike
Recette 60 : Décoder les URL protégées par Microsoft Safelinks
Recette 61 : Extraire les URL de deuxième étape des maldocs Qakbot Excel
Recette 62 : Emotet Maldoc vers PowerShell
Recette 63 : Extraire les URL du VBS obscurci par Dridex
Recette 64 : Convertir des chaînes en requêtes VirusTotal Grep
Recette 65 : Désobfusquer la charge utile du shell inversé MSF Venom PowerShell
Recette 66 : Exemple de sous-section imbriquée
Recette 67 : Conversion d'un ProductCode MSI en ProductID du programme d'installation du registre
Recette 68 : Conversion de tableaux d'octets signés Java
Recette 69 : Extraire la charge utile DLL d'un script Bumblebee Powershell
Recette 70 : Extraction des points de terminaison de la configuration de sécurité du réseau Android
Un scénario très courant : extraire le Base64, gonfler, embellir le code. Vous devrez peut-être ensuite effectuer un traitement supplémentaire ou une analyse dynamique en fonction de l'étape suivante.
Nom du fichier : ahack.bat
Fichier zippé : cc9c6c38840af8573b8175f34e5c54078c1f3fb7c686a6dc49264a0812d56b54_183SnuOIVa.bin.gz
Échantillon : SHA256 cc9c6c38840af8573b8175f34e5c54078c1f3fb7c686a6dc49264a0812d56b54
https://www.hybrid-analysis.com/sample/cc9c6c38840af8573b8175f34e5c54078c1f3fb7c686a6dc49264a0812d56b54?environmentId=120
[{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]},{"op":"Generic Code Beautify","args":[]}]
CyberChef ne sera pas capable de gérer tous les types d'invocation-obfuscation, mais en voici une qui peut être décodée.
Nom du fichier : Accusé de réception NUT-95-52619.eml
Fichier zippé : 1240695523bbfe3ed450b64b80ed018bd890bfa81259118ca2ac534c2895c835.bin.gz
Échantillon : SHA256 1240695523bbfe3ed450b64b80ed018bd890bfa81259118ca2ac534c2895c835
https://www.hybrid-analysis.com/sample/1240695523bbfe3ed450b64b80ed018bd890bfa81259118ca2ac534c2895c835?environmentId=120
[{"op":"Find / Replace","args":[{"option":"Regex","string":"\^|\\|-|_|\/|\s"},"",true,false,true,false]},{"op":"Reverse","args":["Character"]},{"op":"Generic Code Beautify","args":[]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"http:"},"http://",true,false,true,false]},{"op":"Extract URLs","args":[false]},{"op":"Defang URL","args":[true,true,true,"Valid domains and full URLs"]}]
Les logiciels malveillants et les scripts utilisent souvent Charcode pour représenter des caractères afin d'échapper aux solutions AV et EDR. CyberChef mange ça.
Nom du fichier : 3431818-f71f60d10b1cbe034dc1be242c6efa5b9812f3c6.zip
Source : https://gist.github.com/jonmarkgo/3431818
[{"op":"Regular expression","args":["User defined","([0-9]{2,3}(,\s|))+",true,true,false,false,false,false,"List matches"]},{"op":"From Charcode","args":["Comma",10]},{"op":"Regular expression","args":["User defined","([0-9]{2,3}(,\s|))+",true,true,false,false,false,false,"List matches"]},{"op":"From Charcode","args":["Space",10]}]
Lorsqu'un nouveau GPP est créé, un fichier XML associé est créé dans SYSVOL avec les données de configuration pertinentes et si un mot de passe est fourni, il est crypté AES-256 bits. Microsoft a publié la clé AES, qui peut être utilisée pour déchiffrer les mots de passe stockés dans : \SYSVOL<DOMAIN>Policies
Crédit : @cyb3rops
Source 1 : https://twitter.com/cyb3rops/status/1036642978167758848
Source 2 : https://adsecurity.org/?p=2288
[{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"To Hex","args":["None"]},{"op":"AES Decrypt","args":[{"option":"Hex","string":"4e9906e8fcb66cc9faf49310620ffee8f496e806cc057990209b09a433b66c1b"},{"option":"Hex","string":""},"CBC","Hex","Raw",{"option":"Hex","string":""}]},{"op":"Decode text","args":["UTF16LE (1200)"]}]
CyberChef peut utiliser des étiquettes pour identifier des parties de la recette, puis revenir en arrière pour effectuer des opérations plusieurs fois. Dans cet exemple, 29 cycles de codage Base64 sont extraits et décodés.
Crédit : @pmelson
Fichier source : hmCPDnHs.txt
Source 1 : https://pastebin.com/hmCPDnHs
Source 2 : https://twitter.com/pmelson/status/1078776229996752896
Voir également plus d'exemples de boucles sur Base64 : https://twitter.com/QW5kcmV3/status/1079095274776289280 (Crédit : @QW5kcmV3)
[{"op":"Label","args":["top"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]},{"op":"Jump","args":["top",28]},{"op":"Generic Code Beautify","args":[]}]
Google utilise son propre horodatage, j'appelle ei time, qu'il intègre dans l'URL.
Source : https://bitofhex.com/2018/05/29/cyberchef/
[{"op":"From Base64","args":["A-Za-z0-9-_=",true]},{"op":"To Hex","args":["None"]},{"op":"Take bytes","args":[0,8,false]},{"op":"Swap endianness","args":["Hex",4,true]},{"op":"From Base","args":[16]},{"op":"From UNIX Timestamp","args":["Seconds (s)"]}]
Il s'agit d'un scriptlet COM décodé en onze étapes qui utilise les instructions Base64, Gunzip, RegEx et Disassemble x86.
Crédit : @JohnLaTwC
Nom du fichier : 41a6e22ec6e60af43269f4eb1eb758c91cf746e0772cecd4a69bb5f6faac3578.txt
Source 1 : https://gist.githubusercontent.com/JohnLaTwC/aae3b64006956e8cb7e0127452b5778f/raw/f1b23c84c65 4b1ea60f0e57a860c74385915c9e2/43cbbbf93121f3644ba26a273ebdb54d8827b25eb9c754d3631be395f06d8cff
Source 2 : https://twitter.com/JohnLaTwC/status/1062419803304976385
[{"op":"Regular expression","args":["","[A-Za-z0-9=/]{40,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Remove null bytes","args":[]},{"op":"Regular expression","args":["User defined","[A-Za-z0-9+/=]{40,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Gunzip","args":[]},{"op":"Regular expression","args":["User defined","[A-Za-z0-9+/=]{40,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"To Hex","args":["Space"]},{"op":"Remove whitespace","args":[true,true,true,true,true,false]},{"op":"Disassemble x86","args":["32","Full x86 architecture",16,0,true,true]}]
Ce fichier contient un fichier PE intégré (SHA 256 : 26fac1d4ea12cdceac0d64ab9694d0582104b3c84d7940a4796c1df797d0fdc2, R5Sez8PH.exe, VT : 54/70). En utilisant CyberChef, nous pouvons regex hexadécimal et le convertir en un hexadécimal plus facilement visible.
Source 1 : https://pastebin.com/R5Sez8PH (désolé : plus disponible !)
Source 2 : https://twitter.com/ScumBots/status/1081949877272276992
[{"op":"Regular expression","args":["User defined","[a-fA-F0-9]{200,}",true,true,false,false,false,false,"List matches"]},{"op":"From Hex","args":["Auto"]},{"op":"To Hexdump","args":[16,false,false]}]
Un blob de base64 avec quelques octets mineurs à remplacer. Décodage original réalisé par @pmelson en Python et converti en CyberChef.
Crédit : @pmelson
Source 1 : https://pastebin.com/RtjrweYF / RtjrweYF.txt
Source 2 : https://twitter.com/pmelson/status/1076893022758100998
[{"op":"Reverse","args":["Character"]},{"op":"Find / Replace","args":[{"option":"Regex","string":"%"},"A",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"×"},"T",true,false,false,false]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"÷"},"V",true,false,false,false]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"To Hexdump","args":[16,false,false]}]
Ne supprimez pas manuellement vos objets de cache Squid. Téléchargez simplement le fichier sur CyberChef. Cette recette recherchera les octets magiques 0x0D0A0D0A, extraira tout après. Il décompresse ensuite l'objet pour le téléchargement.
Source : 00000915 (la sortie doit être TrueCrypt_Setup_7.1a.exe avec SHA256 e95eca399dfe95500c4de569efc4cc77b75e2b66a864d467df37733ec06a0ff2)
[{"op":"To Hex","args":["None"]},{"op":"Regular expression","args":["User defined","(?<=0D0A0D0A).*$",true,false,false,false,false,false,"List matches"]},{"op":"From Hex","args":["Auto"]},{"op":"Gunzip","args":[]}]
Si vous avez besoin de trier rapidement l'endroit où une photo a été prise et que vous avez la chance d'avoir une latitude et une longitude GPS intégrées, utilisez cette recette pour créer rapidement une URL Google Maps utilisable pour identifier l'emplacement.
[{"op":"Extract EXIF","args":[]},{"op":"Regular expression","args":["User defined","((?<=GPSLatitude:).*$)|((?<=GPSLongitude: ).*$)",true,true,false,false,false,false,"List matches"]},{"op":"Find / Replace","args":[{"option":"Extended (\n, \t, \x...)","string":"\n"},",",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Simple string","string":" "},"https://maps.google.com/?q=",true,false,true,false]}]
CyberChef peut gérer des chiffres massifs. Ici, nous pouvons utiliser une recette simple pour remplacer un X509SerialNumber à 38 chiffres par son numéro de série de certificat X.509 équivalent en hexadécimal. Ensuite, nous pouvons regexer l'hexadécimal et insérer deux points pour le transformer au format correct.
Crédit : @QW5kcmV3
Source : https://twitter.com/QW5kcmV3/status/949437437473968128
[{"op":"To Base","args":[16]},{"op":"Regular expression","args":["User defined","[a-f0-9]{2,2}",true,true,false,false,false,false,"List matches"]},{"op":"Find / Replace","args":[{"option":"Extended (\n, \t, \x...)","string":"\n"},":",true,false,true,false]}]
Les adresses IP dans les enregistrements DNS PTR sont stockées en premier sous la forme de l'octet le moins significatif. Par exemple : 167.139.44.10.in-addr.arpa serait lié à l'adresse IP 10.44.139.167. En utilisant les registres de CyberChef, nous pouvons allouer chaque octet à un registre mémoire (ou à une variable si c'est plus facile d'y penser de cette façon). Ceux-ci peuvent ensuite être inversés pour réorganiser l’adresse IP. Une recherche/remplacement met de l'ordre dans le reste de l'enregistrement. Cela pourrait être inversé si vous vouliez traduire des adresses IP « normales » pour effectuer une recherche dans les enregistrements DNS PTR.
[{"op":"Fork","args":["\n","\n",false]},{"op":"Register","args":["(\d{1,3}).(\d{1,3}).(\d{1,3}).(\d{1,3})",true,false,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"$R0.$R1.$R2.$R3"},"$R3.$R2.$R1.$R0",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":".in-addr.arpa"},"",true,false,true,false]}]
PoshC2 est un framework C2 compatible proxy qui utilise Powershell pour aider les testeurs d'intrusion dans les tâches d'équipe rouge, de post-exploitation et de mouvement latéral. Le compte-gouttes est basé sur PowerShell et consiste en un script PowerShell doublement codé et compressé en Base64. L'extraction des chaînes peut être effectuée avec CyberChef comme détaillé ci-dessous. En fonction des paramètres et de la personnalisation de l'exécutable, vous devrez peut-être ajuster votre recette.
Crédit : @a_tweeter_user
Source : https://twitter.com/a_tweeter_user/status/1100751236687642624
Source : posh.zip
[{"op":"Strings","args":["All",4,"Alphanumeric + punctuation (A)",false]},{"op":"Remove null bytes","args":[]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+=]{200,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Remove null bytes","args":[]},{"op":"Regular expression","args":["User defined","[a-z0-9/\\+=]{100,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]}]
CyberChef peut faire à peu près tout avec les données. Voici les octets hexadécimaux bruts d'une entrée $MFT. En sélectionnant certains octets et en utilisant diverses fonctions de CyberChef, je peux analyser n'importe quelle partie des données selon mes besoins. Cette recette extraira et analysera les horodatages $SI. N'enfermez plus !
[{"op":"Take bytes","args":[160,64,false]},{"op":"Regular expression","args":["User defined",".{16}",true,true,true,false,false,false,"List matches with capture groups"]},{"op":"Fork","args":["\n","\n",false]},{"op":"Swap endianness","args":["Hex",10,true]},{"op":"Remove whitespace","args":[true,true,true,true,true,false]},{"op":"Windows Filetime to UNIX Timestamp","args":["Nanoseconds (ns)","Hex"]},{"op":"From UNIX Timestamp","args":["Nanoseconds (ns)"]},{"op":"Merge","args":[]},{"op":"Register","args":["(.*)\n(.*)\n(.*)\n(.*)",true,false,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"$R0"},"$SI Creation Time: $R0",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"$R1"},"$SI Modified Time: $R1",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"$R2"},"$SI MFT Change Time: $R2",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"$R3"},"$SI Access Time: $R3",false,false,true,false]}]
Les Webshells sont de toutes formes et tailles. Pour les webshells PHP, la combinaison de gzinflate et base64 peut être utilisée pour obscurcir les données d'évaluation. Dans cet exemple, il y a 21 cycles de compression et base64 que nous pouvons analyser rapidement à l'aide d'étiquettes et de boucles.
Source : https://github.com/LordWolfer/webshells/blob/b7eefaff64049e3ff61e90c850686135c0ba74c4/from_the_wild1.php
[{"op":"Label","args":["start"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9=/+]{10,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Block",false,false]},{"op":"Jump","args":["start",21]}]
Souvent vu dans le bot Pastbin de @pmelson @scumbots, cela supprime plusieurs couches d'un script Powershell codé pour afficher le shellcode. À partir de là, vous pouvez extraire les instructions PUSH pour essayer d'identifier l'adresse IP et le port, mais vous obtiendrez trop de faux positifs. Il est donc préférable d'utiliser un outil comme scdbg (voir : http://sandsprite.com/blogs/index.php?uid=7&pid=152)
Source : https://twitter.com/ScumBots/status/1121854255898472453
Source : https://pastebin.com/9DnD6t6W/9DnD6t6W.txt
[{"op":"Regular expression","args":["User defined","[a-zA-Z0-9=/+]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Remove null bytes","args":[]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9=/+]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Gunzip","args":[]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9=/+]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"To Hex","args":["None"]},{"op":"Disassemble x86","args":["32","Full x86 architecture",16,0,true,true]}]
Les sous-sections et les fusions sont des outils puissants dans CyberChef qui permettent d'appliquer des ingrédients à une sélection de données plutôt qu'à l'ensemble du fichier d'entrée. Cette section peut ensuite être fusionnée pour continuer sur l’ensemble de la saisie. Dans un travail impressionnant, @GlassSec a créé un analyseur de corbeille Windows à l'aide de CyberChef, indiquant que les possibilités de ces fonctions sont infinies.
Source : https://gist.github.com/glassdfir/f30957b314ec39a8aa319420a29ffc76
Crédit : https://twitter.com/GlassSec
[{"op":"Conditional Jump","args":["^(\x01|\x02)",true,"Error",10]},{"op":"Find / Replace","args":[{"option":"Regex","string":"^(\x02.{23})(....)"},"$1",false,false,false,false]},{"op":"Subsection","args":["^.{24}(.*)",true,true,false]},{"op":"Decode text","args":["UTF16LE (1200)"]},{"op":"Find / Replace","args":[{"option":"Regex","string":"^(.*)."},"\nDeleted File Path: $1",false,false,false,false]},{"op":"Merge","args":[]},{"op":"Subsection","args":["^.{16}(.{8})",false,true,false]},{"op":"Swap endianness","args":["Raw",8,true]},{"op":"To Hex","args":["None"]},{"op":"Windows Filetime to UNIX Timestamp","args":["Seconds (s)","Hex"]},{"op":"From UNIX Timestamp","args":["Seconds (s)"]},{"op":"Find / Replace","args":[{"option":"Regex","string":"^(.* UTC)"},"\nFile Deletion Time: $1",true,false,true,false]},{"op":"Merge","args":[]},{"op":"Subsection","args":["^.{8}(.{8})",true,true,false]},{"op":"To Hex","args":["None"]},{"op":"Swap endianness","args":["Hex",8,true]},{"op":"From Base","args":[16]},{"op":"Find / Replace","args":[{"option":"Regex","string":"^(.*)"},"\nDeleted File Size: $1 bytes",true,false,true,true]},{"op":"Merge","args":[]},{"op":"Find / Replace","args":[{"option":"Regex","string":"^.{8}"},"******** WINDOWS RECYCLE BIN METADATA ********",true,false,false,false]},{"op":"Jump","args":["Do Nothing",10]},{"op":"Label","args":["Error"]},{"op":"Find / Replace","args":[{"option":"Regex","string":"^.*$"},"This doesn't look like a Recycle Bin file to me ",true,false,true,false]},{"op":"Label","args":["Do Nothing"]}]
Moins une recette et plus une technique. L'utilisation de la fonction « surligner » de l'ingrédient d'expression régulière peut clairement faire ressortir où les données base64 ont été divisées avec un jeu de caractères base64 non traditionnel. Ici la séquence '@<!' est utilisé pour obscurcir et perturber la conversion de codage automatisée. En regardant plus bas dans le script, la séquence est remplacée par « A », qui peut ensuite être inséré avec un Rechercher/Remplacer avant l'extraction. Cela continue pendant plusieurs tours jusqu'à ce qu'un domaine d'intérêt soit révélé (avec un préalable exécutable).
Source : https://pastebin.com/TmJsB0Nv et https://twitter.com/pmelson/status/1167065236907659264
[{"op":"Find / Replace","args":[{"option":"Simple string","string":"@<!"},"A",true,false,true,false]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{20,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{50,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"@<!"},"A",true,false,true,false]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{50,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]}]
Bien que ce ne soit pas le moyen le plus pratique, CyberChef offre la possibilité d'exécuter une règle Yara sur le résultat d'une recette. Vous pouvez combiner cela en utilisant la fonction d'entrées multiples pour analyser un plus grand nombre de fichiers.
Source : https://twitter.com/ScumBots/status/1168528510681538560 et https://pastebin.com/r40SXe7V
[{"op":"Regular expression","args":["User defined","\(.*\);",true,false,false,false,false,false,"List matches"]},{"op":"Find / Replace","args":[{"option":"Regex","string":",|\(|\);"}," ",true,false,true,false]},{"op":"From Charcode","args":["Space",10]},{"op":"YARA Rules","args":["rule SuspiciousPowerShell {n meta:n description = "Testing Yara on Cyberchef for Powershell"n strings:n $a1 = "[System.Reflection.Assembly]" asciin $a2 = "IEX" ascii nocasen $a3 = "powershell.exe -w hidden -ep bypass -enc" asciin condition:n 2 of themn}",true,true,true,true]}]
Cette recette extrait une charge utile VBE d'un fichier de raccourci Microsoft (LNK), puis décode les chaînes hexadécimales en ligne à l'aide de sous-sections.
Source : malveillant.lnk.bin
[{"op":"Microsoft Script Decoder","args":[]},{"op":"Subsection","args":["(?<=\(\")(.*?)(?=\"\))",true,true,false]},{"op":"Fork","args":["\n","\n",false]},{"op":"From Hex","args":["Auto"]}]
En utilisant la fonction HTTP Request et les registres, nous pouvons enrichir les données avec celles d'une API ou d'une ressource externe. Ici, nous recherchons trois hachages JA3 pour tout problème connu.
Source : hachages d'entrée : 1aa7bf8b97e540ca5edd75f7b8384bfa, 1be3ecebe5aa9d3654e6e703d81f6928 et b386946a5a44d1ddcc843bc75336dfce
[{"op":"Comment","args":["https://ja3er.com/search/hash"]},{"op":"Fork","args":["\n","\n",false]},{"op":"Register","args":["(.*)",true,false,false]},{"op":"HTTP request","args":["GET","https://ja3er.com/search/$R0","","Cross-Origin Resource Sharing",false]},{"op":"JSON Beautify","args":[" ",false]}]
Ce fichier DOC malveillant est téléchargé directement depuis Hybrid-Analysis. Nous le extrayons, sélectionnons la dosfuscation avec une expression régulière, puis sélectionnons la section critique utilisée avec la fonction « set ». Cette section est désobscurcie avec une boucle for inversée avec un pas de trois. Ainsi, une fois sélectionnée, nous inversons la chaîne et utilisons des groupes de capture d'expressions régulières pour sélectionner un caractère sur trois. C'est un excellent travail de Hack eXPlorer sur YouTube. Allez-y et regardez !
Source : Untitled-11232018-659370.doc.bin.gz
Crédit : Adapté de la vidéo de Hack eXPlorer Cacher du code malveillant à l'aide de Windows CMD - Dosfuscation
[{"op":"Gunzip","args":[]},{"op":"Regular expression","args":["User defined","c:\\.*"",true,true,false,false,false,false,"List matches"]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"^"},"",true,false,true,false]},{"op":"Regular expression","args":["User defined","(?<=9ojB\=)(.*?)(?=\) )",true,true,false,false,false,false,"List matches"]},{"op":"Reverse","args":["Character"]},{"op":"Regular expression","args":["User defined","(.)..",true,true,false,false,false,false,"List capture groups"]},{"op":"Find / Replace","args":[{"option":"Regex","string":"\n"},"",true,false,true,false]},{"op":"Extract URLs","args":[false]},{"op":"Extract domains","args":[true]}]
Une demande d'assistance a conduit à cette recette qui utilise des registres, une requête HTTP et des Regex pour sélectionner un caractère aléatoire dans une chaîne de six octets.
Crédit : Adapté de Steve Thompson
[{"op":"Register","args":["(.*)",true,false,false]},{"op":"HTTP request","args":["GET","https://www.random.org/integers/?num=1&min=1&max=6&col=1&base=10&format=plain&rnd=new","","Cross-Origin Resource Sharing",false]},{"op":"Register","args":["(.)",true,false,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"(.)"},"$R0",true,false,true,false]},{"op":"Regular expression","args":["User defined","(.){$R1}",true,true,false,false,false,false,"List capture groups"]},{"op":"Head","args":["Line feed",1]}]
Soit pour permettre à vos amis d'accéder facilement à votre wifi invité, soit pour toute équipe rouge qui a besoin d'ajouter une commodité tentante à un point d'accès malveillant ! Utilisation de la fonction de création de code QR pour permettre aux appareils Android ou iOS de se connecter à votre Wifi.
Crédit : https://twitter.com/mattnotmax/status/1242031548884369408
Contexte : https://github.com/zxing/zxing/wiki/Barcode-Contents#wi-fi-network-config-android-ios-11
Generate_QR_Code('PNG',5,2,'Medium')
Décoder un Webshell documenté par SANS entièrement dans Cyberchef à l'aide de regex, ROT13, HTTP Request, Registers et plus encore !
Crédit : https://twitter.com/thebluetoob
[{"op":"Regular expression","args":["User defined","(?<=')(.*?)(?=')",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"ROT13","args":[true,true,13]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]},{"op":"ROT13","args":[true,true,13]},{"op":"Extract URLs","args":[false]},{"op":"Register","args":["(.*)",true,false,false]},{"op":"HTTP request","args":["GET","$R0","","Cross-Origin Resource Sharing",false]},{"op":"Strings","args":["Single byte",4,"Alphanumeric + punctuation (A)",false]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+=/]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Regular expression","args":["User defined","(?<=')(.*?)(?=')",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]},{"op":"ROT13","args":[true,true,13]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+=/]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]}]
Décoder un script de visiteur automatique écrit en PHP dans Cyberchef en utilisant regex, ROT13, plusieurs algorithmes de décompression et sous-sections ! Le point clé à considérer est qu’il existe deux variables utilisant différents cycles d’obscurcissement. Vous avez plusieurs options : travaillez dans plusieurs fenêtres CyberChef pour obtenir le résultat final ou, comme ci-dessous, utilisez des sous-sections et greg pour chaque variable afin de les manipuler indépendamment et d'obtenir les deux sorties désobscurcies dans un seul script. Vous pouvez raccourcir davantage la recette en utilisant des boucles pour sauter les multiples tours de Raw Inflate.
Crédit : Script original fourni par @NtSetDefault, recette(s) Cyberchef originale(s) créée(s) par @thebluetoob et affinée par @mattnotmax en une seule recette.
[{"op":"Regular expression","args":["User defined","(?<=')(.*?)(?=')",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"ROT13","args":[true,true,13]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]},{"op":"ROT13","args":[true,true,13]},{"op":"Subsection","args":["(?<=\$Fadly.*?")(.*?)(?=\")",true,true,false]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"URL Decode","args":[]},{"op":"From HTML Entity","args":[]},{"op":"Merge","args":[]},{"op":"Subsection","args":["(?<=\$Gans.*?")(.*?)(?=\")",true,true,false]},{"op":"Reverse","args":["Character"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Label","args":["jump"]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]},{"op":"Jump","args":["jump",2]},{"op":"Zlib Inflate","args":[0,0,"Adaptive",false,false]},{"op":"Zlib Inflate","args":[0,0,"Adaptive",false,false]}]
Choisissez votre poison avec ce script ingénieux de @0xtornado qui détermine le type d'obscurcissement de votre script de balise via des sauts conditionnels CyberChef pour analyser le shellcode. Tout d’abord, le code recherche une simple expression régulière « bxor » pour ensuite passer à la section appropriée de la recette. Sinon, il analyse le deuxième type. En utilisant les « onglets » de CyberChef, vous pouvez charger deux scripts différents et extraire vos données. Impressionnez vos collègues et votre sympathique équipe rouge ou l'équipe APT locale !
Crédit : https://twitter.com/0xtornado/status/1255866333545316352
[{"op":"Conditional Jump","args":["bxor",false,"Decode_Shellcode",10]},{"op":"Label","args":["Decode_beacon"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Gunzip","args":[]},{"op":"Label","args":["Decode_Shellcode"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"XOR","args":[{"option":"Decimal","string":"35"},"Standard",false]}]
Tout le monde ne considère pas CyberChef comme un outil d’analyse des fichiers journaux. Mais c'est pratique si vous devez transposer, reformater ou manipuler un fichier journal en fonction de vos besoins. Ici, nous avons un fichier journal Apache avec un horodatage qui ne conduit pas à une analyse temporelle utile avec d'autres fichiers journaux : le format de date n'est pas triable, il est entre crochets et il est en UTC +1 et non en UTC standard. En utilisant les sous-sections, les registres et la transposition de la date et de l'heure, nous pouvons modifier le formatage de l'horodatage et déplacer la colonne pour pouvoir la combiner avec d'autres données. Génial!
Crédit : @gazambelli et @mattnotmax
[{"op":"Fork","args":["\n","\n",false]},{"op":"Subsection","args":["\[.*\+0100\]",true,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"\[|\]"},"",true,false,true,false]},{"op":"Translate DateTime Format","args":["Standard date and time","DD/MMM/YYYY:HH:mm:ss ZZ","Etc/GMT-1","YYYY-MM-DDTHH:mm:ss ZZ","UTC"]},{"op":"Merge","args":[]},{"op":"Fork","args":["\n","\n",false]},{"op":"Register","args":["(.*)(\d{4}-.*\+0000)(.*)",true,false,false]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"$R0$R1$R2"},"$R1 $R0 $R2",true,false,true,false]}]
Une variante du chargeur PowerShell standard pour Cobalt Strike. Ici, la première couche d'obscurcissement est un blob GZipped divisé en deux tableaux CharCode. Le résultat final dépend de vous : démontage, chaînes, extraction de l'IP ou analyse de UserAgent. Choisissez votre propre aventure.
Source : @scumbots et https://pastebin.com/raw/mUFM4fcQ
[{"op":"Regular expression","args":["User defined","\d{1,3}",true,true,false,false,false,false,"List matches"]},{"op":"From Charcode","args":["Line feed",10]},{"op":"Gunzip","args":[]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"XOR","args":[{"option":"Decimal","string":"35"},"Standard",false]},{"op":"Strings","args":["Single byte",5,"All printable chars (A)",false]}]
Le fichier .dll malveillant de SolarWinds contenait des chaînes obscurcies à l’aide de la compression et de base64. Plutôt que de perdre le contexte de votre analyse, nous pouvons effectuer une désobscurcissement rapide en ligne en sélectionnant les chaînes avec une sous-section, puis en les convertissant. Le résultat est une fonction qui devient lisible avec le contexte et évite un copier-coller potentiellement sujet aux erreurs.
Crédit : @cybercdh & @Shadow0pz
Source : https://twitter.com/cybercdh/status/1338885244246765569 & https://twitter.com/Shadow0pz/status/1338911469480661000
[{"op":"Subsection","args":["(?<=\(\")(.*)(?=\"\))",true,true,false]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]}]
Gootkit stocke une DLL dans le registre sous forme de PowerShell codé. CyberChef fait de la viande hachée avec ce malware dit « sans fichier ». Une recette pratique fournie par @StefanKelm remet le « fichier » en « sans fichier » (oui, j'y ai pensé moi-même, nous en sommes à la recette 32 mes amis...).
Source : https://github.com/StefanKelm/cyberchef-recipes
[{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Raw Inflate","args":[0,0,"Adaptive",false,false]}]
Grâce au fonctionnement puissant des registres, une recette pratique de @Cryptolaemus1 extrait les URL obscurcies du PowerShell à partir d'un document malveillant Emotet. Ici, les groupes de capture sont utilisés pour récupérer la chaîne de recherche/remplacement qui désobscurcit les URL. Des trucs géniaux.
Crédit : @Cryptolaemus et @NtRaiseException()
Source : https://twitter.com/Cryptolaemus1/status/1319357369902649344
[{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Find / Replace","args":[{"option":"Regex","string":"'\)?\+\(?'"},"",true,false,true,false]},{"op":"Register","args":["\(+'(=[\w\d]*)'\)+,'/'\)",true,false,false]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"$R0"},"/",true,false,true,false]},{"op":"Register","args":["\/(.)http",true,false,false]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"$R1"},"\n",true,false,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"'"},"\n",true,false,true,false]},{"op":"Extract URLs","args":[false]}]
Didier Stevens démontre l'étonnante simplicité et l'utilité de CyberChef en extrayant des URL de documents OOXML (par exemple des fichiers .docx). En décompressant le fichier et en filtrant le « bien connu », les URL restantes peuvent être inspectées. N'oubliez pas de décrocher pour éviter tout clic inutile ou erreur de sécurité opérationnelle. Combinez-le avec la fonctionnalité « onglets » de CyberChef et vous pourrez analyser un lot de fichiers.
Crédit : @DidierStevens
Source : https://isc.sans.edu/diary/27020
[{"op":"Unzip","args":["",false]},{"op":"Extract URLs","args":[false]},{"op":"Filter","args":["Line feed","http://schemas\.openxmlformats\.org/",true]},{"op":"Filter","args":["Line feed","http://schemas\.microsoft\.com/",true]},{"op":"Filter","args":["Line feed","http://purl\.org/",true]},{"op":"Filter","args":["Line feed","http://www\.w3\.org/",true]},{"op":"Defang URL","args":[true,true,true,"Valid domains and full URLs"]}]
Un script de ransomware PowerShell crypté AES ne fait pas le poids face à CyberChef. Ici, nous pouvons convertir le Base64 en hexadécimal, extraire le IV et la clé dans des registres et les utiliser pour déchiffrer le blob. Une fois déchiffré, nous pouvons examiner les données et identifier un fichier PE de 1925 octets dans le blob déchiffré. En extrayant cela, nous pouvons ensuite utiliser d'autres outils pour identifier son comportement, notamment la détonation ou l'analyse statique.
Source : @mattnotmax
Informations complémentaires : Powershell abandonne un ransomware REvil
[{"op":"Subsection","args":["(?<=\")([a-zA-Z0-9+/=]{20,})(?=\")",true,true,false]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"To Hex","args":["None",0]},{"op":"Merge","args":[]},{"op":"Register","args":["(?<=\")([a-fA-F0-9]{32})(?=\")",true,false,false]},{"op":"Register","args":["(?<=\")([a-fA-F0-9]{64})(?=\")",true,false,false]},{"op":"Regular expression","args":["User defined","[a-f0-9]{100,}",true,true,false,false,false,false,"List matches"]},{"op":"AES Decrypt","args":[{"option":"Hex","string":"$R1"},{"option":"Hex","string":"$R0"},"CBC","Hex","Raw",{"option":"Hex","string":""},""]},{"op":"Regular expression","args":["User defined","[a-f0-9]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Hex","args":["Auto"]},{"op":"Drop bytes","args":[0,1925,false]},{"op":"SHA2","args":["256",64,160]}]
Ok, donc je triche un peu ici, car la majeure partie du travail est effectuée par une API. Mais c'est un bon exemple pour vous rappeler que l'opération de requêtes HTTP peut être un moyen extrêmement puissant d'augmenter CyberChef. Ici, j'ai créé un petit « formulaire de saisie » dans le volet de saisie de CyberChef et j'ai utilisé des expressions régulières pour capturer les paramètres clés de l'appel d'API dans les registres. Un petit massage de texte, et vous pouvez disposer d'un générateur rapide et facile selon vos besoins. Enregistré comme recette lorsque vous devez fournir rapidement un nouveau mot de passe à un nouvel utilisateur.
Source : @mattnotmax
[{"op":"Register","args":["(?<=number:\s)(.*)",true,false,false]},{"op":"Register","args":["(?<=words:\s)(.*)",true,false,false]},{"op":"Register","args":["(?<=length:\s)(.*)",true,false,false]},{"op":"HTTP request","args":["GET","https://makemeapassword.ligos.net/api/v1/passphrase/plain?pc=$R0&wc=$R1&sp=y&maxCh=$R2","","Cross-Origin Resource Sharing",false]},{"op":"Find / Replace","args":[{"option":"Regex","string":" "},"-",true,false,true,false]}]
La plupart des sandbox fournissent un fichier compressé avec le mot de passe générique « infecté ». Pourquoi risquer d'extraire sur votre bureau alors que vous pouvez extraire le contenu dans CyberChef ? Nous avons ici un fichier de courrier électronique .eml qui comprend une pièce jointe OLE2. Strings identifient Base64 qui est ensuite extrait et décodé pour extraire la deuxième étape.
Source : Any.run
[{"op":"Unzip","args":["infected",false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"\n"},"",true,false,true,false]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{400,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Strings","args":["16-bit littleendian",400,"Null-terminated strings (U)",false]},{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{2000,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Extract URLs","args":[false]},{"op":"Defang URL","args":[true,true,true,"Valid domains and full URLs"]}]
Une substitution est une substitution. Cela peut être lettre pour lettre, lettre pour chiffre ou lettre pour... crâne ? Ici, l'obscurcissement peut initialement paraître plus déroutant, mais il n'est en réalité pas différent des autres types. Rechercher / Remplacer, Sous-section, Depuis Base64... toute une journée standard pour CyberChef. J'ai inversé la première section pour permettre l'extraction de l'URL, puis j'ai continué la désobscurcissement.
Source : any.run
Crédit : https://twitter.com/neonprimetime/status/1365351048525791232
[{"op":"Find / Replace","args":[{"option":"Regex","string":"☠"},"B",true,false,true,false]},{"op":"Subsection","args":["[a-zA-Z0-9+/=]{300,}",true,true,false]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Decode text","args":["UTF-16LE (1200)"]},{"op":"Reverse","args":["Character"]},{"op":"Merge","args":[]},{"op":"Find / Replace","args":[{"option":"Simple string","string":"_✉✈_"},"A",true,false,true,false]},{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{300,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]}]
GoldMax, alias Sunshuttle, supprime un fichier de configuration crypté lors de son exécution. Dans l'analyse RE réalisée par Microsoft et Fireeye, l'algorithme et les clés ont été identifiés et publiés, ce qui facilite le décryptage avec CyberChef.
Source 1 : https://www.microsoft.com/security/blog/2021/03/04/goldmax-goldfinder-sibot-analyzing-nobelium-malware/
Source 2 : https://www.fireeye.com/blog/threat-research/2021/03/sunshuttle-second-stage-backdoor-targeting-us-based-entity.html
[{"op":"From Base64","args":["A-Za-z0-9-_",true]},{"op":"AES Decrypt","args":[{"option":"UTF8","string":"hz8l2fnpvp71ujfy8rht6b0smouvp9k8"},{"option":"Hex","string":"00000000000000000000000000000000"},"CFB","Raw","Raw",{"option":"Hex","string":""}]},{"op":"Subsection","args":["[a-zA-Z0-9+/=]{50,}",true,true,false]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Merge","args":[]},{"op":"Drop bytes","args":[0,16,false]},{"op":"Take bytes","args":[0,120,false]},{"op":"Register","args":["(^.*?)\|(.*?)\|(.*?)\|(.*)\|(.*)",true,false,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":".*"},"MD5 of Execution Time:\t\t\t$R0\nLower/Upper Limit for Sleep Time:\t$R1\nUtilize “blend-in” traffic requests:\t$R2\nEnd execution timestamp:\t\t$R2\nUser-agent for HTTPS requests:\t\t$R4",false,false,false,false]}]
Oui, il existe une opération de code morse dans CyberChef. Oui, vous devrez peut-être l'utiliser un jour. Malheureusement, ce n'était pas un malware, mais CyberChef fait quand même le travail. Merci à @pmelson et @cyber__sloth pour cette entrée.
Source : https://pastebin.com/raw/PvLuparz
Recette : https://twitter.com/cyber__sloth/status/1367904890157211654
[{"op":"From Binary","args":["Space",8]},{"op":"From Morse Code","args":["Space","Forward slash"]},{"op":"Reverse","args":["Character"]},{"op":"ROT13","args":[true,true,false,13]}]
Que voulons-nous ? Encodage mixte avec hexadécimal et octal dans un seul ensemble ! Quand le voulons-nous ? Maintenant!
Source : https://twitter.com/JCyberSec_/status/1368963598475739137
[{"op":"Fork","args":["\n","\n",false]},{"op":"Subsection","args":["\\x[a-fA-F0-9]{2}",true,true,false]},{"op":"From Hex","args":["\x"]},{"op":"Merge","args":[]},{"op":"Subsection","args":["\\\d{3}",true,true,false]},{"op":"Find / Replace","args":[{"option":"Regex","string":"\\"},"",true,false,true,false]},{"op":"From Octal","args":["Space"]}]
Ce webshell multicouche est un bon cas pour les sous-sections et les sauts. Vous pouvez le diviser en plusieurs parties ou le compléter (comme ci-dessous) en une seule recette CyberChef.
Source : https://twitter.com/mattnotmax/status/1377829935780274176
[{"op":"Regular expression","args":["User defined","[a-zA-Z0-9+/=]{30,}",true,true,false,false,false,false,"List matches"]},{"op":"From Base64","args":["A-Za-z0-9+/=",true]},{"op":"Subsection","args":["(?<=\\x)([a-fA-F0-9]{2})",true,true,false]},{"op":"From Hex","args":["\x"]},{"op":"Merge","args":[]},{"op":"Find / Replace","args":[{"option":"Regex","string":"\\x"},"",true,false,true,false]},{"op":"Subsection","args":["[a-zA-Z0-9+/=]{30,}=",true,true,false]},{"op":"From
