CyberChef Cheatsheet
CyberChef ist eine Web-Anwendung für Verschlüsselung, Codierung, Kompression und Datenanalyse. Bekannt als "The Cyber Swiss Army Knife", ermöglicht es Sicherheitsanalysten, komplexe Datentransformationen durch eine einfache Drag-and-Drop-Schnittstelle durchzuführen, wodurch es für Malware-Analyse, Forensik und CTF-Herausforderungen unschätzbar ist.
## Installation und Inbetriebnahme
### Web-Anwendung
** Online-Zugang:**
# Official hosted version
https://gchq.github.io/CyberChef/
# Alternative mirrors
https://cyberchef.org/
https://icyberchef.com/
```_
### Lokale Installation
**Docker Installation:**
```bash
# Pull official Docker image
docker pull mpepping/cyberchef
# Run CyberChef locally
docker run -d -p 8080:8080 mpepping/cyberchef
# Access at http://localhost:8080
```_
**Node.js Installation:**
```bash
# Clone repository
git clone https://github.com/gchq/CyberChef.git
cd CyberChef
# Install dependencies
npm install
# Build application
npm run build
# Start development server
npm start
# Access at http://localhost:8080
```_
** Standalone Ausführbar: **
```bash
# Download pre-built releases
wget https://github.com/gchq/CyberChef/releases/download/v9.55.0/CyberChef_v9.55.0.zip
# Extract and run
unzip CyberChef_v9.55.0.zip
cd CyberChef_v9.55.0
python3 -m http.server 8080
```_
## Schnittstellenübersicht
### Hauptkomponenten
**Recipe Panel: **
- Drag-Operationen aus der Operationsliste
- Betriebsparameter konfigurieren
- Reord-Operationen durch Ziehen
- Rezepte speichern und laden
**Input Panel:**
- Einfügen oder Typ-Eingabedaten
- Dateien hochladen (drag und drop)
- Daten von URLs laden
- Eingabeformat Optionen (Text, Hex, base64)
**Output Panel:**
- Transformationsergebnisse anzeigen
- Ausgabe als Datei herunterladen
- Kopieren in Clipboard
- Mehrere Ausgabeformatoptionen
**Berufsliste:**
- Suchvorgänge nach Namen
- Suchen nach Kategorie
- Favoriten für schnellen Zugriff
- Aktuelle Betriebsgeschichte
## Kodierung und Dekodierung
### Basis64 Operationen
**Base64 Encode:**
Operation: To Base64
Input: Hello World
Output: SGVsbG8gV29ybGQ=
# With custom alphabet
Operation: To Base64
Alphabet: Custom
Input: sensitive data
**Base64 Decode:**
Operation: From Base64
Input: SGVsbG8gV29ybGQ=
Output: Hello World
# Handle invalid characters
Operation: From Base64
Remove non-alphabet chars: true
**Base64 Varianten:**
# Base32 encoding
Operation: To Base32
Input: Hello World
Output: JBSWY3DPEBLW64TMMQ======
# Base58 encoding (Bitcoin)
Operation: To Base58
Input: Hello World
Output: JxF12TrwUP45BMd
# Base85 encoding
Operation: To Base85
Input: Hello World
Output: 87cURD]j7BEbo80
### URL Kodierung
**URL Encode:**
Operation: URL Encode
Input: hello world!@#$%
Output: hello%20world%21%40%23%24%25
# Encode all characters
Operation: URL Encode
Encode all chars: true
**URL Decode:**
Operation: URL Decode
Input: hello%20world%21%40%23%24%25
Output: hello world!@#$%
### HTML Encoding
**HTML Entity Encode:**
Operation: To HTML Entity
Input:
Output: <script>alert('XSS')</script>
# Named entities only
Operation: To HTML Entity
Named entities: true
**HTML Entity Decode:**
Operation: From HTML Entity
Input: <script>alert('XSS')</script>
Output:
## Verschlüsselung und Entschlüsselung
### Symmetrische Verschlüsselung
**AES Verschlüsselung:**
Operation: AES Encrypt
Mode: CBC
Key: 16-byte key here
IV: 16-byte IV here
Input: Secret message
Output: Encrypted data
# Different modes
Mode: ECB, CBC, CFB, OFB, GCM
Key format: Hex, UTF8, Latin1, Base64
**AES Entschlüsselung:**
Operation: AES Decrypt
Mode: CBC
Key: 16-byte key here
IV: 16-byte IV here
Input: Encrypted data
Output: Secret message
**DES/3DES:**
Operation: DES Encrypt
Mode: CBC
Key: 8-byte key
IV: 8-byte IV
Input: Data to encrypt
Operation: Triple DES Encrypt
Mode: CBC
Key: 24-byte key
IV: 8-byte IV
### Hash Funktionen
**Common Hashes: **
# MD5 Hash
Operation: MD5
Input: Hello World
Output: b10a8db164e0754105b7a99be72e3fe5
# SHA-1 Hash
Operation: SHA1
Input: Hello World
Output: 0a4d55a8d778e5022fab701977c5d840bbc486d0
# SHA-256 Hash
Operation: SHA2
Size: 256
Input: Hello World
Output: a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e
**HMAC:**
Operation: HMAC
Hash function: SHA256
Key: secret-key
Input: message to authenticate
Output: HMAC value
### Passwort Cracking
**Hash Analyse:**
Operation: Analyse hash
Input: 5d41402abc4b2a76b9719d911017c592
Output: Possible hash types: MD5, NTLM
# Hash identifier
Operation: Hash identifier
Input: $2b$12$...
Output: bcrypt hash detected
**Dictionary Attack:**
# Generate wordlist
Operation: Generate wordlist
Type: Bruteforce
Charset: abcdefghijklmnopqrstuvwxyz
Min length: 4
Max length: 8
# Compare with hash
Operation: Compare hashes
Hash type: MD5
Target hash: 5d41402abc4b2a76b9719d911017c592
## Datenanalyse
### Textanalyse
**Frequenzanalyse:**
Operation: Frequency distribution
Input: ATTACKATDAWN
Output: Character frequency chart
# Letter frequency analysis
Operation: Chi squared
Input: Encrypted text
Output: Chi-squared values for different shifts
**Entropy Analyse:**
Operation: Entropy
Input: Random data vs compressed data
Output: Entropy value (0-8 bits)
# Detect compression/encryption
High entropy (>7): Likely encrypted/compressed
Low entropy (``<4): Likely plain text
**String Extraction:**
Operation: Strings
Min length: 4
Input: Binary file data
Output: Printable strings
# Extract specific patterns
Operation: Regular expression
Pattern: [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]\\\{2,\\\}
Input: Text with email addresses
### Binäranalyse
**Hex Operationen:**
Operation: To Hex
Delimiter: Space
Input: Hello World
Output: 48 65 6c 6c 6f 20 57 6f 72 6c 64
Operation: From Hex
Delimiter: Auto
Input: 48656c6c6f20576f726c64
Output: Hello World
**Binary Operations:**
Operation: To Binary
Delimiter: Space
Input: Hello
Output: 01001000 01100101 01101100 01101100 01101111
# XOR operations
Operation: XOR
Key: secret
Key format: UTF8
Input: Data to XOR
**Dateianalyse:**
Operation: File type
Input: File header bytes
Output: Detected file type
# Extract file signatures
Operation: Extract file paths
Input: Binary data
Output: Embedded file paths
# Detect embedded files
Operation: Binwalk
Input: Firmware or binary file
Output: Embedded file locations
## Forensik und Malware-Analyse
### Netzwerkanalyse
**IP Adresse Operationen:**
Operation: Parse IP range
Input: 192.168.1.0/24
Output: List of IP addresses
# GeoIP lookup
Operation: GeoIP lookup
Input: 8.8.8.8
Output: Location information
# DNS operations
Operation: DNS over HTTPS
Query type: A
Domain: example.com
**URL-Analyse:**
Operation: URL decode
Input: Encoded URL
Output: Decoded URL
# Parse URL components
Operation: Parse URI
Input: https://example.com:8080/path?param=value
Output: Protocol, host, port, path, query
# Defang URLs
Operation: Defang URL
Input: http://malicious-site.com
Output: hxxp://malicious-site[.]com
### Analyse der Ergebnisse
** Anmeldung:**
Operation: Parse log file
Format: Apache Common Log
Input: 127.0.0.1 - - [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326
# Extract timestamps
Operation: Extract dates
Input: Log entries with various date formats
Output: Standardized timestamps
# Parse Windows Event Logs
Operation: Parse Windows Event Log
Input: XML event log data
Output: Structured event information
** Timeline Analyse:**
Operation: Sort
Sort by: Timestamp
Input: Multiple log entries
Output: Chronologically sorted events
# Time zone conversion
Operation: Change datetime format
Input format: DD/MM/YYYY HH:mm:ss
Output format: ISO 8601
Timezone: UTC
### Steganbau
**Bild Steganographie:**
Operation: Extract LSB
Input: Image file
Bit plane: 0 (LSB)
Output: Hidden data
# Extract EXIF data
Operation: Extract EXIF
Input: JPEG image
Output: Metadata information
# Image analysis
Operation: View Bit Plane
Bit: 0
Input: Suspicious image
Output: LSB visualization
**Text Steganographie:**
Operation: Detect hidden text
Method: Zero-width characters
Input: Text with hidden content
Output: Extracted hidden message
# Whitespace steganography
Operation: Whitespace
Action: Decode
Input: Text with hidden whitespace patterns
## Kryptanalyse
### Classical Ciphers
**Caesar Cipher: **
Operation: ROT13
Input: HELLO WORLD
Output: URYYB JBEYQ
# Variable rotation
Operation: Caesar cipher
Amount: 7
Direction: Encrypt
Input: ATTACK AT DAWN
Output: HAAHJR HA KHDV
** Substitution Ciphers:**
Operation: Substitution cipher
Plaintext alphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZ
Ciphertext alphabet: ZYXWVUTSRQPONMLKJIHGFEDCBA
Input: HELLO
Output: SVOOL
# Atbash cipher
Operation: Atbash cipher
Input: HELLO WORLD
Output: SVOOL DLIOW
**Vigenère Cipher: **
Operation: Vigenère encode
Key: SECRET
Input: HELLO WORLD
Output: ZINCS AIDVN
# Vigenère decode
Operation: Vigenère decode
Key: SECRET
Input: ZINCS AIDVN
Output: HELLO WORLD
### Moderne Kryptanalyse
**Frequenzanalyse:**
Operation: Frequency distribution
Show percentages: true
Input: Encrypted text
Output: Character frequency analysis
# Index of Coincidence
Operation: Index of Coincidence
Input: Ciphertext
Output: IC value (indicates monoalphabetic vs polyalphabetic)
**Key Recovery:**
Operation: Kasiski examination
Input: Vigenère ciphertext
Output: Probable key lengths
# Brute force Caesar
Operation: ROT13 brute force
Input: Encrypted text
Output: All possible rotations
## Automatisierung und Schrift
### Rezept Kreation
**Save Rezepte:**
# Create reusable recipes
1. Build operation chain
2. Click "Save recipe"
3. Name and describe recipe
4. Share recipe link
# Example: Malware deobfuscation recipe
Operations:
1. From Base64
2. Gunzip
3. From Hex
4. AES Decrypt (key: known_key)
**Recipe Sharing: **
# Share via URL
Recipe URL contains encoded operations
Example: https://gchq.github.io/CyberChef/#recipe=To_Base64('A-Za-z0-9%2B/%3D')
# Export/Import recipes
File format: JSON
Contains: Operations, parameters, input/output
### Batch Processing
** Multiple Inputs:**
# Process multiple files
1. Upload multiple files
2. Apply recipe to all
3. Download results as ZIP
# Batch text processing
Input: Multiple lines of data
Recipe: Applied to each line
Output: Processed results
** Automatische Skripte:**
```javascript
// CyberChef API usage (Node.js)
const chef = require("cyberchef");
// Create recipe
const recipe = new chef.Recipe(
new chef.operations.ToBase64(),
new chef.operations.MD5()
);
// Process data
const result = chef.bake("Hello World", recipe);
console.log(result.toString());
```_
## Erweiterte Techniken
### Zollsätze
** Magische Operation:**
Operation: Magic
Input: Unknown encoded data
Output: Automatically detected and decoded
# Intensive mode
Intensive: true
Extensive language support: true
Depth: 3 (number of operations to try)
**Fork Operation:**
Operation: Fork
Split on: \n (newline)
Merge: true
Input: Multiple lines of data
Recipe: Applied to each line separately
Output: Combined results
### Datenvisualisierung
**Chart Generation:**
Operation: Scatter chart
X values: Column 1
Y values: Column 2
Input: CSV data
Output: Interactive scatter plot
# Hex dump visualization
Operation: To Hexdump
Width: 16
Upper case: true
Include ASCII: true
**Netzwerkdiagramme:**
Operation: Generate network diagram
Input: Network connection logs
Output: Visual network topology
# Timeline visualization
Operation: Timeline
Date field: timestamp
Event field: event_type
Input: Log data with timestamps
## Integrationsbeispiele
### SIEM Integration
**Splunk Integration:**
```bash
# Use CyberChef for data preprocessing
# Example: Decode base64 logs before indexing
# Splunk search command
|eval decoded_data = base64decode(encoded_field)
|eval hash_value = md5(decoded_data)
# CyberChef recipe equivalent:
# 1. From Base64
# 2. MD5
```_
**ELK Stack Integration:**
```json
\\\{
"processors": [
\\\{
"script": \\\{
"source": "ctx.decoded = Base64.getDecoder().decode(ctx.encoded_field)"
\\\}
\\\}
]
\\\}
```_
### Threat Intelligence
**IOC Extraktion:**
# Extract indicators from reports
Recipe:
1. Regular expression (IP addresses)
2. Regular expression (Domain names)
3. Regular expression (File hashes)
4. Defang URLs
5. Format as CSV
Input: Threat intelligence report
Output: Structured IOC list
**Malware Analyse:**
# Deobfuscate malware samples
Recipe:
1. From Base64
2. Gunzip
3. From Hex
4. XOR (key: 0x42)
5. Extract strings
6. Regular expression (URLs/IPs)
Input: Obfuscated malware
Output: Deobfuscated code with IOCs
### CTF und Herausforderungen
**Common CTF Rezepte:**
# Multi-layer encoding
Recipe:
1. From Base64
2. URL Decode
3. From Hex
4. ROT13
5. Atbash cipher
# Steganography analysis
Recipe:
1. Extract LSB
2. From Binary
3. Gunzip
4. From Base64
# Cryptanalysis chain
Recipe:
1. Frequency distribution
2. Index of Coincidence
3. Kasiski examination
4. Vigenère decode (guessed key)
## Fehlerbehebung
### Gemeinsame Themen
**Leistungsprobleme:**
# Large file processing
- Use "Drop bytes" to reduce size
- Process in chunks using "Split"
- Disable auto-bake for large operations
# Memory issues
- Clear input/output regularly
- Use streaming operations when available
- Restart browser if memory usage high
** Kodierungsfragen:**
# Character encoding problems
- Check input encoding (UTF-8, Latin1, etc.)
- Use "Detect encoding" operation
- Convert between encodings as needed
# Binary data handling
- Use hex input for binary data
- Check byte order (little/big endian)
- Verify file headers and signatures
**Recipe Debugging: **
# Debug failed recipes
- Check each operation individually
- Verify input format matches expected
- Use "To Hex" to inspect intermediate results
- Check operation parameters
# Error messages
- "Invalid input": Check data format
- "Key length": Verify encryption key size
- "Parse error": Check syntax for regex/JSON
### Best Practices
**Rezeptentwicklung:**
# Start simple
1. Test each operation individually
2. Build recipe step by step
3. Verify intermediate outputs
4. Document recipe purpose
# Error handling
- Use "Drop bytes" to handle extra data
- Add "Try" operations for uncertain steps
- Include fallback operations
**Sicherheitsbedenken:**
# Sensitive data handling
- Use local installation for sensitive data
- Clear browser cache after use
- Avoid cloud-hosted instances for secrets
- Use HTTPS for web access
# Data validation
- Verify output makes sense
- Cross-check with other tools
- Test with known good data
- Document assumptions and limitations
```_
Dieses umfassende CyberChef-Catsheet umfasst Datentransformation, Kryptanalyse, Forensik und Automatisierungstechniken für effektive Sicherheitsanalyse und Untersuchung.