Find your next open-source project

Search by name, purpose, or keyword — or paste a GitHub repository URL
All skills

azrielnan/artex-ko-main

Gives authorized security testers a large library of attack, recon and reporting skills for web, cloud, mobile and network targets.

  • 200 skills
  • 116 stars

The 5 most installed

  • Tries header, IP and path tricks to get past protected routes that return 401 or 403.

  • Checks whether an API exposes data or privileged actions without requiring login.

  • Collects the API endpoints a website exposes for later testing.

  • Runs an Android APK through download, decompilation, secret grepping, component listing and Frida instrumentation.

  • Maps an organization's IP ranges using ASN, CIDR, domain expansion and reverse DNS.

The other 195 skills
  • Looks up attack technique categories to classify a verified web or WordPress behavior.

  • Walks through a full bug bounty workflow from recon and hunting to chaining and reporting.

  • Guides you through the bug bounty phases and suggests what to do next.

  • Orchestrates an end-to-end bug bounty engagement including recon, hunting, chaining and report writing.

  • Helps write Bugcrowd reports with VRT categories, severity overrides and rebuttal templates.

  • Attempts CDN cache poisoning or deception when an X-Cache header is present.

  • Analyzes AWS, Azure and GCP credentials for privilege escalation and role-chaining paths.

  • Identifies the CMS, frameworks and server stack running on live hosts.

  • Runs consistent CORS checks across a list of authorized API endpoints.

  • Exploits WordPress CORS credential reflection to steal data across origins.

  • Combines two or more verified findings into a higher-impact attack path.

  • Compares two recon scans to flag new, regressed and persistent findings.

  • Performs deeper WordPress testing covering SSRF, plugin CVEs, JS mining and port chains.

  • Escapes Docker containers to host root using five documented techniques.

    Runs only when you type /docker-privesc

  • Checks SPF, DKIM and DMARC records, tests spoofing and reviews email security headers.

  • Fingerprints and tests SSL VPN and remote-access appliances against known CVEs.

  • Searches leaked error_log files for credentials, paths and SQL details.

  • Redacts cookies, personal data and HAR headers before submitting proof-of-concept evidence.

  • Tests Exchange and OWA servers for NTLM AD leaks and password spraying.

  • Probes leaked Firebase and Supabase configs to reach exposed data.

  • Exploits exposed Flask and Werkzeug debug consoles to leak tracebacks and secret keys.

  • Searches public GitHub repositories for leaked API keys, tokens and credentials.

  • Mines GitLab instances for secrets and CI tokens once a subdomain is found.

  • Provides ready-made Google search queries that surface exposed configs, secrets and credentials.

    Runs only when you type /google-dorks-catalog

  • Detects hardcoded passwords in HTML forms, JavaScript files and API responses.

  • Mimics a chosen browser's HTTP/2 fingerprint by spoofing settings frames and header order.

  • Simulates human-like mouse, keyboard and scroll behavior to get past bot detection.

  • Checks APIs for mass assignment, JWT flaws, prototype pollution and verb tampering.

  • Probes ASP.NET sites for ViewState deserialization, machineKey leaks and trace page exposure.

  • Tests nine account takeover paths, from password reset flaws to session and JWT abuse.

  • Hunts login and authentication bypasses across SAML, JWT and SSO implementations.

  • Finds function-level authorization gaps via verb drift, route shadowing and transport differences.

  • Checks for weak rate limiting on logins, OTPs, reset tokens and account enumeration.

  • Tests business logic flaws such as coupon stacking, negative quantities and price tampering.

  • Hunts web cache poisoning and cache deception issues, including header and path tricks.

  • Tests six ways CAPTCHA checks can be skipped, replayed or left unbound to the action.

  • Looks for CI/CD pipeline flaws in GitHub Actions, GitLab CI, Jenkins and Terraform state.

  • Checks whether pages can be framed and trick users into hidden clicks.

  • Finds public buckets, exposed services and leaked cloud credentials on AWS, GCP and Azure.

  • Tests CORS setups for credentialed cross-origin reads and origin-check bypasses.

  • Hunts cross-site request forgery, including SameSite, token and Origin-check bypasses.

  • Tests Java, PHP, Python, .NET and Ruby deserialization paths that can lead to remote code execution.

  • Fingerprints a target and loads the matching attack skills for the hunt orchestrator.

  • Hunts Django and DRF permission gaps, ORM injection and admin panel weaknesses.

  • Finds client-side DOM flaws like clobbering, postMessage hijacking and CSS exfiltration.

  • Feeds malformed input to endpoints to find error pages that leak stack traces, file paths or library versions.

  • Checks FastAPI apps for dependency injection gaps, Pydantic type coercion issues and exposed OpenAPI docs.

  • Tests file upload features for webshell execution, SVG/HTML script injection, XXE and path traversal bypasses.

  • Probes fintech GraphQL APIs for transfer abuse, balance IDOR, rounding tricks and double-spend via idempotency bypass.

  • Finds exposed Firebase keys and checks Firestore, Realtime Database and Storage for unauthenticated read or write.

  • Checks password reset flows for user enumeration, token leaks, token replay and missing rate limits.

  • Hunts GraphQL bugs such as IDOR via node IDs, mutation abuse, batching DoS and missing field-level authorization.

  • Checks gRPC services for enabled reflection, missing auth, plaintext transport and proto file leaks.

  • Tests Host header injection for password reset poisoning, cache poisoning and routing-based SSRF.

  • Finds places where input is rendered as raw HTML, enabling phishing forms and UI manipulation.

  • Tests for HTTP request smuggling by exploiting disagreements between front-end and back-end header parsing.

  • Hunts IDOR bugs where changing an object ID exposes other users' data.

  • Looks for leaked source code, backup files, source maps, config files and error messages.

  • Tests JWT signature flaws like alg:none and RS256-to-HS256 key confusion to forge tokens.

  • Checks Kubernetes and Docker setups for anonymous API access, kubelet exec, exposed etcd and container escapes.

  • Checks Laravel apps for debug mode leaks, exposed Telescope/Horizon panels, Ignition RCE and .env exposure.

  • Tests LDAP and XPath injection for login bypass, blind attribute extraction and directory enumeration.

  • Hunts file inclusion and path traversal bugs, including log poisoning and PHP filter-chain RCE.

  • Tests AI features for prompt injection, indirect injection, data exfiltration and agentic security flaws.

  • Tests whether extra fields in requests let you change roles or other protected values.

  • Checks Model Context Protocol integrations in AI tools for security weaknesses.

  • Finds public metrics, health and actuator endpoints that leak database, AI usage or operational details.

  • Tests seven ways to bypass two-factor auth, from skipped checks to OTP brute force and replay.

  • Covers assorted bug classes drawn from a large set of public bug bounty reports.

  • Checks NestJS apps for guard bypasses, missing decorators and microservice auth drift.

  • Checks Next.js sites for Server Actions abuse, middleware auth bypass, image SSRF and source map leaks.

  • Tests Node.js and Express apps for prototype pollution, command injection, template injection and path traversal.

  • Probes MongoDB, CouchDB and Redis backends for NoSQL injection and auth bypass.

  • Reads anonymous NTLM challenges on IIS, SharePoint and Exchange to reveal internal domain and host names.

  • Hunts OAuth flaws such as redirect_uri abuse and token theft, based on public bug bounty reports.

  • Finds open redirects and chains them into OAuth token theft or phishing flows.

  • Tests client- and server-side prototype pollution for XSS, auth bypass and remote code execution.

  • Hunts race conditions like coupon double-spend and MFA bypass using modern single-packet techniques.

  • Checks RAG vector stores for corpus poisoning, cross-tenant data leaks and embedding-layer weaknesses.

  • Hunts remote code execution paths, drawing on 67 public bug bounty reports.

  • Tests SAML single sign-on for signature wrapping, comment injection, signature stripping and replay.

  • Enumerates hidden tables, fields and endpoints from API error messages across REST, GraphQL and PostgREST.

  • Checks session handling for fixation, weak logout invalidation, predictable IDs and cookie flag gaps.

  • Finds undocumented and old API versions, then diffs them for auth and validation regressions.

  • Enumerates on-prem SharePoint farms for anonymous endpoints, version leaks and known exploit chains.

  • Finds leaked source maps, .env and .git files, Swagger specs and build artifacts that expose the app.

  • Extracts a single-page app's hidden backend API from its JS bundle and tests it for missing auth.

  • Checks Spring Boot apps for exposed Actuator endpoints, SpEL injection, heap dumps and known CVEs.

  • Hunts SQL and NoSQL injection, including ORM flaws, blind timing attacks and GraphQL resolvers.

  • Hunts server-side request forgery, including cloud metadata theft, DNS rebinding and gopher-to-Redis chains.

  • Detects server-side template injection across Jinja2, Twig, Freemarker and other engines, then escalates to code execution.

  • Finds subdomain takeovers on Azure, Zendesk, Vercel, Fastly and S3 with current provider fingerprints.

  • Tests Supabase apps for exposed anon keys, RLS bypass, open storage buckets and cross-tenant data access.

  • Checks TLS, DNS and email settings for missing HSTS, weak ciphers, zone transfers and spoofable DMARC.

  • Tests WebSocket endpoints for cross-site hijacking, weak origin checks and missing per-message auth.

  • Checks an authorized WordPress site's core, plugins, themes, REST API and XML-RPC for known weaknesses.

  • Finds write endpoints that accept PATCH, POST or DELETE without authorization while reads stay protected.

  • Hunts cross-site scripting flaws on a target using patterns drawn from public bug bounty reports.

  • Hunts XML external entity flaws, including blind out-of-band cases and chains to file read or code execution.

  • Walks through iOS app red-teaming: getting the IPA, static analysis, secret extraction, pinning bypass and runtime instrumentation.

  • Probes cameras over RTSP, ONVIF and vendor config interfaces when port 554 is open.

  • Scans JavaScript bundles and source maps for hardcoded keys, tokens and internal endpoints.

  • Decodes, forges and brute-forces JWTs when a Bearer token is in use.

  • Tests an authorized LLM app for prompt injection, system-prompt leaks, unsafe tool use and RAG boundary failures.

  • Runs a Microsoft 365 and Entra ID attack chain covering user enumeration, lockout math, conditional access and sign-in flows.

  • Audits meme coins and tokens for rug pulls, hidden minting, liquidity attacks and DEX integration risks.

  • Detects client patches, other attackers and security changes happening during a live engagement and turns them into findings.

  • Covers Active Directory attack steps from recon and credential abuse to privilege escalation, lateral movement and persistence.

  • Guides full red-team engagements from scoping and C2 infrastructure to OPSEC, evasion and reporting.

  • Provides an offensive checklist for assessing AI and LLM systems, including prompt injection and model extraction.

  • Explains anti-forensics techniques such as clearing logs, altering timestamps and hiding payloads on disk.

  • Covers advanced API abuse like business logic chaining, GraphQL batching and pagination-based data exfiltration.

  • Tests REST, gRPC and WebSocket APIs against the OWASP API Top 10 and related attack techniques.

  • Teaches foundational exploitation: controlling the instruction pointer, ROP chains, ret2libc and bypassing ASLR, NX and canaries.

  • Covers Bluetooth Low Energy attacks such as GATT enumeration, pairing downgrade, sniffing and key extraction.

  • Covers Bluetooth Classic attacks including service enumeration, legacy PIN cracking and profile abuse.

  • Finds bugs through code review patterns, taint analysis, dangerous function hunting and automated scanning.

  • Tests business logic flaws like workflow bypass, price manipulation, coupon stacking and race conditions.

  • Sets up and operates C2 frameworks such as Cobalt Strike, Sliver and Mythic for red-team engagements.

  • Exploits CI/CD pipelines across GitHub Actions, Jenkins and GitLab CI attack paths.

  • Extracts secrets from CI/CD pipelines, including environment variables, vault misconfigurations and runner tokens.

  • Guides attacking AWS, Azure and GCP: harvesting credentials, escalating privileges and establishing persistence.

  • Walks through breaking out of Docker, containerd and Podman containers via misconfigurations and known CVEs.

  • Triages crash dumps with WinDbg and GDB and judges whether a crash is exploitable.

  • Exploits weak cryptography such as padding oracles, ECB mode, hash length extension and RSA flaws.

  • Covers ways to move stolen data out through DNS, ICMP, cloud storage, email and steganography.

  • Performs Wi-Fi deauthentication attacks to capture handshakes, force reconnects or test PMF defenses.

  • Explains dependency confusion and namespace attacks across npm, PyPI and NuGet package ecosystems.

  • Lists techniques for evading antivirus and EDR, such as unhooking, direct syscalls and AMSI bypass.

  • Builds rogue Wi-Fi access points and captive portals to capture credentials from nearby clients.

  • Provides a structured exploit development course roadmap with weekly topics, labs and reading.

  • Guides writing and debugging reliable exploits with pwntools, pwndbg and heap exploitation techniques.

  • Gives a speed-focused checklist of quick-win vulnerabilities and fast recon shortcuts for short assessments.

  • Checks file upload endpoints for MIME, extension and magic-byte bypasses and related attacks.

  • Sets up and runs fuzzing campaigns with AFL++, libFuzzer and Boofuzz, then triages crashes.

  • Teaches fuzzing methodology: target selection, corpus building, coverage-guided fuzzing and crash triage.

  • Attacks GraphQL APIs through introspection abuse, authorization bypass, injection and batching tricks.

  • Tests for IDOR and privilege escalation by enumerating object IDs and chaining access flaws.

  • Lists initial access techniques such as phishing, credential stuffing and exposed service exploitation.

  • Tests IoT and embedded devices: hardware probing, firmware extraction, analysis and runtime attacks.

  • Tests JWT authentication for algorithm confusion, weak secrets, header injection and related flaws.

  • Attacks Kubernetes clusters from a pod foothold through RBAC abuse, etcd access and kubelet exploits.

  • Explains keylogger architecture, including keyboard hooks, ETW capture and stealth techniques.

  • Explains KRACK and FragAttacks against WPA2 clients and where they still work today.

  • Covers moving across a network with pass-the-hash, NTLM relay, remote execution and tunneling tools.

  • Guides replay and spoofing attacks on LoRaWAN and sub-GHz devices like remotes, TPMS and smart plugs.

  • Lists common binary protections like ASLR, DEP and canaries, and known ways to bypass them.

  • Walks through Android and iOS app penetration testing, from static analysis to Frida hooks and SSL pinning bypass.

  • Explains how to use NetExec for Active Directory enumeration, password spraying and credential dumping.

  • Covers internal network attacks such as ARP spoofing, LLMNR poisoning, VLAN hopping and MITM with common tools.

  • Provides a checklist for testing OAuth flows, including redirect_uri bypass, CSRF and token leakage.

  • Lists ways to find and exploit open redirects, including encoding tricks and chaining with OAuth or SSRF.

  • Gives concrete commands and wordlists for subdomain, cloud, identity and vendor reconnaissance.

  • Outlines a structured OSINT process from target definition through collection, correlation and reporting.

  • Explains HTTP parameter pollution, how frontend and backend parsing differ, and how to exploit it.

  • Describes Windows and Linux persistence techniques such as scheduled tasks, WMI subscriptions and golden tickets.

  • Covers running a phishing campaign end to end, from mail infrastructure and payloads to SPF/DKIM bypass.

  • Provides a checklist for finding and exploiting race conditions, including Turbo Intruder and double-spend attacks.

  • Guides writing penetration test reports with executive summaries, CVSS scoring and clean evidence handling.

  • Explains HTTP request smuggling variants, how to detect them, and how to bypass WAFs and poison caches.

  • Helps write custom x86/x64 shellcode and loaders while avoiding detection and null bytes.

  • Covers pretexting, vishing and smishing techniques for authorized red team and physical tests.

  • Guides SQL injection testing across databases and injection types, with WAF bypass and sqlmap automation.

  • Provides a checklist for finding SSRF, reaching cloud metadata, bypassing filters and escalating to RCE.

  • Explains server-side template injection across many template engines, including fingerprinting and escalation to RCE.

  • Describes software supply chain attacks such as dependency confusion, typosquatting and maintainer account takeover.

  • Covers auditing and exploiting TLS/SSL misconfigurations, including POODLE, DROWN, FREAK and BEAST.

  • Explains time-of-check to time-of-use races across binaries, kernels, filesystems, web apps and containers.

  • Teaches core vulnerability classes like buffer overflows, use-after-free and type confusion with real CVE cases.

  • Lists WAF bypass techniques such as encoding tricks, comment injection and payload obfuscation per vendor.

  • Guides Wi-Fi attacks such as handshake capture, evil twin and WPS cracking during authorized wireless tests.

  • Maps nearby Wi-Fi networks, including hidden SSIDs, channels and client probes, before an authorized wireless test.

  • Explains Windows security boundaries like sandboxes and COM/RPC to help plan privilege escalation paths.

  • Describes Windows exploit protections such as ASLR, CFG and CET along with known bypass techniques.

  • Walks through Windows privilege escalation from a normal user shell to SYSTEM using token and service flaws.

  • Guides attacks on enterprise Wi-Fi using 802.1X/EAP, including evil-twin RADIUS and credential cracking.

  • Guides WPA/WPA2-PSK cracking through handshake capture, PMKID attacks and GPU-based hash cracking.

  • Covers WPA3/SAE attacks such as downgrade, Dragonblood side channels and authentication flooding.

  • Guides WPS PIN attacks, including offline Pixie Dust and online brute force against routers.

  • Provides a cross-site scripting testing checklist covering stored, reflected, DOM and blind XSS.

  • Guides testing Z-Wave smart home devices, including sniffing, key flaws and replay attacks.

  • Guides testing Zigbee, Thread and Matter smart devices with sniffing, replay and commissioning attacks.

  • Walks through attacking Okta single sign-on, from user enumeration to MFA bypass and admin access.

  • Forces all traffic through Tor at the kernel level so testing tools cannot leak your real IP.

  • Finds a site's real origin IP behind a CDN or WAF using favicon hashes, DNS history and certificates.

  • Runs a structured OSINT pipeline to map an organization's external attack surface and exposures.

  • Runs a password spray playbook across M365, Okta, Exchange and AD while avoiding account lockouts.

  • Provides a seven-phase penetration testing pipeline from passive recon through exploitation.

    Runs only when you type /pentest-playbook

  • Chains an exposed phpinfo page into remote code execution when the server allows it.

  • Automates browser interactions and runs Playwright tests against web pages.

  • Scans large IP ranges for open ports using Masscan and RustScan, then grabs service banners.

  • Uses Nmap to identify services such as MySQL, Redis, FTP and internal APIs on open ports.

  • Analyzes binaries, packages and source trees in an isolated reverse-engineering mode.

  • Guides the information-gathering phase at the start of an authorized web and API assessment.

  • Separates a target's real assets from same-named companies' noise in automated recon output.