yaklang/hack-skills
102 skills110k installs100k starsGitHub
Install
npx skills add https://github.com/yaklang/hack-skillsSkills in this repo
1HackHack is the primary router skill for Yaklang’s HackSkills library, aimed at solo builders and small teams doing authorized web application testing, API security review, recon, and vulnerability triage. Rather than dumping exploit steps into chat, it forces a disciplined sequence: identify the testing phase, choose the correct vulnerability category, then load the specialized skill for that track. That structure helps agents avoid skipping recon, misclassifying findings, or leaning on stale training data when JWT, SSRF, IDOR, or API nuances matter. The skill foregrounds a trust model—legitimate research, defensive validation, and in-scope bug bounty work only—and steers work toward content safety and auditability. Use it at the start of a new target engagement when you need a stable methodology and clear handoff to category-specific HackSkills modules.1.2kinstalls2Sqli Sql InjectionSQL Injection (sqli-sql-injection) packages extended attack scenarios and real-world cases for solo builders and small teams hardening data-driven apps. The material goes past textbook UNION SELECT examples into where applications actually break: JSON keys used as column names, path segments fed into queries, X-Forwarded-For and cookie channels, multipart filenames, and ORDER BY clauses driven by sort APIs. It also documents out-of-band exfiltration paths such as SMB-triggered LOAD_FILE on Windows MySQL, including when DNS exfil is more firewall-friendly versus when SMB leaks credentials. For indie SaaS and API products, this skill supports authorized security review during ship—turning vague “check for SQLi” into concrete probe patterns you can run in staging. It is advanced appsec reference content paired with the main SKILL.md workflow; use only on systems you own or have explicit permission to test.1.2kinstalls3Code Obfuscation DeobfuscationCode Obfuscation & Deobfuscation is an expert agent skill that walks solo builders and reverse engineers through identifying and defeating common native-binary protections inside disassemblers such as IDA and Ghidra. It is for anyone who hits unreadable control flow, encrypted strings, or virtualized code while investigating a suspect executable—not for casual source-code refactors. Use it when the binary shows flattened CFGs, movfuscator-only instruction streams, VM protector entry stubs, or layers of junk and opaque predicates that block static analysis. The skill emphasizes correct classification (packing vs obfuscation) and pairs each symptom with a starting tactic, from symbolic execution for recovered CFGs to trace-based lifting for movfuscator and dedicated VM bytecode work for commercial protectors. It complements—not replaces—dynamic debugging and dedicated symbolic-engine workflows. Outcomes are clearer analysis paths, fewer dead-end static passes, and handoffs to sibling skills when anti-debug or deep VM bytecode analysis is required.1.2kinstalls4Xss Cross Site ScriptingXSS Cross-Site Scripting is a supplementary agent skill reference for security-focused builders and agents who need modern cross-site scripting techniques beyond a core XSS checklist. It documents mutation XSS (mXSS) where sanitizers and browser HTML parsers disagree, producing payloads that look safe until DOM insertion mutates them into executable nodes. The reference includes concrete DOMPurify-oriented patterns such as MathML namespace confusion, noscript parsing differentials, and form/table restructuring tricks, plus guidance to validate findings by piping sanitizer output through innerHTML and inspecting the resulting DOM. It is intended as a load-when-needed depth layer when the agent tackles framework XSS, DOM clobbering, Trusted Types bypass, or Service Worker persistence—not as a replacement for responsible disclosure policy or authorized testing scope. Solo builders shipping user-generated HTML, rich text, or SPA frameworks use it during security review to stress-test client-side sanitization assumptions.1.2kinstalls5Ssrf Server Side Request Forgeryssrf-server-side-request-forgery is an extended security reference for agents and builders auditing features that fetch URLs on behalf of users—webhooks, importers, previewers, and admin tools. It documents historical exploitation paths such as WebLogic SearchPublicRegistries SSRF and chains that pivot from an open internal port to Redis command injection and remote code execution. Companion material covers port scanning through the vulnerable server, CRLF payloads, and DNS rebinding where validation resolves a safe IP but the subsequent connection hits loopback or metadata services. Solo founders use it during Ship security passes and when hardening Operate-era admin panels that were added quickly. It supplements a primary SSRF SKILL.md with CVE narratives rather than replacing secure SDLC policy.1.2kinstalls6Api Secapi-sec is the Yak hack-skills entry router for API security. Solo and indie builders (or small teams) who ship REST or GraphQL backends install it when they need a disciplined order of operations before diving into OpenAPI drift, broken object-level authorization, JWT misuse, or GraphQL introspection—not ad-hoc checklist hopping in chat. The skill reads like a security program manager: it asks what you observe on the wire (docs exposed, IDs in URLs or JSON, bearer tokens, GraphQL args) and points you to exactly one deeper SKILL.md track. That keeps agent sessions focused and reduces missed classes of bugs when you are hardening your own product or running authorized assessments. It is advanced, offensive-security oriented, and assumes you will only test systems you are allowed to test.1.2kinstalls7Api Recon And DocsAPI Recon and Docs is a security agent playbook for builders and testers who need a complete picture of a target API before deeper testing. It instructs the agent to load this skill first when the target is REST, mobile, or GraphQL and you must enumerate endpoints, documentation, versions, and hidden surface area. The checklist combines client-side JavaScript mining, probing well-known documentation paths, and hunting version and product drift such as mobile-only or legacy routes. From discovered docs it prioritizes optional and undocumented fields, admin-flavored examples, still-active deprecated routes, and schema looseness that often precedes authorization bugs. Findings explicitly route to companion hack-skills—for example object IDs everywhere leads toward API authorization and BOLA work—so solo builders running agent-led pentests can chain recon into exploitation-focused steps without ad-hoc guessing.1.1kinstalls8Recon And MethodologyRecon and Methodology is a Yaklang hack-skills agent playbook that teaches solo security-minded builders and indie pentesters how elite hunters map attack surface before firing exploits. It encodes a clear hierarchy: pick a target, lock scope, discover assets, fingerprint technology, enumerate endpoints, then test by vulnerability class. The skill emphasizes that many high-severity findings come from breadth and consistency, not isolated clever payloads. Passive enumeration via Subfinder, Amass, and crt.sh reduces noisy DNS when you are still in discovery; active massdns-style steps come after you accept operational touch on the target. Use it when you have authorized scope—your own SaaS, a bounty program, or a client engagement—and need a structured plan the agent can follow. It is not a single CVE checker; it is methodology plus command patterns for recon. Pair it with Yaklang or your preferred scanner stack once endpoints are listed. Intermediate comfort with bash, DNS, and program rules is assumed; always stay inside legal scope.1.1kinstalls9Android Pentesting TricksAndroid Pentesting Tricks is a Yaklang hack-skills reference that supplies copy-paste Frida JavaScript for common Android assessment tasks when you already follow the parent Android testing methodology. Templates cover SSL pinning bypass across TrustManager and OkHttp certificate pinners, root detection bypass, method tracing, cryptographic API hooks, and WebView debugging scenarios. Solo builders shipping consumer or B2B Android apps use it to reproduce attacker techniques on debug builds they own, then close gaps before store submission. The skill is advanced, device- and Frida-dependent, and intentionally narrow: it is not a full mobile build guide but a script library that accelerates security Ship work alongside emulator or physical test rigs. Pair it with your legal scope and the main SKILL.md workflow rather than treating scripts as production code changes.1.1kinstalls10Api Auth And Jwt Abuseapi-auth-and-jwt-abuse is a Yaklang hack-skills playbook that walks agents through API authentication weaknesses: how to triage JWT headers and claims, which first-shot tests map to common misconfigurations, and where batching or spoofed client IP headers break rate limits. Solo builders shipping bearer-token SaaS or mobile-backed APIs can use it during structured security review—not as a license to attack third parties—to translate OWASP-adjacent JWT folklore into ordered checks on systems they own or have written permission to test. The skill emphasizes trust boundaries (remote JWK fetch, weak HMAC secrets, cross-product token reuse) and pairs token attacks with mass-assignment probes and GraphQL batch patterns. It is intermediate to advanced: you need running endpoints, test accounts, and clear scope. Outputs are findings and repro steps for fixes, not automated exploit chains. Keep legal and program rules primary; the skill is a tester’s cue card for agent-guided sessions.1.1kinstalls11Recon For Secrecon-for-sec is a security methodology router for builders and testers who inherit a fresh target and need a disciplined first pass instead of guessing which vulnerability class to chase. It applies when scope is unclear, attack surface is unknown, or you must translate asset discovery, port and service identification, technology fingerprinting, and endpoint collection into a prioritized testing plan. The skill anchors a recommended flow: validate in-scope assets and target type, run structured discovery and fingerprinting, then branch to specialized follow-ups such as API security, authentication flaws, injection checks, or business-logic abuse. It maps adjacent recon skills for exposed source-control artifacts and dependency-confusion supply-chain signals. Treat it as the front door to the hack-skills security graph—use it to document what you learned and which deeper skill slug should run next. It assumes authorized testing only; it does not replace legal scope paperwork or formal pentest reporting templates.1.1kinstalls12Jwt Oauth Token Attacksjwt-oauth-token-attacks is an expert agent skill from the Yaklang hack-skills collection that walks solo builders and small security-minded teams through JWT and OAuth 2.0 weakness validation in authorized assessments. It is meant when you already have token-based auth and need to stress signing algorithms, key handling, claim abuse, bearer flows, and OAuth account-binding gaps—not when you are greenfield choosing an auth provider. The playbook routes related work to oauth-oidc misconfiguration, CORS cross-origin issues, and SAML SSO assertion testing when enterprise login sits outside pure OAuth/OIDC. For indie SaaS and API products shipping Claude-adjacent stacks, modern apps almost always depend on JWTs; this skill gives procedural coverage that ad-hoc chat rarely structures. Treat all steps as in-scope penetration testing only; pair findings with fixes in your ship security workflow before launch.1.1kinstalls13Websocket Securitywebsocket-security is a Yaklang hack-skills agent skill for solo builders and small teams who ship real-time features—chat, live notifications, collaborative UIs, or WebSocket-backed APIs—and need structured security review beyond REST checklists. It explains protocol handshake markers, success responses, and practical filtering in Burp or browser DevTools, then focuses on cross-site WebSocket hijacking and common vulnerability classes under authorized engagement rules. The skill explicitly treats tokens and payloads as sensitive and points to api-sec when authentication and authorization models should stay consistent across HTTP and WS surfaces. Indie products increasingly lean on sockets for agent dashboards and streaming; this procedural skill helps you catch CSWSH and mis-bound sessions before launch without guessing wire formats.1.1kinstalls14Authbypass Authentication FlawsAuthentication Bypass — Expert Attack Playbook is an agent skill that encodes offensive testing steps for web and service login surfaces. Solo builders and small teams use it when they need repeatable coverage of authentication flaws—bypass via injection, weak reset flows, account recovery gaps, MFA circumvention, session boundary mistakes, and brute-force resistance—under explicit authorization. The skill loads as procedural knowledge for security reviewers and agent-assisted pentesters, with a dedicated planning section for shrinking attack surface (routing entries, default creds, username variants, port focus, and wordlist sizing) before any credential spray. It complements but does not replace JWT/OAuth-focused skills by staying on the login mechanism itself. Outputs are test hypotheses, prioritized checks, and service-specific starter credential sets suitable for staging or bug-bounty scope—not for shipping unreviewed attacks to production without permission.1.1kinstalls15Waf Bypass TechniquesWAF bypass techniques is an advanced agent skill for developers who legally test their own applications when a web application firewall blocks injection probes such as SQLi, XSS, or remote code execution strings. It teaches a structured evasion playbook: recognize the WAF, apply generic categories from encoding and HTTP semantics through HTTP/2 and parameter pollution, then escalate to product-specific guidance via the bundled matrix document. The skill intentionally chains to sibling hack-skills for delivering payloads after bypass, smuggling requests around the WAF entirely, or using Ghost Bits narrowing on Java backends when conventional encodings fail. Solo builders should treat this as authorized security research on owned staging systems, not as a shortcut for attacking third parties. Used well, it helps you confirm whether your WAF and app validation actually hold up or merely block naive signatures.1.1kinstalls16Auth SecAuth-sec is a routing skill for solo builders and small teams who run agent-assisted security reviews on apps with real login and permission boundaries. Instead of jumping straight into payloads, it tells you whether the problem is primarily login mechanics, broken object authorization, browser trust issues like CSRF and CORS, or protocol misconfiguration across JWT, OAuth, OIDC, and SAML. You invoke it when the target exposes authentication surfaces or when you suspect cross-tenant access before you load narrower skills such as authentication bypass, IDOR, JWT attacks, or OAuth misconfiguration guides from the same hack-skills family. It does not replace manual penetration testing or compliance programs; it structures how an coding agent sequences auth work so you waste less time on the wrong attack class. Pair it with your staging environment and explicit authorization to test only systems you own or are permitted to assess.1.1kinstalls17Injection CheckingExtra Injection Types — SSI, LDAP, XPath is a security companion skill for solo builders and indie teams auditing web apps where modern SQLi scanners miss niche parsers. It explains how server-side include directives get evaluated when user input lands in SSI-enabled templates, which web server options must be present, and how to use safe echo probes before attempting command or file-include confirmations. Nginx and Apache configuration cues help agents reason about whether a finding is environmental noise or a real include surface. The readme positions LDAP and XPath as additional less-common injection classes to chase when the stack uses directory queries or XML APIs. Use it during security review passes on admin portals, legacy PHP or .shtml sites, and internal tools before ship—or when reproducing bug-bounty style findings with your coding agent. It supports structured payloads and detection logic; it does not replace authorized scope rules or full DAST pipelines.1.1kinstalls18Business Logic Vulnerabilitiesbusiness-logic-vulnerabilities is an advanced security agent skill from the Yaklang hack-skills family that teaches how to reason about workflows scanners cannot see: race conditions, price and coupon manipulation, referral abuse, negative values, broken state machines, and authorization gaps across multi-step flows. It instructs the agent to load METHODOLOGY.md for modeling and matrices, CHECKLIST.md for module-by-module verification, and SCENARIOS.md for deep exploitation patterns such as payment precision, captcha bypass, and password reset flaws. Solo builders shipping SaaS, marketplaces, or APIs benefit when they want structured red-team thinking without pretending automation replaces judgement. The skill explicitly positions these flaws as high-reward in bug bounty contexts and requires deliberate human reasoning. Use it during security review before launch, when hardening checkout or auth flows, or when documenting test plans for indie products that handle money or identity.1.1kinstalls19Idor Broken Object AuthorizationIDOR / Broken Object Level Authorization is an expert attack playbook skill for solo builders and indie security testers who ship APIs, multi-tenant SaaS, or agent tools that pass user or resource identifiers. Use it when requests expose object IDs, tenant boundaries, writable fields, or missing object-level checks—the scenarios called out in the skill description. The content walks through BOLA versus BFLA, every common location IDs hide, and systematic testing rather than guessing another user’s primary key in the path. It is aimed at bug bounty and pre-launch hardening, not day-to-day feature work. Pair it with broader API security reviews during Validate (scoped prototypes) and Build (backend integrations), but list it under Ship → Security so Prism users find it when they are validating authorization before users hit production.1.1kinstalls20401 403 Bypass Techniques401-403-bypass-techniques is an offensive-security agent skill from the hack-skills lineage for builders and testers who legally assess access controls. It activates when admin panels, API routes, or restricted paths return 401 or 403 despite interesting surface area. The playbook explains why reverse proxies and backends disagree on normalized paths, then walks path manipulation, HTTP method override, header-based bypasses, and protocol tricks in a fuller matrix than typical model defaults. It cross-links sibling skills for authentication flaws, WAF-specific bypass, Host header attacks, request smuggling, and HTTP/2 h2c issues so you can escalate methodically. Use only on systems you own or have written permission to test. Prism catalogs it so solo founders running pre-launch hardening or bug bounty workflows can invoke consistent procedures in Claude Code or similar agents—not as encouragement for unauthorized access.1.1kinstalls21Api Authorization And BolaAPI Authorization and BOLA is an agent skill for solo builders and small teams shipping REST or JSON APIs who need a disciplined authorization test path instead of ad-hoc guessing. It targets broken object-level authorization, broken function-level authorization, HTTP method abuse, and hidden writable fields—the failures that slip past happy-path QA. The playbook starts by creating two accounts, capturing create/read/update/delete traffic as Account A, then replaying identifiers and nested routes with Account B’s token while probing alternate verbs and shadow admin endpoints. Inline payload examples accelerate mass-assignment checks on fields like role, org, or verified flags. The skill also highlights easy-to-miss surfaces such as IDs in headers or GraphQL arguments and cases where a parent resource is authorized but child objects are not. Use it while hardening Ship security for SaaS or internal APIs before release.1.1kinstalls22Oauth Oidc MisconfigurationOAuth OIDC Misconfiguration is a security agent skill that gives a disciplined playbook for finding common identity-provider integration mistakes—weak redirect URI rules, broken state and nonce handling, missing or downgraded PKCE, and loose audience or issuer checks that enable account takeover or token reuse. Solo builders shipping SaaS with social login rarely have a dedicated appsec reviewer; this skill compresses high-value themes into a table-driven review you can run when OAuth endpoints or callbacks appear in scope. Load it when the target uses standard authorize/callback flows; pair with jwt oauth token attacks when review shifts to JWT manipulation rather than flow misconfiguration. It is advanced, checklist-oriented, and meant for deliberate security passes during ship, not for day-one prototyping without an auth surface to assess.1.1kinstalls23Heap ExploitationHeap Exploitation is a Yaklang hack-skills reference module for solo builders and security researchers who already understand ptmalloc2 basics and need precise named heap attack recipes. It documents when each House-style technique applies, which glibc versions block them (for example House of Force before 2.29 top-chunk validation), and what write primitives you must already have. The skill is loaded on demand so agents do not confuse generic malloc talk with step-specific exploit chains. It supports authorized binary security work—CTF challenges, internal red-team labs, and firmware reviews—not typical SaaS feature development. Pair it with the parent heap SKILL.md for allocator layout and version gates before selecting a named method.1.1kinstalls24Csrf Cross Site Request ForgeryCSRF — Cross-Site Request Forgery is a Yaklang hack-skills playbook written for agents and builders who need more than a CSRF token checkbox on a form. It frames the four conditions that make CSRF possible—active session, cookie-only auth, predictable requests, and cross-origin cookie behavior—then walks you through finding and stress-testing state-changing endpoints that actually matter for account takeover. The guidance goes past textbook HTML form posts into SameSite edge cases, JSON and multipart CSRF, login CSRF, and OAuth state handling, with explicit pointers to load CORS and OAuth/OIDC skills when exposure crosses origins or identity flows. Solo founders shipping SaaS or APIs with cookie sessions should invoke it during security review sprints, after major auth changes, or before compliance-sensitive launches. It teaches methodology and attack framing for authorized testing on systems you own or are permitted to test—not a drop-in scanner.1.1kinstalls25Business Logic VulnBusiness Logic Vuln is a Yaklang hack-skills routing skill for solo builders and small teams testing web and API products before launch. It steers the agent when the real risk is workflow abuse—stacked discounts, negative quantities, approval bypass, invite or trial fraud, or race conditions—not classic injection at the parser. You start by mapping key business states and one-time actions, then hunt for check-then-act gaps and weak cross-step authorization, and finally return to sibling routers when the chain needs API, auth, or file-access coverage. It pairs with the fuller Business Logic Vulnerabilities skill for depth. Ideal for indie SaaS, marketplaces, and payment-adjacent backends where a single logic bug equals revenue or account takeover.1.1kinstalls26Cors Cross Origin Misconfigurationcors-cross-origin-misconfiguration is a Yaklang hack-skills security package that teaches agents and builders how cross-origin resource sharing and JSONP mistakes become exploitable—not just theoretical CSP trivia. It is aimed at solo and indie developers shipping SPAs, BFFs, and REST or GraphQL APIs who need a structured lens before go-live or after adding a new third-party integration. The companion readme deepens JSONP hijacking mechanics, watering-hole embedding of callback endpoints, and how authenticated browsers leak sensitive JSON through unvalidated script-src patterns. Use it when you are hardening an MVP backend, reviewing a staging deployment, or iterating on microservices that expose browser-callable routes. Unlike a one-line “set CORS headers” snippet, this skill frames misconfiguration as an attacker workflow so your agent can reason about Origin reflection, credentials, and legacy JSONP in the same pass. Pair it with your own manual verification in devtools and staged environments; it documents attack narratives rather than replacing formal penetration testing.1.1kinstalls27Path Traversal LfiPath Traversal / LFI is an expert attack playbook skill for agents helping solo builders and small security teams reason through local file inclusion and directory escape bugs. It is meant when file paths, download endpoints, include operations, archive extraction, or wrapper behavior might grant filesystem read or code execution—not for casual bug fixes. The material walks encoding chains that base models often miss, OS differences between Linux and Windows separators, and escalation from read primitives to RCE via wrappers or log poisoning. Related routing points you to upload-focused skills or Ghost Bits homoglyph traversal when Java backends block percent-encoded dots. Use it during structured security passes on web APIs and monoliths you own or are authorized to test, and pair findings with remediation in your ship checklist.1.1kinstalls28Traffic Analysis PcapTraffic Analysis & PCAP is an expert playbook skill for agent-assisted network forensics. It targets builders and security practitioners who need structured guidance when opening corrupted captures, filtering in Wireshark or tshark, walking HTTP through TLS, DNS, FTP, SMTP, USB keyboard traffic, WiFi, and ICMP, and extracting files or credentials from PCAPs. The skill emphasizes gaps general models miss—USB HID decode patterns, DNS tunneling checks, and TLS decryption steps—and routes to related skills for memory correlation, stego on carved files, protocol attacks, and shell traffic identification. Use it during incident response, malware traffic review, or competition forensics when you have a `.pcap` and need repeatable analysis commands and mental models rather than ad-hoc guessing at filters.1.1kinstalls29Cmdi Command Injectioncmdi-command-injection is an agent skill that packages an expert OS command-injection attack playbook for builders and security reviewers who need to find shell sinks before attackers do. It walks through metacharacter semantics, quoted-argument breaks, command substitution, and Windows versus Unix timing probes so you are not limited to obvious `;id` smoke tests. The skill emphasizes blind and out-of-band scenarios where stdout never returns, which is where ad-hoc prompting usually misses real bugs in converters, importers, and background jobs. It pairs with broader upload and import routing when the dangerous call chain starts with file handling. Use it during security review, bug-bounty-style self-audits, or CI-adjacent staging checks on APIs and CLIs you ship—not as a substitute for parameterized APIs and strict input allowlists. The playbook is dense enough for intermediate builders who already run staging apps and need repeatable injection families instead of one-off chat guesses.1.1kinstalls30File Access Vulnfile-access-vuln is a Yaklang Hack Skills routing skill for authorized testers who hit parameters, filenames, or workflows that influence filesystem paths on a target. It answers whether the problem is path traversal or local file inclusion versus insecure upload handling across accept, store, process, and serve stages. Solo builders and small teams shipping APIs or SaaS with uploads, previews, or proxied downloads can use it inside a structured pentest or bug-bounty pass so agents do not jump straight to payloads without scoping the entry point. The skill points to path-traversal-lfi and upload-insecure-files and notes related injection and business-logic categories. It assumes you already have legal scope and a concrete endpoint or upload flow to exercise.1.1kinstalls31Graphql And Hidden ParametersGraphQL-and-hidden-parameters is a Yaklang hack-skills playbook for solo builders shipping GraphQL or REST APIs who need structured authorized testing—not ad-hoc query fiddling. It walks introspection and error-based schema discovery, then prioritizes IDOR via object ids, login or fetch batching as a force multiplier, and nested authorization gaps on related types. Parallel tracks cover hidden parameters: fields in admin docs but not public specs, permissive JSON schemas, richer bodies in frontend or mobile clients than the UI exposes, and internal filters for org, role, or feature flags. Use it in the Ship security subphase when GraphQL is in production or when OpenAPI hints at optional or deprecated fields. When findings imply broken object-level auth, the skill points you toward deeper API authorization skills in the same repo stack.1.1kinstalls32Http Parameter PollutionHTTP Parameter Pollution is an agent skill that walks solo builders through HPP when duplicate query or body keys are parsed differently at each hop in the request path. It starts from the hypothesis that security checks read one occurrence of a parameter while business logic reads another, and supplies first-pass payloads, multipart variants, and a methodology to fingerprint front stacks and design scenario chains. Indie devs shipping APIs or multi-tier web apps use it during authorized security review when filters and application layers might disagree—enabling bypass, internal SSRF via a second URL value, logic abuse on amounts, or CSRF token confusion. The skill emphasizes repeatable testing across GET and POST rather than assuming HTTP treats duplicate keys as errors. Pair it with your WAF and framework docs to map which layer wins first versus last.1.1kinstalls33Race ConditionRace-condition is a Yaklang hack-skills playbook for authorized testers targeting web apps where check-then-update logic is not atomic. Solo builders shipping coupons, wallets, referrals, or limited inventory benefit because a single race can duplicate payouts or bypass one-time limits without classic injection. The skill prioritizes one-time and balance-like operations first, then documents parallel delivery techniques—from HTTP/1.1 last-byte synchronization through HTTP/2 single-packet attacks and Turbo Intruder gates—always pairing transport tricks with observable application proof such as duplicate HTTP 200s, divergent balances, or twin ledger entries. It explicitly treats CWE-362-style synchronization gaps as authorization integrity issues. Start here for concurrent abuse on business endpoints; cross-load business-logic-vulnerabilities when the flaw sits in workflow rules rather than pure timing. Authorized testing only.1.1kinstalls34Ssti Server Side Template InjectionSSTI Server-Side Template Injection is an advanced security agent skill focused on finding and classifying template injection in web apps that render user-influenced input server-side. It packages a systematic fingerprinting tree—starting with simple arithmetic probes and branching into engine-specific tests for Python Jinja2, PHP Twig/Smarty, Java FreeMarker/Velocity/EL, Ruby ERB, Node EJS, and related stacks. Companion material extends the core skill with disclosure payloads, RCE-oriented chains where applicable, and blind detection patterns. Solo builders and small teams should treat this as pre-ship or ongoing appsec hardening on apps they own or explicitly pen-test—not as a shortcut for unauthorized scanning. The skill emphasizes reading server responses and errors to narrow the engine before selecting payloads, which mirrors how real assessments are run without replacing a full DAST pipeline or professional pentest engagement.1.1kinstalls35Xxe Xml External EntityXXE — Extended Scenarios & Real-World Cases is a security-focused agent skill from the hack-skills catalog that deepens XML External Entity testing beyond baseline guidance. Solo builders and small teams shipping APIs, document upload features, search backends, or conversion microservices use it to reason about file disclosure, SSRF-style callbacks, and chained RCE when external entities are mishandled. The readme documents high-impact chains such as Apache Solr Config API XXE paired with VelocityResponseWriter abuse, plus practical OOXML manipulation for Word and related formats common in import and preview flows. It is reference material for authorized penetration tests and defensive reviews—not for attacking systems you do not own. Pair it with secure XML parser configuration, strict DTD disabling, and upload validation during ship-phase security work so agents produce concrete test ideas instead of generic “check for XXE” advice.1.1kinstalls36Deserialization InsecureDeserialization-insecure is a Yaklang hack-skills deep-dive for solo builders and small teams who run authorized security tests on their own APIs and services. It extends the main insecure-deserialization skill with Java gadget-chain version compatibility (CommonsCollections and CommonsBeanutils), cross-language patterns (YAML, Hessian, Kryo, ViewState, Ruby), and magic-byte fingerprinting so you can narrow libraries and JDK constraints before firing payloads. Use it during ship-phase security work when logs or WAF alerts suggest serialized blobs, not as a substitute for fixing parsers and signing secrets on ViewState. The content assumes ysoserial basics and PHP/Python fundamentals from the parent SKILL.md are already in context. Prism lists it for builders who wear the security hat before launch or during bug-bounty prep on apps they own or are contracted to test.1.1kinstalls37Format String ExploitationFormat String Exploitation is an expert offensive-security agent skill that walks you through printf-family bugs end to end: spotting user-controlled format strings, leaking canaries and libc/PIE bases, and escalating arbitrary read/write primitives into code execution. It is written for solo builders and small teams doing CTF prep, security coursework, or deliberate appsec review on native code—not for casual feature work. The playbook stresses common model failure modes such as wrong positional argument offsets and poor 64-bit address layout after the format string. It routes to related skills for stack overflow ROP chains, binary protection bypass, heap exploitation, and arbitrary-write-to-RCE conversion so you do not stop at a single leak. Use it when you already suspect a format string sink and need a repeatable methodology instead of guessing gadget chains from chat.1.1kinstalls38Crlf InjectionCRLF Injection is an agent skill that gives solo builders and security reviewers an expert attack playbook for carriage-return and line-feed injection when user-controlled data lands in HTTP response headers, Location redirects, Set-Cookie values, or log files. It explains how a single unsanitized reflection can split one header into many or smuggle a response body, and walks through detection, header and body injection, XSS escalation, cache poisoning, and encoding bypasses that many automated scanners skip. The skill is aimed at indie devs shipping SaaS, APIs, or internal tools who need repeatable manual test cases during security review—not production code generation. It references related routing when standard percent-encoded CRLF is blocked on Java services. Use it in authorized assessments or your own staging environments before launch.1.1kinstalls39Request SmugglingRequest Smuggling (advanced variants) is an agent skill extension for security testers who already understand classic TE/CL smuggling and need HTTP/2-specific desync, cache poisoning follow-ons, and CDN edge cases. It documents H2.CL disagreements between H2 frame length and forwarded Content-Length, Fat GET patterns, and client-side desync so you can reason about real proxy downgrade paths instead of copying generic cheatsheets. Solo builders shipping APIs behind Cloudflare, nginx, or multi-tier gateways use it during authorized assessments to validate whether one request can queue a second on the origin. It is advanced, offensive material—only load on systems you own or have written permission to test—and pairs with broader appsec review workflows rather than everyday feature work.1.1kinstalls40Open RedirectOpen Redirect is an agent skill playbook for solo builders and small teams who need structured coverage beyond guessing ?next= parameters. It explains how trusted domains become launchpads for attacker-controlled destinations, catalogs common parameter names and framework redirect APIs, and separates server-side Location behavior from client-side JavaScript sinks. The skill emphasizes chaining—phishing credibility, OAuth abuse, CSRF referer tricks, and SSRF stepping stones—so findings are prioritized by real blast radius rather than informational noise. Use it during security review of login, checkout, and marketing links where user-supplied URLs drive navigation. It is offensive guidance intended for scoped assessments and fix verification, not for weaponizing third-party sites without permission.1.1kinstalls41Insecure Source Code ManagementInsecure Source Code Management is an agent skill for authorized security assessments that helps solo builders and testers find when version-control folders, backup files, and environment configs are reachable over HTTP. It gives a quick-start routing note and concrete paths to probe first, then walks through Git and related VCS exposure signals so agents do not ad-lib dangerous recon. The skill emphasizes authorized use only, rate limits, and not exfiltrating real data beyond scope—making it a procedural checklist rather than a generic hacking prompt. Pair it with broader recon skills when those exist in the workspace so discovery stays structured. It matters for indie SaaS and API builders who self-host or use shared hosting where a mispublished .git directory can leak secrets and history in minutes.1.1kinstalls42Kubernetes PentestingKubernetes Pentesting packages an expert offensive playbook for solo builders and tiny teams who run their own clusters on EKS, GKE, AKS, or self-managed Kubernetes and cannot afford a dedicated red team before launch. The skill routes agents through realistic attack surfaces: overly permissive API server access, RBAC misbindings between namespace and cluster scope, long-lived service account tokens, etcd backups leaking secrets, and the commonly missed unauthenticated Kubelet API. It also covers cloud metadata abuse from pods, admission webhook bypass thinking, and network policy evasion, with explicit pointers to companion skills for container escape, Linux privilege escalation, and SSRF chains into the control plane. Use it during ship-phase security assessment or operate-phase incident validation when you need ordered checks instead of random kubectl grep. It is procedural attack knowledge for authorized assessments, not a replacement for platform hardening guides.1.1kinstalls43Web Cache DeceptionWeb Cache Deception (advanced reference) deepens the yaklang hack-skills cache module for builders and security-minded developers who ship cached HTTP APIs or multi-tenant SaaS behind CDNs. It clarifies two often-conflated classes: cache poisoning, where an attacker seeds malicious responses for everyone, versus cache deception, where a victim’s authenticated response is cached and later read by the attacker through path or extension confusion. The reference walks unkeyed inputs, Fat GET variants, parameter cloaking, CDN quirks, and Vary-header pitfalls so your agent does not stop at textbook path-append tests. Solo operators rarely have a dedicated AppSec bench; this skill packages expert distinctions and detection signals into agent-loadable prose you invoke during ship-phase review or targeted bug bounty work. It assumes fundamentals from the parent SKILL.md are already in context.1.1kinstalls44Kernel Exploitationkernel-exploitation is an advanced reference skill in the Yaklang hack-skills bundle that documents Linux kernel heap exploitation techniques for authorized security work. It assumes loaders already understand the broader kernel exploitation model from sibling SKILL.md material and mitigation context from KERNEL_MITIGATION_BYPASS. The content walks SLUB allocator behavior, freelist randomization and hardening, heap spray reliability, and cross-cache strategies, then drills into exploitation patterns around common kernel structures. Indie builders rarely need this unless they run security research, kernel CTF, or formal pentest engagements on Linux targets. It is reference material for agents assisting exploit development or deep security reviews—not a shipping checklist for SaaS features.1.1kinstalls45Jndi InjectionJNDI injection is an expert attack playbook from yaklang hack-skills for authorized security testers targeting Java naming lookups that reach user-controlled strings. Solo builders shipping JVM backends, Spring services, or logging stacks use it during Ship security work to distinguish true JNDI sinks from deserialization or EL issues, then follow lookup-mechanism abuse, RMI and LDAP class loading, marshalsec tooling, and Log4Shell-relevant patterns without mixing attack surfaces. The skill documents vulnerable code shapes, routes to related skills when post-8u191 bypasses lean on gadgets or when SpEL and OGNL are in the chain, and assumes you already have legal scope for offensive testing. It is advanced material meant for code review, pentest prep, and remediation planning—not casual feature development.1.1kinstalls46Csv Formula Injectioncsv-formula-injection is an agent skill for solo builders and small teams who ship features that dump user or admin data into CSV downloads, BI exports, or spreadsheet imports. It teaches how cells that begin with =, +, -, or @ can execute formulas, DDE chains, or remote fetches when opened in Excel, LibreOffice, or cloud sheets—material that belongs in security review, not casual copy-paste from blog posts. The SKILL.md frames lab-only reproduction, documents impactful payloads responsibly, and tells you when to prioritize prefix routing during export pipelines. Use it while hardening Ship-phase release gates or when revisiting Build-time export serializers so you do not accidentally weaponize customer names or ticket fields. It does not replace a full pentest program, but it gives your agent a structured checklist for spreadsheet-side execution risk that OWASP-style app testing sometimes misses.1.1kinstalls47Saml Sso Assertion AttacksSAML SSO assertion attacks is a yaklang hack-skills playbook for authorized testers validating how a service provider trusts IdP-issued SAML assertions. Indie builders shipping B2B SaaS with external identity providers load it during Ship security to systematically check signature validation, assertion wrapping, audience and recipient restrictions, ACS endpoints, freshness fields, and multi-tenant issuer confusion—without treating SSO as a black box. The skill emphasizes capturing one complete browser POST or redirect binding round trip, mapping which XML elements are actually signed, and correlating misconfigurations to account takeover or privilege bleed. It pairs naturally with broader appsec review but stays focused on SAML XML trust boundaries and enterprise login flows rather than generic API auth.1.1kinstalls48Clickjackingclickjacking is a Yaklang hack-skills playbook that teaches agents how to assess and demonstrate UI redress attacks against web applications. Solo builders shipping admin panels, billing flows, or account settings can use it during authorized security passes to verify framing policy: X-Frame-Options, Content-Security-Policy frame-ancestors, and real click paths on sensitive endpoints. The skill explains transparent iframe overlays, decoy buttons, multi-step sequences, and drag-and-drop variants that turn a naive “low” finding into critical impact when high-privilege actions lack clickjacking defenses. It is explicitly an expert attack playbook for testers—not a feature to embed in product code. Load it when validating that your SaaS cannot be forced to delete accounts, change passwords, or approve payments via invisible frames.1.1kinstalls49Expression Language InjectionExpression Language Injection is an advanced agent skill from the hack-skills collection that packages procedural offensive security knowledge for Java ecosystem expression evaluators. Solo builders shipping Spring APIs, legacy Struts surfaces, or enterprise Confluence-style deployments can invoke it during authorized assessments to distinguish EL injection from server-side template injection, run polyglot arithmetic probes, and follow framework-specific escalation guidance including sandbox escapes and actuator misuse. The readme stresses that ${7*7} may indicate multiple engines, so disambiguation tables and related-skill routing prevent misapplied payloads. It is not a replacement for automated scanners; it accelerates expert reasoning inside the agent when you already suspect attacker-controlled expressions reach an evaluator. Use only on systems you own or have written permission to test, and fold findings into ship-phase review gates before launch.1.1kinstalls50Dependency ConfusionDependency Confusion is an agent skill that documents how package managers can resolve internal-looking names from public registries when version ranges and index order allow a newer attacker-controlled release. It is built for security-minded solo builders, indie SaaS teams, and authorized pentesters who need repeatable manifest and CI cache review across npm, pip, Rubygems, Maven, Composer, and Docker contexts. Use it during Ship security hardening, before merging dependency changes, or when auditing whether lockfiles and private registry configuration actually enforce your intended feed. The skill emphasizes recon on naming leaks, resolver behavior including scopes and extra indexes, and proof patterns that demonstrate impact without destructive exfiltration. It explicitly requires authorization on systems under test. Pair it with broader supply-chain recon when manifests or build pipelines are in scope so agents do not hand-wave install scripts as low risk.1.1kinstalls51Browser Exploitation V8browser-exploitation-v8 is an advanced agent skill from the hack-skills collection that teaches how to turn JavaScript engine flaws in Chrome and Chromium into usable exploit chains. It is aimed at security researchers, CTF competitors, and bug-bounty practitioners who already work in authorized contexts and need correct mental models for the V8 compilation pipeline, object representation, and post-bug primitive construction. The skill explains when to pursue JIT type confusion and bounds-elimination bugs, how addrof and fakeobj primitives fit into wider memory corruption, and where ArrayBuffer and WASM RWX techniques enter the chain. It also foregrounds the V8 sandbox and pointer compression as hard gates that base models often mishandle. Rather than replacing hands-on debugging, it gives your coding agent a consistent attack narrative and explicit handoffs to heap, ROP, and Chrome IPC escape skills so planning stays aligned with Project Zero–style and CTF-wiki patterns.1.1kinstalls52Ios Pentesting TricksiOS Pentesting Tricks is a reference skill for security-minded solo builders and small teams auditing their own iOS apps or client engagements. Load it when you already follow the parent iOS pentesting methodology and need copy-paste Frida recipes, Objection commands, and hook templates rather than repeating boilerplate. Coverage includes enumerating sensitive ObjC classes, listing methods on targets like AppDelegate, and bypassing jailbreak detection via path and API hooks. It is advanced, hands-on mobile appsec work tied to instrumented devices or simulators where Frida attaches to running processes. Use during Ship-phase security reviews before App Store submission or after receiving a penetration test report, to validate fixes or reproduce findings. It does not replace threat modeling or static analysis; it accelerates dynamic runtime verification.1.1kinstalls53Prototype Pollutionprototype-pollution is an expert attack playbook for client and server JavaScript stacks where untrusted input becomes object keys. It routes you when you see recursive merges, query parsers, or JSON bodies layered onto defaults—situations that can silently alter Object.prototype and enable denial of service or remote code execution through known gadgets. Quick-start probes span hash/query parameters and POST JSON using both __proto__ and constructor.prototype shapes. The skill assumes you already understand inheritance and spread; it emphasizes parser-specific behavior and post-pollution sinks rather than generic XSS. Solo builders shipping Node APIs, admin panels, or embedded JS should run these checks before trusting third-party merge utilities or custom deep-assign helpers.1.1kinstalls54Llm Prompt InjectionLlm-prompt-injection is a deep reference skill from hack-skills that catalogs LLM jailbreak and prompt-injection techniques for authorized security testing. Solo builders shipping agents, copilots, or RAG APIs can use it in Ship to design regression suites and in Build when hardening system prompts and tool policies. The readme positions it as a load-on-demand extension: once the base SKILL.md explains injection concepts, this file supplies named patterns such as DAN lineages and developer-mode personas with example payloads. It is aimed at builders who need reproducible red-team scripts rather than ad-hoc “try to break my bot” chats. Pair it with your own policy on ethical use—only systems you own or have permission to test. The skill improves AEO-facing agent security literacy by naming real technique families defenders must patch against in guardrails, output filters, and human review.1.1kinstalls55Type JugglingType Juggling is an agent skill from the hack-skills lineage that guides authorized testing of PHP weak comparison bugs—authentication branches, HMAC or signature checks, and token validation that rely on `==` instead of strict types. Solo builders and security-minded indies use it during code review or pen tests on legacy PHP and CTF-style targets: map the comparison sink, confirm PHP version behavior, then apply minimal probes before escalating payloads. The skill emphasizes proving the server treats unequal secrets as equal via coercion, not guessing credentials. It pairs quick-start payloads with local `php -r` probes and a routing table from code clues to next steps. When source already uses `hash_equals` or `===`, the skill directs you elsewhere—avoid wasted effort and false positives.1.1kinstalls56Xslt Injectionxslt-injection is an agent skill that walks solo builders and small security-minded teams through authorized XSLT injection testing when attacker-influenced stylesheets may compile or execute on the server. It starts at transform sinks—parameters named xslt or stylesheet, SOAP stylesheets, report generators, and XML-to-HTML converters—then confirms execution with harmless probes before fingerprinting whether the stack is Java, .NET, PHP, or libxslt. From that map, the skill escalates along realistic chains: document() for outbound requests, XXE where entities apply, EXSLT write where supported, and language-specific extension functions that can surface remote code execution. It explicitly routes you to companion XXE and SSRF skills when the data path is generic XML parsing or outbound HTTP rather than a dedicated transform pipeline. Use it during pre-launch hardening or targeted appsec reviews, not as a substitute for formal penetration testing sign-off.1.1kinstalls57Binary Protection BypassBinary Protection Bypass is a reference matrix skill for AI-assisted offensive security and binary analysis. It systematically maps bypass techniques to specific protections (starting with ASLR and PIE) and states the memory corruption or leak primitive each path requires, along with qualitative success rates and architecture constraints. Solo builders and small teams rarely ship native exploit chains daily, but indie security researchers, bug-bounty hunters, and agent operators doing CTF or firmware review need this kind of structured lookup instead of ad-hoc recall. Use it when you already identified a protection on a target binary and must choose the smallest primitive that defeats it, or when comparing deterministic leaks versus brute-force or sigreturn-based strategies. The doc explicitly instructs agents to load the parent SKILL.md for individual protection deep dives and treat this file as the cross-reference layer. It is advanced, liability-sensitive material aimed at authorized testing only.1.1kinstalls58Http Host Header AttacksHTTP Host Header Attacks is an agent skill playbook for finding and chaining Host-header injection when applications trust Host for links, routing, or access control. Solo builders shipping SaaS behind CDNs or multi-tenant reverse proxies often underestimate how reset emails, absolute redirects, and cache keys inherit attacker-controlled hosts—the skill documents those surfaces plus double-Host tricks, absolute-URI override, and connection-state angles that generic models skip. Invoke it during authorized assessments of your staging or production app, or while building security regression tests for your own framework configuration. It routes to related yaklang skills for cache deception, SSRF, open redirect, request smuggling, subdomain takeover, and WAF bypass when Host manipulation is only one layer of the chain. The audience is builders and security-minded operators who need procedural coverage, not a single CVE write-up. Pair with manual proxy tooling and fixed test tenants rather than spraying payloads against third-party sites.1.1kinstalls59Active Directory Acl Abuseactive-directory-acl-abuse is an agent skill extension for authorized Active Directory assessments. It assumes you already use the parent SKILL.md for concrete ACL abuse moves and adds BloodHound collection tradeoffs, lower-noise ingest options, and copy-paste Neo4j Cypher for high-value paths such as routes to Domain Admins and principals with DCSync-relevant rights. Solo builders and small teams running internal labs, MSSP-style checks, or agent-assisted red-team prep install it so Claude Code, Cursor, or Codex stop improvising graph queries and collection switches mid-engagement. Use it when Neo4j is loaded, you need repeatable chain analysis, and you want DC-only or session-focused runs instead of blasting full SMB enumeration. It does not replace legal scope, credential handling, or remediation— it standardizes how you query and collect so findings tie back to ACL edges you can fix in Group Policy, delegation, and tiering.1.1kinstalls60Arbitrary Write To RceArbitrary Write to RCE is an advanced agent skill for security researchers and CTF-focused solo builders who already hold an arbitrary write primitive and must land code execution without targeting obsolete glibc hooks. The playbook maps overwrite targets—GOT, legacy malloc/free hooks, _IO_FILE vtables, exit function chains, TLS destructors, dynamic linker finish paths, modprobe_path, .fini_array, and C++ vtables—with version-aware guidance so post-glibc 2.34 environments are not approached with hook strategies that no longer exist. It explicitly positions itself as the last mile after heap exploitation, format-string %n primitives, or stack-based writes, and cross-links deep _IO_FILE material and protection bypass logic. Install it when auditing native services, practicing exploit development, or teaching agents systematic escalation paths—not when building normal application features. Expect dense low-level C/Linux context, not generic “scan my SaaS” advice.1.1kinstalls61Active Directory Kerberos Attacksactive-directory-kerberos-attacks is an advanced agent skill for chaining Kerberos-related Active Directory techniques into end-to-end escalation narratives. It assumes you already loaded the parent Kerberos skill for atomic attacks and now need orchestration: for example Kerberoasting a service account, discovering constrained delegation, obtaining a service ticket as administrator, and dumping secrets from a domain controller. Another documented path covers resource-based constrained delegation when you have GenericWrite on a computer object, creating a machine account, setting RBCD, and moving laterally. Solo builders rarely run their own AD forests, but small teams shipping B2B SaaS on customer VPNs or MSPs validating client environments can use this inside authorized assessments. Outputs are chain diagrams and command sequences suitable for purple-team tabletop or lab reproduction—not for casual agent chat without scope.1.1kinstalls62Csp Bypass Advancedcsp-bypass-advanced is an agent skill package for authorized testers who hit a Content Security Policy wall during XSS or exfiltration work. It walks through advanced bypass angles—nonce and hash abuse, trusted endpoint misuse, gaps in base-uri and object-src, and framework-specific weak spots—so you do not assume unsafe-inline or miss non-script exfil paths. Solo builders shipping browser-facing SaaS or extensions can use it during structured ship-phase reviews or when debugging why a reported injection fails in staging. It complements sibling hack-skills for XSS delivery, dangling markup when scripts stay blocked, CRLF for header or nonce theft, WAF evasion, and clickjacking when frame-ancestors is absent. Treat outputs as findings for remediation, not production attack recipes.1.1kinstalls63Subdomain TakeoverSubdomain Takeover is an agent skill that walks solo builders and small security-minded teams through detecting and reasoning about subdomain takeover risk when DNS still points at cloud or SaaS resources that are gone or never claimed. It is for anyone shipping a product on a real domain who needs more than a passive subdomain scanner: the skill stresses that a dangling CNAME alone is not proof of exploitability until the backing tenant can be registered. The playbook maps provider-specific fingerprints, claim flows, and how a successful takeover chains into SSRF bypasses, wildcard CORS trust, XSS under the victim origin, and cache or Host-header issues. Use it during pre-launch hardening, bug-bounty style assessments, or when auditing acquisitions with messy DNS. It complements defensive monitoring so you fix records before an attacker registers the orphan endpoint.1.1kinstalls64Active Directory Certificate ServicesActive-directory-certificate-services is a red-team-oriented agent skill that documents how misconfigured AD Certificate Services enable template abuse, relay to enrollment, and certificate-backed persistence. Prism lists it for builders and operators who run authorized assessments on Windows estates—not for casual indie app shipping. The SKILL.md stresses what base models miss: stacked ESC conditions, enrollment prerequisites, and when to load sibling playbooks for ACL edits (ESC4), Kerberos follow-on, or coercion for ESC8. Use it when you already have lab or customer scope, tooling for AD CS enumeration, and a need to map findings to ESC variants with defensible detection notes. Complexity is advanced; outputs are engagement-ready attack paths and matrix-backed command references rather than product features. Pair it with organizational change control because certificate issuance touches domain-wide trust.1.1kinstalls65Symbolic Execution ToolsSymbolic-execution-tools packages ready-to-run angr patterns for solo builders tackling capture-the-flag binaries or similar constrained reversing puzzles. Instead of rebuilding the same simulation_manager boilerplate, you load scenario-matched recipes: address-tied find/avoid, stdout-driven success detection for position-independent layouts, and length-bounded printable flag symbols via Claripy. The skill targets intermediate users who already understand basic angr project and state setup from the parent SKILL.md and want copy-paste starting points they can adapt to scanf, fgets, or argv models. It fits agent-assisted workflows where your model proposes exploration goals while you supply binary paths and success strings. Expect heavy CPU and memory use on large binaries—this is a surgical testing aid, not a default CI step for every app you ship.1.1kinstalls66Anti Debugging TechniquesAnti-debugging-techniques is a reference skill for solo builders and security-minded agents who need a structured matrix of debugger-evasion methods rather than scattered forum notes. It maps each technique to how it is detected on target operating systems, how reliable that signal is, which bypass approaches apply, and which tools practitioners typically use. The document assumes you already loaded the parent SKILL.md for concepts and is optimized for deep lookups during malware triage, CTF reversing, or authorized hardening reviews. You reach for it when a binary refuses to run under GDB, behaves differently under Frida, or you need to document detection coverage for a threat model. It does not replace hands-on lab practice but collapses weeks of cheat-sheet hunting into one agent-loadable surface so your coding assistant can suggest the next probe instead of generic “disable ptrace” advice.1.1kinstalls67Memory Forensics VolatilityMemory Forensics — Volatility is an advanced agent playbook for expert memory dump analysis using Volatility 2 and 3. Solo builders and small security teams use it when incident response or malware review requires RAM evidence: OS identification, process trees including hidden processes, network sockets, injected code, and credential artifacts. The skill stresses command parity gaps between Vol2 and Vol3 that generic models often miss, plus Linux-specific acquisition and analysis paths. It points to a bundled cheatsheet for plugin sequences by investigation type and optional related skills for PCAP correlation, steganography, and Windows privilege escalation context. Invoke when the user is doing memory forensics, Volatility workflows, or reconstructing attack timelines from dumps—not for routine app debugging without a dump file.1.1kinstalls68Http2 Specific AttacksHTTP/2 Specific Attacks is an agent skill playbook from the hack-skills collection for security testers and builders who harden edge proxies and APIs. It activates when the target supports HTTP/2 and you need techniques that only exist on the binary-framed protocol: HPACK table manipulation, pseudo-header abuse, h2c cleartext upgrade smuggling, single-packet races over multiplexed streams, and downgrade paths that inject ambiguous requests into HTTP/1.1 backends. The skill positions itself as complementary routing to request-smuggling fundamentals and dedicated H2 smuggling variant docs, plus race-condition and cache-deception skills when poisoning or desync chains apply. It is written for authorized assessments, CTF-style labs, and architecture reviews—not for shipping product features. Intermediate-to-advanced readers should already understand reverse proxies, TLS termination, and baseline smuggling theory before applying frame-level payloads.1.1kinstalls69Stack Overflow And RopStack Overflow and ROP is an advanced agent skill from the yaklang hack-skills package for solo builders and security researchers who already grasp fundamental ROP and need a structured playbook for harder Linux exploitation scenarios. It walks through Blind ROP when you cannot read the remote binary: crash-driven stack and canary recovery, discovery of stop and BROP gadgets, leaking via puts or write PLT stubs, dumping pages from memory, and finishing with ret2libc using the recovered image. The readme also points to ret2vdso for ASLR bypass, partial overwrites to defeat PIE without full leaks, and jump-oriented or call-oriented programming when return stacks are constrained. Use it during authorized CTF work, lab binaries, or penetration tests where forking servers preserve canary and mapping layout across probes. It is procedural exploit knowledge meant to pair with the package’s main ROP skill, not a substitute for legal scope, sandboxing, or secure coding in your own SaaS codebase.1.1kinstalls70Vm And Bytecode ReverseVM and Bytecode Reverse Engineering is an expert analysis playbook for agents tackling custom interpreters: the skill teaches recognition of dispatcher patterns, systematic opcode mapping, ISA reconstruction, and when to build a disassembler or lean on symbolic tools. It targets CTF players, malware analysts, and indie developers auditing licensed or crackme-style binaries that hide logic behind a virtual CPU. Quick-identification tables steer you from switch-dispatch loops versus indirect jump tables versus nested if-chains. Related routing points to code obfuscation deobfuscation when commercial protectors wrap the VM, symbolic execution when angr can solve constraints, and anti-debugging when the VM guards analysis. The workflow is advanced and hands-on—you need patience for handler-by-handler annotation. Outcomes are a readable opcode semantics table and a path to emulate or decompile the VM program rather than dead-ending on opaque byte streams.1.1kinstalls71Windows Av EvasionWindows AV Evasion (AMSI bypass supplement) is a deep-dive agent skill from yaklang hack-skills that documents how Anti-Malware Scan Interface scanning works on Windows and catalogs memory-patching and obfuscation patterns aimed at AmsiScanBuffer. It assumes the parent SKILL.md is already loaded and extends coverage to PowerShell-specific bypasses, .NET AMSI interaction, and escaping Constrained Language Mode. Solo builders should only use this in explicitly authorized engagements—own lab, contracted pen tests, or defensive purple-team exercises—to understand attacker tradecraft and improve detections. The readme emphasizes variable randomization and implementation variance rather than copy-paste weaponization. Prism lists it for discoverability of security research skills; it does not endorse illegal use. Pair with proper logging, EDR baselines, and legal review. Not a replacement for Microsoft’s security guidance or enterprise GPO hardening.1.1kinstalls72Dangling Markup InjectionDangling Markup Injection is an agent skill from the hack-skills security playbook for solo builders and small teams who need to assess real-world HTML injection impact when JavaScript cannot run. Many assessments stop at “CSP blocks scripts” and miss that unclosed tags can still capture and leak subsequent page content to an attacker-controlled URL. The skill walks through when to prefer dangling markup over full XSS, what assets are stealable (CSRF tokens, session-adjacent data, sensitive DOM text), tag choices, and how to chain findings into CSRF or cache-related attacks. It is meant for authorized testing on apps you own or have permission to test, and pairs naturally with XSS, advanced CSP bypass, and CSRF skills in the same catalog family.1.1kinstalls73Mobile Ssl Pinning BypassMobile SSL Pinning Bypass is an expert attack playbook skill for indie developers and security testers who must inspect HTTPS from mobile apps that refuse trust-store proxies. Certificate pinning, public key pinning, and SPKI hashing block normal MITM tools; this skill catalogs bypass tooling and hook patterns per platform, then drills into framework-specific implementations where generic SSL unpinning fails. It emphasizes resilience differences between pinning types and how modern apps stack custom validators with network libraries. After bypass succeeds, practitioners typically pivot to API security testing. The skill assumes lawful use on apps you develop or are engaged to assess, and complements dedicated Android and iOS pentesting tricks in the same repository family.1.1kinstalls74Email Header InjectionEmail Header Injection is an agent skill that packages an expert attack playbook for authorized security testing. Solo builders shipping SaaS with contact forms, transactional email, or password-reset flows can invoke it when user input might reach SMTP headers without strict sanitization. The SKILL.md distinguishes technical CRLF injection in headers from protocol-level authentication bypass (SPF, DKIM, DMARC) and display-name spoofing—surfaces base models often conflate. It references sibling hack-skills for general CRLF, SSRF-to-SMTP, and open redirects in reset links. Use it in the Ship phase during security review or pre-launch pentests on staging, not as a shortcut for phishing real users. Outputs are methodological guidance and test ideas you document in findings reports. You must have explicit permission to test the target environment.1.1kinstalls75Hash Attack TechniquesHash-attack-techniques is a Yaklang hack-skills playbook that trains agents to choose the right cryptanalytic move when a challenge or authorized test hinges on broken hash usage. Solo builders and security-minded developers often misapply length extension to HMAC or SHA-3, or confuse identical-prefix with chosen-prefix MD5 collisions—this skill documents when each attack applies and which tools typically support it. It is framed for CTF and permitted security assessments, with cross-links to RSA, symmetric cipher, and classical analysis skills when hash flaws sit inside larger protocols. Use it while hardening custom authentication tags, reviewing legacy MD5/SHA1 deployments, or solving proof-of-work puzzles—not for attacking systems you do not own. The content is dense procedural knowledge meant to load before exploitation scripts run so your agent does not waste cycles on mathematically impossible paths.1.1kinstalls76Ai Ml SecurityAI/ML Security is an expert attack-playbook agent skill aimed at builders who ship models, fine-tunes, or autonomous agents and cannot treat Hugging Face downloads or pickle checkpoints as benign files. It structures assessment around supply chain compromise (malicious serialization in .pt/.pth weights), adversarial manipulation at inference, poisoning during training, and extraction attacks that clone proprietary models from APIs. Privacy sections address membership inference and inversion—risks that matter when user data trained the model. The skill explicitly notes that default models underestimate pickle RCE severity and the feasibility of model extraction, nudging agents toward realistic threat models. It cross-links sibling skills for LLM prompt injection, general deserialization, and dependency confusion when ML pipelines mix pip and npm ecosystems. Solo founders running agent products or embedded LLM features should run this before Ship and revisit in Operate when models or dependencies change. It is offensive knowledge for defensive hardening and red-team style review, not a compliance checklist replacement.1.1kinstalls77Linux Lateral MovementLinux Lateral Movement is an agent skill packaged as an expert attack playbook for authorized testers who already have a foothold on a Linux host and must pivot across the environment. It walks through SSH agent hijacking, harvesting credentials from common locations, abusing shared filesystems, D-Bus exploitation, sudo token reuse, and systemd manipulation—areas where generic models often miss SSH_AUTH_SOCK hijacking and ptrace-based sudo session hijack. The skill expects you to load sibling Yaklang hack-skills when you need local root first, when shells are restricted, when targets are containerized or on Kubernetes, or when internal services like Redis need service-specific exploitation. It is procedural knowledge for red-team and appsec workflows, not a shipping feature generator. Solo builders should only invoke it inside explicit legal scope with written permission.1.1kinstalls78Dns Rebinding AttacksDNS Rebinding Attacks is a security agent skill that teaches how to abuse DNS resolution timing so a victim browser treats responses from an attacker server and from an internal IP as the same origin. The playbook emphasizes the distinction base models often blur: rebinding is a client-side same-origin problem, whereas SSRF is server-side request forgery. It documents TTL manipulation, cache bypass considerations, attack variants across HTTP and WebSocket, time-of-check/time-of-use patterns, and targeting internal services when server-side SSRF is unavailable but JavaScript can fetch attacker-controlled domains. Related routing points to SSRF and CORS skills when those misconfigurations offer simpler reads. Solo builders running pre-launch security reviews on apps that pin trust to DNS hostnames or embed client-side fetches benefit from structured test ideas; unauthorized use against third parties is out of scope.1.1kinstalls79Container Escape TechniquesContainer Escape Techniques is a security-focused agent skill that documents end-to-end escape chains for misconfigured Docker and Kubernetes environments. It assumes foundational escape material from the parent SKILL.md is already loaded, then walks through concrete sequences such as privileged containers mounting host disks and chrooting to root, cleaner nsenter entry via PID 1, and Docker socket paths when a client is available. Each chain lists verification steps, typical device nodes, and optional persistence patterns so defenders and authorized testers can map attack surfaces to controls. Solo builders running self-hosted agents or k8s sidecars should use it only inside legal scope—to reproduce lab findings and fix caps, mounts, socket exposure, and namespace sharing—not as a deployment shortcut.1kinstalls80Classical Cipher AnalysisClassical Cipher Analysis is an expert agent skill packaged as a CTF-oriented cryptanalysis playbook. Solo builders and security hobbyists install it when agent outputs guess cipher types too quickly or skip decoding layers before analysis. The skill walks through identification methodology—frequency analysis, index of coincidence, Kasiski examination—and then applies the right break for substitution, polyalphabetic, transposition, classical encoding schemes, or XOR. It explicitly contrasts classical puzzles with modern symmetric, hash, and lattice problems so you route to sibling skills instead of forcing classical tools on AES or knapsack tasks. It matters because base models often misclassify ciphertext or treat still-encoded blobs as raw cipher text; this skill forces observation-driven triage first. Best for capture-the-flag players and anyone analyzing toy ciphers in challenges—not for production TLS or application crypto design.1kinstalls81Linux Privilege EscalationLinux Privilege Escalation is an advanced agent skill from the hack-skills family that gives security practitioners a structured kernel-exploit reference when a foothold host runs an outdated Linux kernel. After loading the parent SKILL.md, this extension maps versions to named exploits (DirtyPipe, DirtyCow, OverlayFS variants, nf_tables, io_uring, Netfilter batch issues, and more), cites CVEs and kernel ranges, and flags stability so you waste less time on crash-prone chains. It also covers practical compilation, cross-compilation, and static linking considerations for lab or engagement workflows. Solo indie builders should treat this as specialized offensive-security knowledge for authorized assessments, CTF practice, or validating that their own servers are patched—not as a default step in shipping a consumer app. It does not replace vulnerability scanning or patch management; it accelerates manual escalation research when kernel age is already in scope.1kinstalls82Upload Insecure FilesUpload Insecure Files is an advanced security agent skill that extends the core upload-insecure-files playbook with parsing-edge cases and CVE-grounded examples for authorized testers. It explains how IIS, Nginx, and Apache can execute or mishandle uploaded content when extensions, directories, null bytes, newlines, or .htaccess rules interact badly with server configuration. Solo builders shipping user-generated content should use it during security review to red-team their own upload pipelines—not to bypass third-party systems. The skill pairs conceptual tables (technique, example, mechanism) with exploitation-flow reasoning so an agent can suggest test filenames, config checks, and parser-specific hypotheses. It complements secure-upload implementation work in Build by focusing on what breaks when validation is extension-only or when CGI pathinfo and handler rules are wrong. Outputs are test ideas and case patterns suitable for manual verification in staging.1kinstalls83Windows Privilege EscalationWindows Privilege Escalation is an offensive-security agent skill packaged as an expert attack playbook for authorized assessments. It assumes you already have low-privilege execution on a Windows host and need a methodical escalation path instead of guessing techniques that fail on modern builds. Coverage spans token manipulation, the Potato exploit lineage, misconfigured services, DLL hijacking, AlwaysInstallElevated, scheduled task abuse, registry autoruns, and named pipe impersonation—with explicit notes on prerequisite privileges and version-specific constraints that generic models mishandle. The skill also points to companion hack-skills for lateral movement after elevation, AV or EDR evasion when tooling is blocked, and Active Directory Kerberos or ACL abuse when the machine is domain-joined. Solo builders cataloging security tooling use it to understand what hardened Ship checks must defeat; professional testers invoke it during lab or client engagements with written permission. It is advanced, shell-centric, and intentionally not a substitute for patch management or compliance automation—rather a procedural map of how real attackers chain local weaknesses on Windows endpoi1kinstalls84Prototype Pollution Advancedprototype-pollution-advanced is a security reference skill for agents and builders who have already confirmed prototype pollution and need the right gadget for the target framework or library. It organizes known polluted properties, example payloads, trigger conditions (such as res.render or template compile paths), impact class, and affected versions across high-risk ecosystems like Express template engines. The skill is not a scanner; it is a lookup table meant to accelerate responsible validation, patch verification, and write-ups during secure ship workflows. Solo builders maintaining Node APIs or SaaS backends can use it to understand how a __proto__ merge can escalate to RCE when dangerous opts merge behavior exists, then prioritize upgrades and input sanitization. Treat it as advanced appsec material aligned with penetration testing and code review, not everyday feature work.1kinstalls85Tunneling And PivotingTunneling and Pivoting is an advanced security agent skill from the hack-skills collection that documents how to extend access through compromised hosts using tunnels most general models mishandle—especially egress-filtered paths and transparent routing. It is aimed at authorized penetration testers, security-minded solo builders hardening their own staging environments, and red-team practitioners chaining SSH forwards, Chisel SOCKS, Ligolo-ng TUN interfaces, socat relays, and application-layer DNS or HTTP tunnels. The playbook stresses tool selection based on egress rules, multi-hop pivot design, and coordination with related skills for shells, privilege escalation, and service exploitation on newly reachable segments. Prism lists it so builders running legal assessments can load consistent procedural knowledge into Claude Code or similar agents. It is not a shortcut for unauthorized network access; scope must match written permission and your jurisdiction.1kinstalls86Smart Contract VulnerabilitiesSmart Contract Vulnerabilities is an agent skill that loads an expert Solidity/EVM attack playbook when you need to audit contracts for classes base models often miss—especially cross-contract reentrancy and proxy storage layout collisions. It is built for solo and indie builders shipping DeFi, NFT, or token logic who want repeatable review language instead of ad-hoc “is this safe?” chat. Invoke it when reviewing pull payments, external calls before state updates, upgradeable proxies, or signature-based permissions. The skill sequences practical checks across reentrancy, overflow, access control, delegatecall, oracle/randomness abuse, flash-loan composability, replay, and MEV exposure, and points you to deeper pattern files when you need fixed-code comparisons. Pair it with protocol-specific DeFi attack routing when the bug is economic, not just a single-function flaw.1kinstalls87Network Protocol AttacksNetwork Protocol Attacks is an expert offensive-security agent skill from the Yaklang hack-skills family. It gives solo builders and small security teams a structured playbook for exploiting layer 2 and layer 3 protocols during authorized assessments: ARP spoofing, name-resolution poisoning, WPAD and DHCPv6 abuse, VLAN hopping, STP manipulation, DNS spoofing, IPv6 attacks, and IDS/IPS evasion. The documentation stresses chaining—establishing a man-in-the-middle position, then routing into tunneling, NTLM relay coercion, unauthorized-access on discovered services, and PCAP analysis—because modern switched networks rarely yield value from a single technique in isolation. Load it when you are scoping or executing internal network tests in Claude Code, Cursor, or Codex and need agent-ready procedural knowledge instead of generic “use Wireshark” chat advice. It is advanced material meant for environments you own or have written permission to test.1kinstalls88Defi Attack PatternsDeFi Attack Patterns is an expert agent skill for solo builders and auditors shipping decentralized finance products. It compresses flash loan mechanics, price oracle manipulation, MEV strategies, governance and bridge weaknesses, and token-standard pitfalls into a single attack-oriented playbook tuned for agent sessions. The SKILL.md explicitly calls out where base models fail—treating flash loans as multi-step collateralized loans instead of single-transaction atomicity, and blurring spot-price manipulation with TWAP defenses. Use it when you are in Validate or Build proving economic safety of a protocol design, or in Ship running a structured security pass before mainnet. It pairs upstream with smart-contract-vulnerabilities for reentrancy and delegatecall patterns and downstream thinking about off-chain bridge relayers via deserialization-insecure when indexer infrastructure is in scope. The tone is adversarial research for builders who need to think like attackers without scattering chat prompts across exploit categories.1kinstalls89Linux Security BypassLinux-security-bypass is an advanced agent skill that encodes an expert playbook for circumventing common Linux hardening layers during authorized security work. It targets builders and testers who already operate in red-team, CTF, or defensive research contexts—not casual app shipping—and need reliable sequences when rbash, read-only or noexec mounts, AppArmor, SELinux, seccomp, or aggressive auditing block progress. The skill emphasizes gaps typical LLMs skip, including fileless execution paths and architecture-confusion seccomp bypass, and points to sibling playbooks for privilege escalation, container escape, lateral movement, and command injection when the scenario shifts. Use it to structure lab reproductions, write test cases for your own images, or train an agent during sanctioned assessments. It is not a license to attack systems you do not own; Prism tags it so defenders and indie operators running private labs can find deep Linux security material alongside shipping-time security skills.1kinstalls90Steganography TechniquesSteganography Techniques is an advanced multi-phase agent skill that walks solo builders and security hobbyists through expert hidden-data analysis on images, audio, composite files, and text. Instead of guessing one tool, it enforces a file-type-first playbook: LSB and chunk tricks on PNG, DCT and metadata on JPEG, spectrograms on audio, polyglots and appended blobs on binaries, plus whitespace and homoglyph text channels. It cross-links PCAP extraction, memory dumps, and classical cipher follow-ups when recovered material is still encoded. Use during Ship security reviews of user uploads, malware samples, or challenge files; during Operate when investigating suspicious attachments. Load STEGO_TOOLS_GUIDE when you need install commands and detailed CLI workflows. Not a replacement for enterprise forensics suites—it's procedural depth for agents and indies who need repeatable extraction steps.1kinstalls91Nosql InjectionNoSQL Injection is an advanced agent skill for solo builders and small teams shipping APIs that use MongoDB, Redis, CouchDB, or JSON-native query layers. It teaches how NoSQL injection differs from classic SQLi: attackers inject query operators that flip boolean logic instead of breaking string literals. The playbook walks through authentication bypass examples, operator families, blind extraction paths, and database-specific pitfalls so you can test login, search, and admin endpoints before launch. Invoke it when backends accept JSON query objects, flexible filters, or document-store operators—situations where copying SQLi payloads wastes time and misses real flaws. It is not a substitute for secure schema design or WAF tuning; it gives reproducible offensive patterns for Ship-phase security review of your own staging or bug-bounty scope.1kinstalls92Windows Lateral MovementWindows Lateral Movement is an advanced security reference skill from the Yaklang hack-skills collection that supplements broader lateral-movement guidance with credential-dumping detail. It is aimed at practitioners who already operate under written authorization on Windows estates and need structured comparisons of LSASS memory capture paths—built-in comsvcs MiniDump, Microsoft-signed ProcDump, Mimikatz-class tooling, lighter variants, and remote Impacket-style collection. The readme frames AI load instructions for LSASS dumps, SAM/SYSTEM extraction, DPAPI secrets, cached domain credentials, and NTDS.dit work, assuming the parent SKILL.md is loaded for movement techniques. Solo indie builders shipping a SaaS or mobile app should not treat this as a daily Ship-phase checklist; it is specialized offensive tradecraft for red-team, pentest, or internal purple-team exercises. Use it to reason about detection risk and method choice during authorized assessments, then fold findings into hardening tickets rather than production feature work.1kinstalls93Lattice Crypto AttacksLattice-crypto-attacks is an agent skill that packages lattice-based cryptanalysis playbooks for CTF players and security researchers attacking RSA, DSA/ECDSA, and knapsack constructions. Solo builders rarely need it unless they ship custom crypto or compete in capture-the-flag events; when they do, the skill steers the agent through LLL and BKZ reduction, Coppersmith’s method for small roots (including multivariate and Boneh-Durfee bounds), Hidden Number Problem formulations for biased nonces, and knapsack low-density attacks. It emphasizes correct lattice dimension and scaling—common failure modes for generic models—and points to sibling RSA and symmetric cipher attack skills when the problem type fits those routes. Use only on puzzles, CTF flags, or systems you own or are explicitly authorized to test; it is not a substitute for professional crypto design or compliance review.1kinstalls94Rsa Attack TechniquesRSA Attack Techniques is a deep appendix skill in the Yaklang hack-skills line that agents load when standard RSA attack selection from SKILL.md is not enough and you need full mathematics, SageMath or Python implementations, and edge-case handling. Solo builders and security hobbyists use it in authorized CTF contexts or when reviewing whether their toy crypto challenges leak factors through smooth p±1 structures, small primes, or predictable randomness. The readme positions it explicitly after the main SKILL.md decision tree so the agent does not shotgun attacks blindly—it implements Pollard's rho with gcd loops, Williams' p+1 for when p+1 is smooth, trial division baselines, and additional catalog sections that continue beyond the excerpted factorization chapter. Complexity is advanced: you should be comfortable with modular arithmetic and willing to run computer algebra tooling. It does not replace legal key management guidance for production SaaS; it accelerates exploit development and education where breaking RSA is the goal. Prism lists it under Ship security research for agents helping you script attacks or understand failure modes before you harden real systems with proper1kinstalls95Sandbox Escape TechniquesSandbox Escape Techniques is an advanced agent skill from the Yaklang hack-skills collection that teaches structured Python pyjail breakout methodology for solo builders and security-minded developers who encounter restricted interpreters in CTFs, bug bounties, or internal red-team labs. It is meant to load after the main sandbox identification SKILL.md so the agent picks the right jail profile before diving into subclass walking, builtins recovery, and indirect syscall paths. The document walks through tuple/object subclass enumeration, finding useful loaded classes like os._wrap_close, and reaching command execution through __init__.__globals__. It also documents AST manipulation, RestrictedPython circumvention, pickle and code-object tricks, and file exfiltration when open() is banned. This is procedural offensive-security knowledge—not a ship-to-production integration—so it belongs on the security shelf for agents helping you reason through exploit chains, write challenge solutions, or review whether your own sandbox is robust. Intermediate Python fluency and explicit authorization for the target environment are assumed throughout.1kinstalls96Symmetric Cipher Attackssymmetric-cipher-attacks is a YakLang hack-skills deep-dive module for exploiting misimplemented symmetric encryption—starting with a complete padding-oracle treatment for CBC and PKCS#7. It is written for security practitioners who already chose an attack path from the parent SKILL.md and now need byte-level procedures, valid/invalid padding examples, and oracle query mechanics. Solo builders should only use it in authorized contexts: verifying their own API’s crypto before ship, lab CTFs, or client engagements with written permission. The content is advanced and offensive; it does not replace secure library choices or TLS configuration. Prism lists it so agents do not hallucinate exploit steps during legitimate ship-phase security reviews, while keeping the canonical shelf under security rather than general backend build tasks.1kinstalls97Unauthorized Access Common Servicesunauthorized-access-common-services (port-service-matrix reference) is a dense offensive-security cheat sheet for service enumeration organized by listening port. It supplements the parent unauthorized-access skill with bash-ready patterns for anonymous FTP, SSH brute force and key reuse, SMTP open-relay and user enumeration, and similar techniques across many classic ports. On Prism it is tagged for builders who run authorized assessments on their own staging stacks or apps they own—not as guidance for attacking third parties. The value is speeding triage after nmap finds open services: what to try next, which scripts apply, and how misconfigurations chain. Treat outputs as inputs to remediation tickets during ship-phase security work, then re-test after fixes.1kinstalls98Ntlm Relay CoercionNtlm-relay-coercion is a specialized security skill fragment for agents assisting on authorized Windows Active Directory assessments. It loads after core NTLM relay fundamentals and supplies a coercion-methods matrix that maps each technique to RPC interfaces, callable functions, SMB transport, machine-account behavior, and whether domain credentials are required. Practitioners use it to choose between PetitPotam-style EFS abuse, spooler PrinterBug paths, DFS and shadow-copy coercion, and event-log oriented variants without guessing incompatible preconditions. The content is explicitly offensive-security vocabulary and command-oriented examples suited to red-team or internal pen-test scopes—not routine SaaS shipping. Solo builders should only invoke it inside legal, in-scope engagements with written authorization.1kinstalls99Macos Security BypassmacOS Security Bypass is an advanced agent skill that loads expert attack techniques for Apple’s layered protections during legally authorized assessments. It walks through Transparency Consent and Control bypasses, Gatekeeper evasion, System Integrity Protection constraints, sandbox boundaries, code signing quirks, and entitlement-based access, with pointers to deeper injection and shared Unix bypass material when initial access already exists. Solo builders rarely need this unless they are security consultants, macOS tool authors, or indie teams running formal pentests on their own apps. The playbook stresses version-specific TCC nuances and interaction effects that generic models often flatten. Use only with written authorization, clear scope, and responsible disclosure paths; it complements defensive hardening rather than replacing secure-by-design engineering.1kinstalls100Macos Process Injectionmacos-process-injection is a deep-dive agent skill from the Yaklang hack-skills family that loads when you already understand the main injection overview and need executable methodology for macOS. It teaches automated and manual discovery of hijackable weak dylibs, rpath ordering that determines which writable directory wins, and tooling patterns built around otool and DYLD environment variables. The audience is security researchers, macOS appsec engineers, and authorized penetration testers—not casual indie app shippers—who need reproducible checklists instead of ad-hoc forum snippets. Use it during security reviews of native macOS binaries, CI hardening, or malware analysis labs where Mach ports and XPC exploitation context matters. Complexity is advanced because mistakes cause false positives or unsafe testing on production machines. Pair with organizational policy, code signing review, and sandbox entitlement analysis; do not treat this as a shortcut to ship consumer features faster.1kinstalls101Reverse Shell TechniquesReverse Shell Techniques is an agent skill packaged as a cheatsheet for authorized security work: it catalogs listener setup commands and language-specific one-liner reverse-shell payloads you can adapt by swapping ATTACKER and PORT. Solo builders and small teams rarely need offensive payloads day to day, but the skill helps when you are deliberately testing your own APIs, servers, or containers in a lab, walking through CTF-style exercises, or documenting what an attacker might try after command injection or upload flaws. It complements defensive shipping work by making common connection patterns explicit so you can block egress, harden interpreters, and verify monitoring. Treat every payload as illegal outside scopes you own or have written permission to test; the skill is reference material, not an autonomous exploit chain. Use it alongside your engagement checklist, capture outputs in your report, and map findings back to concrete fixes in ship and operate.1kinstalls102Ghost Bits Cast AttackGhost Bits Cast Attack is a companion agent skill to the main Yaklang hack-skills SKILL.md, aimed at security-minded solo builders and small teams who need depth beyond a conceptual primer. Load it when you require the full low-byte-to-Unicode table, patched-version matrices, copy-paste Python or Yaklang generators, or WAF normalization logic for multi-view decoding. The cookbook explains how attacker-controlled bytes map into legal UTF-8 scalar values that survive HTTP, JSON, and SMTP transports yet narrow differently inside vulnerable components—a class of issues relevant when you ship APIs behind WAFs or custom filters. It explicitly tells the agent not to load this file for overview-only questions; the parent skill covers concepts. During Ship, use it to red-team your own rulesets and to document detection gaps, not to blindly paste payloads into third-party systems. Expect advanced material: tabular byte mappings, control-character attack uses, and defensive pseudocode meant to pair with your security review workflow.790installs