cyberchef recipes
1.0.0
CyberChef ist das von GCHQ entwickelte „Cyber-Schweizer Taschenmesser“. Es ist ein fantastisches Tool zur Datentransformation, -extraktion und -manipulation in Ihrem Webbrowser.
Volle Anerkennung geht an @GCHQ für die Erstellung des Tools. Siehe: https://gchq.github.io/CyberChef/
Die Beherrschung regulärer Ausdrücke ist der Schlüssel, um die Datenmanipulation in CyberChef (oder einer anderen DFIR-Arbeit) optimal zu nutzen. Unten sind einige reguläre Ausdrücke, auf die ich immer wieder zurückkomme.
Base64 extrahieren: [a-zA-Z0-9+/=]{30,}
Hexadezimal extrahieren: [a-fA-F0-9]{10,}
Zeichencodes extrahieren: [d]{2,3}(,|')
(?<=foo)(.*)^.*(?=bar)(?<=')(.*?)(?=')
CyberChef bietet eine Operation HTTP Request (siehe Rezept 22), die HTTP-Anfragen an externe Ressourcen ermöglicht. Aufgrund der Same Origin Policy (SOP) oder fehlender Cross-Origin Resource Sharing-Konfiguration funktionieren viele nicht. SOP ist eine Sicherheitsmaßnahme in modernen Browsern, die verhindert, dass Sie Cross-Site-Antworten von Servern lesen, die dies nicht explizit über CORS zulassen. Schauen Sie sich den Vortrag von @GlassSec auf CyberChef an, der Tipps zum Booten von Chrome ohne Web-Sicherheit enthält, um HTTP-Anfragen an ansonsten eingeschränkte APIs (wie Virus Total) zu ermöglichen.
Einige Beispielrezepte von CyberChef:
Rezept 1: Base64 extrahieren, roh aufblasen und verschönern
Rezept 2: Verschleierung hervorrufen
Rezept 3: Aus CharCode
Rezept 4: Entschlüsselung des Gruppenrichtlinien-Präferenzkennworts
Rezept 5: Schleifen und Beschriftungen verwenden
Rezept 6: Google ei-Zeitstempel
Rezept 7: Mehrstufige COM-Skriptlet-zu-x86-Assembly
Rezept 8: Hexadezimal extrahieren, in Hexdump für eingebettete PE-Datei konvertieren
Rezept 9: Umgekehrte Zeichenfolgen, Zeichenersetzung, von Base64
Rezept 10: Objekt aus dem Squid-Proxy-Cache extrahieren
Rezept 11: GPS-Koordinaten in Google Maps-URLs extrahieren
Rezept 12: Verarbeitung großer Zahlen
Rezept 13: Parsen von DNS-PTR-Einträgen mit Registern
Rezept 14: Dekodierung der ausführbaren POSHC2-Dateien
Rezept 15: Parsen von $MFT $SI-Zeitstempeln
Rezept 16: PHP-Gzinflate- und Base64-Webshells dekodieren
Rezept 17: Extrahieren von Shellcode aus einem Powershell Meterpreter Reverse TCP-Skript
Rezept 18: Papierkorb-Parser mit Unterabschnitten und Zusammenführungen
Rezept 19: Identifizieren Sie verschleiertes Base64 mit der Hervorhebung regulärer Ausdrücke
Rezept 20: Verwendung von Yara-Regeln mit entschleierten Schadskripten
Rezept 21: Inline-Entschleierung eines hexadezimal codierten VBE-Skripts, das an eine schädliche LNK-Datei angehängt ist
Rezept 22: JA3-API-Suche mit HTTP-Anforderung und -Registern
Rezept 23: Besiegen von DOSfuscation, eingebettet in eine schädliche DOC-Datei, mit Erfassungsgruppen für reguläre Ausdrücke
Rezept 24: Einen zufälligen Buchstaben aus einer Sechs-Byte-Zeichenfolge auswählen
Rezept 25: Erstellen eines WLAN-QR-Codes
Rezept 26: Extrahieren und Dekodieren einer mehrstufigen PHP-Webshell
Rezept 27: Dekodierung eines Auto-Visitor-PHP-Skripts
Rezept 28: Entschleierung von Cobalt Strike Beacon mithilfe von bedingten Sprüngen, um Shellcode zu erhalten
Rezept 29: Manipulation des Protokolldatei-Zeitstempels mit Unterabschnitten und Registern
Rezept 30: CharCode verschleiert PowerShell Loader für ein Cobalt Strike-Beacon
Rezept 31: Entschlüsseln Sie codierte Zeichenfolgen in der .NET-Binärdatei
Rezept 32: Extrahieren Sie schädliche Gootkit-DLLs aus verschleierten Registrierungsdaten
Rezept 33: Identifizieren Sie eingebettete URLs im Emotet PowerShell-Skript
Rezept 34: OOXML-Dateien auf URLs analysieren
Rezept 35: REvil PowerShell-Ransomware-Beispiel entschlüsseln
Rezept 36: Erstellen Sie einen CyberChef-Passwortgenerator
Rezept 37: Von Sandbox-Zip-E-Mails zu bösartigen URLs
Rezept 38: Flugzeuge, Totenköpfe und Umschläge – Live and Let PowerShell
Rezept 39: Entschlüsseln Sie die mit GoldMax oder Sunshutte verschlüsselten Konfigurationsdateien
Rezept 40: Morsecode-Wahnsinn
Rezept 41: PHP gemischte Hexadezimal- und Oktalkodierung
Rezept 42: PHP-Webshell mit mehrschichtiger Verschleierung
Rezept 43: Magento-Skimmer-Entschleierung
Rezept 44: JobCrypter-Ransomware entschlüsseln
Rezept 45: Sqiud-Proxy-Protokoll-Zeitstempelkonvertierung
Rezept 46: Passen Sie Ihren regulären Ausdruck an die Situation an
Rezept 47: Trickbot Visual Basic-Skript
Rezept 48: vjw0rm Emoji Madness
Rezept 49: Zerlegen Sie eine EICAR-Testdatei
Rezept 50: Ausgabe der Sicherheitsbeschreibungsdefinitionssprache analysieren
Rezept 51: Base-45-Decoder
Rezept 52: Liste der Elemente zufällig anordnen
Rezept 53: Olevba-Ausgabe an Powershell
Rezept 54: Windows-Ereignis-ID 1029-Hashes
Rezept 55: Debofuscating BazarLoader, auch bekannt als TA551 maldoc
Rezept 56: Berechnen und Suchen von JA3- oder JA3S-Hashwerten aus einem PCAP
Rezept 57: Erstellen Sie ein Meme mit CyberChef
Rezept 58: Extrahieren Sie die IcedID-URL der zweiten Stufe aus einem Maldoc
Rezept 59: Cobalt Strike-Beacon-Konfiguration analysieren
Rezept 60: Durch Microsoft Safelinks geschützte URLs dekodieren
Rezept 61: Extrahieren Sie URLs der zweiten Stufe aus Qakbot Excel-Maldocs
Rezept 62: Emotet Maldoc zu PowerShell
Rezept 63: Extrahieren Sie URLs aus von Dridex verschleiertem VBS
Rezept 64: Strings in VirusTotal Grep-Abfragen konvertieren
Rezept 65: MSF Venom PowerShell-Reverse-Shell-Nutzlast entschleieren
Rezept 66: Beispiel für einen verschachtelten Unterabschnitt
Rezept 67: Konvertieren eines MSI-Produktcodes in die Produkt-ID des Registrierungsinstallationsprogramms
Rezept 68: Konvertieren von Java-Arrays mit signierten Bytes
Rezept 69: Extrahieren der DLL-Nutzlast aus einem Bumblebee Powershell-Skript
Rezept 70: Extrahieren von Endpunkten aus der Android-Netzwerksicherheitskonfiguration
Ein sehr häufiges Szenario: Base64 extrahieren, aufblasen, Code verschönern. Je nach nächster Stufe müssen Sie dann möglicherweise eine weitere Verarbeitung oder dynamische Analyse durchführen.
Dateiname: ahack.bat
ZIP-Datei: cc9c6c38840af8573b8175f34e5c54078c1f3fb7c686a6dc49264a0812d56b54_183SnuOIVa.bin.gz
Beispiel: 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 wird nicht in der Lage sein, alle Arten von Invoke-Obfuscation zu verarbeiten, aber hier ist eine, die entschlüsselt werden kann.
Dateiname: Acknowledgement NUT-95-52619.eml
ZIP-Datei: 1240695523bbfe3ed450b64b80ed018bd890bfa81259118ca2ac534c2895c835.bin.gz
Beispiel: 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"]}]
Malware und Skripte verwenden häufig Charcode zur Darstellung von Zeichen, um AV- und EDR-Lösungen zu entgehen. CyberChef frisst das auf.
Dateiname: 3431818-f71f60d10b1cbe034dc1be242c6efa5b9812f3c6.zip
Quelle: 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]}]
Wenn ein neues GPP erstellt wird, wird in SYSVOL eine zugehörige XML-Datei mit den relevanten Konfigurationsdaten erstellt. Wenn ein Kennwort angegeben wird, wird diese mit AES-256-Bit verschlüsselt. Microsoft hat den AES-Schlüssel veröffentlicht, der zum Entschlüsseln von Passwörtern verwendet werden kann, gespeichert unter: \SYSVOL<DOMAIN>Policies
Bildnachweis: @cyb3rops
Quelle 1: https://twitter.com/cyb3rops/status/1036642978167758848
Quelle 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 kann Etiketten verwenden, um Teile des Rezepts zu identifizieren und dann eine Schleife ausführen, um Vorgänge mehrmals auszuführen. In diesem Beispiel gibt es 29 Runden Base64-Kodierung, die extrahiert und dekodiert werden.
Bildnachweis: @pmelson
Quelldatei: hmCPDnHs.txt
Quelle 1: https://pastebin.com/hmCPDnHs
Quelle 2: https://twitter.com/pmelson/status/1078776229996752896
Sehen Sie sich auch weitere Beispiele für Schleifen über Base64 an: https://twitter.com/QW5kcmV3/status/1079095274776289280 (Quelle: @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 verwendet einen eigenen Zeitstempel, ich nenne Ei-Zeit, den es in die URL einbettet.
Quelle: 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)"]}]
Dabei handelt es sich um ein elfstufig dekodiertes COM-Skriptlet, das die Anweisungen Base64, Gunzip, RegEx und Disassemble x86 verwendet.
Bildnachweis: @JohnLaTwC
Dateiname: 41a6e22ec6e60af43269f4eb1eb758c91cf746e0772cecd4a69bb5f6faac3578.txt
Quelle 1: https://gist.githubusercontent.com/JohnLaTwC/aae3b64006956e8cb7e0127452b5778f/raw/f1b23c84c65 4b1ea60f0e57a860c74385915c9e2/43cbbbf93121f3644ba26a273ebdb54d8827b25eb9c754d3631be395f06d8cff
Quelle 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]}]
Diese Datei verfügt über eine eingebettete PE-Datei (SHA 256: 26fac1d4ea12cdceac0d64ab9694d0582104b3c84d7940a4796c1df797d0fdc2, R5Sez8PH.exe, VT: 54/70). Mit CyberChef können wir Hexadezimalzahlen regexieren und in einen besser sichtbaren Hexdump konvertieren.
Quelle 1: https://pastebin.com/R5Sez8PH (leider nicht mehr verfügbar!)
Quelle 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]}]
Ein Base64-Blob mit einigen zu ersetzenden Nebenbytes. Ursprüngliche Dekodierung von @pmelson in Python und konvertiert in CyberChef.
Bildnachweis: @pmelson
Quelle 1: https://pastebin.com/RtjrweYF / RtjrweYF.txt
Quelle 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]}]
Schneiden Sie Ihre Squid-Cache-Objekte nicht manuell aus. Laden Sie die Datei einfach auf CyberChef hoch. Dieses Rezept sucht nach den magischen Bytes 0x0D0A0D0A und extrahiert danach alles. Anschließend dekomprimiert gzip das Objekt zum Herunterladen.
Quelle: 00000915 (Ausgabe sollte TrueCrypt_Setup_7.1a.exe mit SHA256 e95eca399dfe95500c4de569efc4cc77b75e2b66a864d467df37733ec06a0ff2 sein)
[{"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":[]}]
Wenn Sie schnell herausfinden müssen, wo ein Foto aufgenommen wurde, und Sie das Glück haben, über eingebettete GPS-Breiten- und Längengrade zu verfügen, können Sie mit diesem Rezept schnell eine verwendbare Google Maps-URL zur Identifizierung des Standorts erstellen.
[{"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 kann große Zahlen verarbeiten. Hier können wir ein einfaches Rezept verwenden, um eine 38-stellige X509SerialNumber in die hexadezimale entsprechende Seriennummer des X.509-Zertifikats zu ändern. Dann können wir die Hexadezimalzahl regexieren und einen Doppelpunkt einfügen, um sie in das richtige Format umzuwandeln.
Bildnachweis: @QW5kcmV3
Quelle: 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]}]
IP-Adressen in DNS-PTR-Einträgen werden als niedrigstwertiges Oktett zuerst gespeichert. Beispiel: 167.139.44.10.in-addr.arpa würde sich auf die IP-Adresse 10.44.139.167 beziehen. Mithilfe der Register von CyberChef können wir jedes Oktett einem Speicherregister (oder einer Variablen, wenn es einfacher ist, sich das so vorzustellen) zuordnen. Diese können dann umgekehrt werden, um die IP-Adresse neu anzuordnen. Durch Suchen/Ersetzen wird der Rest des Datensatzes aufgeräumt. Dies könnte umgekehrt werden, wenn Sie „normale“ IP-Adressen für die Suche in DNS-PTR-Einträgen übersetzen möchten.
[{"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 ist ein Proxy-fähiges C2-Framework, das Powershell nutzt, um Penetrationstester bei Red Teaming, Post-Exploitation und Lateral Movement zu unterstützen. Der Dropper basiert auf PowerShell und besteht aus einem PowerShell-Skript, das doppelt Base64-codiert und komprimiert ist. Das Extrahieren der Zeichenfolgen kann mit CyberChef wie unten beschrieben erfolgen. Abhängig von den Einstellungen und der Anpassung der ausführbaren Datei müssen Sie möglicherweise Ihr Rezept anpassen.
Bildnachweis: @a_tweeter_user
Quelle: https://twitter.com/a_tweeter_user/status/1100751236687642624
Quelle: 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 kann mit Daten so ziemlich alles machen. Hier sind rohe Hex-Bytes aus einem $MFT-Eintrag. Durch die Auswahl bestimmter Bytes und die Verwendung verschiedener Funktionen von CyberChef kann ich jeden Teil der Daten nach Bedarf analysieren. Dieses Rezept extrahiert und analysiert die $SI-Zeitstempel. Nicht mehr einhüllen!
[{"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]}]
Webshells gibt es in allen Formen und Größen. Für PHP-Webshells kann die Kombination von gzinflate und base64 verwendet werden, um die Auswertungsdaten zu verschleiern. In diesem Beispiel gibt es 21 Komprimierungsrunden und Base64, die wir mithilfe von Beschriftungen und Schleifen schnell analysieren können.
Quelle: 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]}]
Dies kommt oft im Pastbin-Bot @scumbots von @pmelson vor und entfernt mehrere Ebenen eines codierten Powershell-Skripts, um den Shellcode anzuzeigen. Von hier aus könnten Sie PUSH-Anweisungen extrahieren, um zu versuchen, die IP-Adresse und den Port zu identifizieren, aber Sie erhalten zu viele Fehlalarme. Daher ist es besser, ein Tool wie scdbg zu verwenden (siehe: http://sandsprite.com/blogs/index.php?uid=7&pid=152).
Quelle: https://twitter.com/ScumBots/status/1121854255898472453
Quelle: 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]}]
Unterabschnitte und Zusammenführungen sind leistungsstarke Werkzeuge in CyberChef, die die Anwendung von Zutaten auf eine Auswahl von Daten statt auf die gesamte Eingabedatei ermöglichen. Dieser Abschnitt kann dann zusammengeführt werden, um mit der gesamten Eingabe fortzufahren. In einer großartigen Arbeit hat @GlassSec mit CyberChef einen Windows-Papierkorb-Parser erstellt, der zeigt, dass die Möglichkeiten dieser Funktionen endlos sind.
Quelle: https://gist.github.com/glassdfir/f30957b314ec39a8aa319420a29ffc76
Bildnachweis: 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"]}]
Weniger ein Rezept als vielmehr eine Technik. Durch die Verwendung der „Hervorhebung“-Funktion des regulären Ausdrucks können Sie deutlich erkennen, wo Base64-Daten mit einem nicht-traditionellen Base64-Zeichensatz aufgebrochen wurden. Hier die Sequenz '@<!' wird verwendet, um die automatische Kodierungskonvertierung zu verschleiern und zu stören. Wenn Sie weiter unten im Skript nachsehen, wird die Sequenz durch „A“ ersetzt, das dann vor der Extraktion mit „Suchen/Ersetzen“ eingefügt werden kann. Dies wird über mehrere Runden fortgesetzt, bis eine interessierende Domäne (zusammen mit einem ausführbaren Prior) aufgedeckt wird.
Quelle: https://pastebin.com/TmJsB0Nv & 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]}]
Auch wenn dies nicht die bequemste Möglichkeit ist, bietet CyberChef die Möglichkeit, eine Yara-Regel auf die Ausgabe eines Rezepts anzuwenden. Sie können dies kombinieren, indem Sie die Funktion „Mehrere Eingaben“ verwenden, um eine größere Anzahl von Dateien zu scannen.
Quelle: https://twitter.com/ScumBots/status/1168528510681538560 & 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]}]
Dieses Rezept extrahiert eine VBE-Nutzlast aus einer Microsoft Shortcut-Datei (LNK) und dekodiert dann die Hex-Zeichenfolgen inline mithilfe von Unterabschnitten.
Quelle: bösartig.lnk.bin
[{"op":"Microsoft Script Decoder","args":[]},{"op":"Subsection","args":["(?<=\(\")(.*?)(?=\"\))",true,true,false]},{"op":"Fork","args":["\n","\n",false]},{"op":"From Hex","args":["Auto"]}]
Mit der HTTP-Request-Funktion und den Registern können wir Daten mit denen einer API oder einer externen Ressource anreichern. Hier suchen wir anhand von drei JA3-Hashes nach bekannten Fehlern.
Quelle: Eingabe-Hashes: 1aa7bf8b97e540ca5edd75f7b8384bfa, 1be3ecebe5aa9d3654e6e703d81f6928 und 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]}]
Diese schädliche DOC-Datei wird direkt von Hybrid-Analysis heruntergeladen. Wir entpacken es, wählen die Datei mit einem regulären Ausdruck aus und wählen dann mit der Funktion „set“ den kritischen Abschnitt aus, der verwendet wird. Dieser Abschnitt wird durch eine umgekehrte for-Schleife mit einem Dreierschritt entschlüsselt. Nach der Auswahl kehren wir die Zeichenfolge um und verwenden Erfassungsgruppen für reguläre Ausdrücke, um jedes dritte Zeichen auszuwählen. Das ist eine großartige Arbeit von Hack eXPlorer auf YouTube. Gehen Sie dorthin und schauen Sie zu!
Quelle: Untitled-11232018-659370.doc.bin.gz
Bildnachweis: Angepasst an das Video von Hack eXPlorer: Verstecken von bösartigem Code mit 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]}]
Eine Bitte um Unterstützung führte zu diesem Rezept, das Register, HTTP-Anforderungen und etwas Regex verwendet, um ein zufälliges Zeichen aus einer Sechs-Byte-Zeichenfolge auszuwählen.
Bildnachweis: Adaptiert von 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]}]
Entweder, um Ihren Freunden den Zugriff auf Ihr Gäste-WLAN zu erleichtern, oder für jedes Red Team, das einen verlockenden Komfort zu einem betrügerischen Zugangspunkt hinzufügen möchte! Verwenden Sie die Funktion zum Erstellen eines QR-Codes, um Android- oder iOS-Geräten die Anmeldung bei Ihrem WLAN zu ermöglichen.
Bildnachweis: https://twitter.com/mattnotmax/status/1242031548884369408
Hintergrund: https://github.com/zxing/zxing/wiki/Barcode-Contents#wi-fi-network-config-android-ios-11
Generate_QR_Code('PNG',5,2,'Medium')
Dekodierung einer von SANS dokumentierten Webshell vollständig in Cyberchef unter Verwendung von Regex, ROT13, HTTP-Anfrage, Registern und mehr!
Bildnachweis: 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]}]
Dekodierung eines in PHP geschriebenen automatischen Besucherskripts in Cyberchef unter Verwendung von Regex, ROT13, mehreren Dekomprimierungsalgorithmen und Unterabschnitten ! Der wichtigste zu berücksichtigende Punkt ist, dass es zwei Variablen gibt, die unterschiedliche Verschleierungsrunden verwenden. Sie haben mehrere Möglichkeiten: Arbeiten Sie in mehreren CyberChef-Fenstern, um das Endergebnis zu erhalten, oder verwenden Sie, wie unten beschrieben, Unterabschnitte und Greg für jede Variable, um jede einzeln zu bearbeiten und beide entschleierten Ausgaben in einem Skript zu erhalten. Sie können das Rezept weiter verkürzen, indem Sie Schleifen verwenden, um die mehreren Runden von Raw Inflate zu überspringen.
Bildnachweis: Originalskript bereitgestellt von @NtSetDefault, Originalrezept(e) von Cyberchef erstellt von @thebluetoob und verfeinert von @mattnotmax zu einem Rezept.
[{"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]}]
Wählen Sie Ihr Gift mit diesem genialen Skript von @0xtornado, das über bedingte Sprünge von CyberChef bestimmt, welche Art von Verschleierung Ihr Beacon-Skript hat, um den Shellcode zu analysieren. Zuerst sucht der Code nach einem einfachen regulären Ausdruck „bxor“, um dann zum entsprechenden Abschnitt des Rezepts zu springen. Andernfalls wird der zweite Typ analysiert. Mit den „Tabs“ von CyberChef können Sie zwei verschiedene Skripte laden und Ihre Daten abrufen. Beeindrucken Sie Ihre Kollegen und das freundliche rote Team oder die lokale APT-Crew!
Bildnachweis: 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]}]
Nicht jeder denkt, dass CyberChef ein Tool zur Protokolldateianalyse ist. Aber es ist praktisch, wenn Sie eine Protokolldatei für Ihren Zweck transponieren, neu formatieren oder manipulieren müssen. Hier haben wir eine Apache-Protokolldatei mit einem Zeitstempel, der nicht zu einer nützlichen zeitlichen Analyse mit anderen Protokolldateien führt: Das Datumsformat ist nicht sortierbar, es ist in eckige Klammern eingeschlossen und es ist UTC +1, kein Standard-UTC. Mithilfe von „Unterabschnitten“, „Registern“ und „Datum und Uhrzeit transponieren“ können wir die Formatierung des Zeitstempels ändern und die Spalte verschieben, um sie mit anderen Daten kombinieren zu können. Eindrucksvoll!
Bildnachweis: @gazambelli und @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]}]
Eine Variante des Standard-PowerShell-Loaders für Cobalt Strike. Hier ist die erste Verschleierungsebene ein GZipped-Blob, der in zwei CharCode-Arrays aufgeteilt ist. Das Endergebnis liegt bei Ihnen: Disassemblierung, Zeichenfolgen, IP-Adresse extrahieren oder UserAgent analysieren. Wählen Sie Ihr eigenes Abenteuer.
Quelle: @scumbots & 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]}]
Die bösartige DLL von SolarWinds enthielt durch Komprimierung und Base64 verschleierte Zeichenfolgen. Anstatt den Kontext in Ihrer Analyse zu verlieren, können wir eine schnelle Inline-Entschleierung durchführen, indem wir die Zeichenfolgen mit einem Unterabschnitt auswählen und dann konvertieren. Das Ergebnis ist eine Funktion, die im Kontext lesbar wird und ein potenziell fehleranfälliges Ausschneiden und Einfügen vermeidet.
Bildnachweis: @cybercdh & @Shadow0pz
Quelle: 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 speichert eine DLL in der Registrierung als codierte PowerShell. CyberChef macht Hackfleisch aus dieser sogenannten „dateilosen“ Malware. Ein praktisches Rezept von @StefanKelm versetzt die „Datei“ wieder in „dateilos“ (ja, daran habe ich selbst gedacht, wir sind bei Rezept 32, meine Freunde ...).
Quelle: 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]}]
Mithilfe der leistungsstarken Funktion von Registers extrahiert ein praktisches Rezept von @Cryptolaemus1 verschleierte URLs aus der PowerShell aus einem schädlichen Emotet-Dokument. Hier werden Erfassungsgruppen verwendet, um die Such-/Ersetzungszeichenfolge abzurufen, die die URLs entschleiert. Tolles Zeug.
Bildnachweis: @Cryptolaemus und @NtRaiseException()
Quelle: 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 demonstriert die erstaunliche Einfachheit und Nützlichkeit von CyberChef, indem er URLs aus OOXML-Dokumenten (z. B. .docx-Dateien) extrahiert. Durch Entpacken der Datei und Herausfiltern der „bekanntermaßen guten“ Dateien können die verbleibenden URLs überprüft werden. Vergessen Sie nicht, die Fangvorrichtung zu entfernen, um unnötige Klicks oder Fehler bei der Betriebssicherheit zu vermeiden. In Kombination mit der „Tabs“-Funktion von CyberChef können Sie einen Stapel Dateien analysieren.
Bildnachweis: @DidierStevens
Quelle: 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"]}]
Ein AES-verschlüsseltes PowerShell-Ransomware-Skript ist CyberChef nicht gewachsen. Hier können Sie Base64 in Hex umwandeln, IV und Schlüssel in Register extrahieren und sie zum Entschlüsseln des Blobs verwenden. Nach der Entschlüsselung können wir die Daten untersuchen und eine PE-Datei mit 1925 Bytes im entschlüsselten Blob identifizieren. Wenn wir dies extrahieren, können wir dann andere Tools verwenden, um sein Verhalten zu identifizieren, einschließlich Detonation oder statische Analyse.
Quelle: @mattnotmax
Weitere Informationen: Powershell lässt eine REvil-Ransomware fallen
[{"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, ich schummele hier also ein bisschen, da der Großteil der Arbeit von einer API erledigt wird. Aber es ist ein gutes Beispiel, um Sie daran zu erinnern, dass der HTTP-Anforderungsvorgang eine äußerst leistungsstarke Möglichkeit zur Erweiterung von CyberChef sein kann. Hier habe ich im CyberChef-Eingabebereich ein kleines „Eingabeformular“ erstellt und reguläre Ausdrücke verwendet, um die Schlüsselparameter für den API-Aufruf in Registern zu erfassen. Eine kleine Textmassage, und Sie können einen schnellen und einfachen Generator haben, wie Sie ihn brauchen. Wird als Rezept gespeichert, wenn Sie einem neuen Benutzer schnell ein neues Passwort zukommen lassen müssen.
Quelle: @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]}]
Die meisten Sandboxes liefern eine ZIP-Datei mit dem generischen Passwort „infected“. Warum sollten Sie das Risiko eingehen, die Inhalte auf Ihren Desktop zu extrahieren, wenn Sie die Inhalte auch in CyberChef extrahieren können? Hier haben wir eine E-Mail .eml -Datei, die einen OLE2-Dateianhang enthält. Strings identifiziert Base64, das dann extrahiert und dekodiert wird, um die zweite Stufe herauszuziehen.
Quelle: 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"]}]
Eine Substitution ist eine Substitution. Es kann Buchstabe für Buchstabe, Buchstabe für Zahl oder Buchstabe für ... Schädel sein? Hier sieht die Verschleierung zunächst vielleicht verwirrender aus, unterscheidet sich aber eigentlich nicht von anderen Arten. Suchen/Ersetzen, Unterabschnitt, Von Base64 ... alles ein normaler Tagesausflug für CyberChef. Ich habe den ersten Abschnitt umgekehrt, um die Extraktion der URL zu ermöglichen, und fahre dann mit der Entschleierung fort.
Quelle: any.run
Bildnachweis: 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, auch bekannt als Sunshuttle, löscht bei der Ausführung eine verschlüsselte Konfigurationsdatei. In der RE-Analyse von Microsoft und Fireeye wurden der Algorithmus und die Schlüssel identifiziert und veröffentlicht, sodass die Entschlüsselung mit CyberChef ein Kinderspiel ist.
Quelle 1: https://www.microsoft.com/security/blog/2021/03/04/goldmax-goldfinder-sibot-analyzing-nobelium-malware/
Quelle 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]}]
Ja, es gibt eine Morsecode-Operation in CyberChef. Ja, möglicherweise müssen Sie es eines Tages verwenden. Leider handelte es sich dabei nicht um Schadsoftware, aber CyberChef erledigt den Job trotzdem. Vielen Dank an @pmelson und @cyber__sloth für diesen Eintrag.
Quelle: https://pastebin.com/raw/PvLuparz
Rezept: 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]}]
Was wollen wir? Gemischte Kodierung mit Hexadezimal- und Oktalkodierung in einem Satz! Wann wollen wir es? Jetzt!
Quelle: 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"]}]
Diese mehrschichtige Webshell eignet sich gut für Unterabschnitte und Sprünge. Sie können es in Teile aufteilen oder (wie unten) in einem einzigen CyberChef-Rezept vervollständigen.
Quelle: 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
