Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
verified-pentest — Self-service pentest platform that only scans domains whose ownership is proven, and re-checks that proof at scan time. OWASP, TLS, DNS and port checks + a capped, read-only AI pass. | Kitploit
Tools/GitLabGitLab/kavin-jain/verified-pentest
Vulnerability ScannersWeb Vulnerability ScannersPort ScanningConfiguration AuditingSecurity VirtualizationWeb SecurityPenetration TestingSecret Detection
Subdomain Enumeration
DNS Analysis
AI Security
GitLabkavin-jain/verified-pentest

verified-pentest

Self-service pentest platform that only scans domains whose ownership is proven, and re-checks that proof at scan time. OWASP, TLS, DNS and port checks + a capped, read-only AI pass.

View Repository
6 days agoNot yet reviewed
Share

verified-pentest

A free, open-source, verified-domain penetration testing platform. You enter a website, prove you own it, and it runs a real security assessment — OWASP web vulnerabilities, dependency/secret scanning, network/infra exposure, TLS/SSL audit, and (via a bundled Claude Code skill) an AI analysis pass that cross-correlates the results into attack chains a fixed rule engine would miss.

Why this exists, and the one rule that never changes

Automated scanning of a website you don't own or control is illegal regardless of intent, even with good motives. So the entire system is built around one non-negotiable gate: no scan ever runs against a domain that hasn't cryptographically proven ownership, re-checked at scan time, not just at signup. Every other safety mechanism below exists to keep this tool from being repurposed into something it isn't.

  • Domain ownership verification (src/verification/) — DNS TXT record or a /.well-known/verified-pentest.txt file / meta tag. Re-verified immediately before every scan, not just once at signup, so a domain that changed hands or removed the token can't be scanned on stale trust.
  • Consent + audit trail — every scan requires an explicit consent statement, logged with the requester's IP.
  • Per-domain cooldown and global scan concurrency caps (src/config/safety.ts) — this tool can never become a DoS source.
  • SSRF guard (src/utils/ssrfGuard.ts) — every outbound request refuses to target private/loopback/link-local/cloud-metadata IP ranges.
  • No credential brute-forcing, no destructive requests, ever — not in the deterministic checks, not in the AI analysis layer (see below).

None of this is a checkbox for its own sake — see the check-by-check rationale inline in the source, especially src/config/safety.ts and .claude/skills/deep-pentest/SKILL.md.

What it actually checks

Zero-install (pure Node, no external binaries):

CheckWhat it finds
headersMissing CSP/HSTS/X-Frame-Options/etc., server version disclosure
tlsCert expiry/trust, deprecated TLS1.0/1.1 support
dns-configMissing/weak SPF, missing/monitor-only DMARC
cookie-flagsMissing Secure/HttpOnly/SameSite on cookies
csrfPOST forms without an apparent CSRF token (heuristic)
client-js-libsVulnerable client-side JS library versions
secret-scanExposed API keys/secrets in client-served code
port-scanOpen ports (nmap if installed, built-in TCP-connect fallback otherwise)

Tool-backed (auto-detected; each check reports skipped with an install hint if the tool isn't present — nothing fails silently):

CheckToolWhat it adds
zap-scanOWASP ZAPActive web vulnerability scanning (DoS-category rules hard-disabled)
nuclei-scannucleiThousands of community CVE/misconfiguration templates
httpx-fingerprinthttpxTech/stack fingerprinting
subfinder-reconsubfinderPassive subdomain discovery (reported, never auto-scanned)
testssl-scantestssl.shDeep TLS/SSL audit (Heartbleed, POODLE, ROBOT, cipher/protocol coverage)
repo-dependency-scangitleaks, osv-scanner, semgrep, trivyLeaked secrets, vulnerable dependencies, code-level vuln classes, IaC misconfig (only when a repoUrl is supplied)

Quickstart

npm install
cp .env.example .env          # fill in BOOTSTRAP_ADMIN_TOKEN at minimum
npx prisma migrate dev
npm run dev                   # http://localhost:3000

Optional — installs the tool-backed checks above (no sudo required; nuclei/ httpx/subfinder/trivy/gitleaks/osv-scanner as prebuilt binaries, ZAP + a portable JDK 17, testssl.sh via git clone, semgrep via pipx):

scripts/setup-tools.sh

Basic flow

# 1. Get an API key (gated by BOOTSTRAP_ADMIN_TOKEN in .env — this is a
#    self-service security tool, not an open-signup product yet)
curl -X POST localhost:3000/auth/signup \
  -H 'content-type: application/json' \
  -d '{"email":"[email protected]","bootstrapToken":"<from .env>"}'

# 2. Register a domain -- returns DNS TXT / file / meta-tag instructions
curl -X POST localhost:3000/domains \
  -H "authorization: Bearer $API_KEY" -H 'content-type: application/json' \
  -d '{"hostname":"yoursite.com"}'

# 3. Add the DNS TXT record (or well-known file / meta tag) to your site,
#    then verify:
curl -X POST localhost:3000/domains/$DOMAIN_ID/verify \
  -H "authorization: Bearer $API_KEY"

# 4. Scan
curl -X POST localhost:3000/domains/$DOMAIN_ID/scans \
  -H "authorization: Bearer $API_KEY" -H 'content-type: application/json' \
  -d '{"checkTypes":["headers","tls","dns-config"],"consentStatement":"I own this site"}'

# 5. Poll, then get the report
curl localhost:3000/scans/$SCAN_ID -H "authorization: Bearer $API_KEY"
curl "localhost:3000/scans/$SCAN_ID/report?format=markdown" -H "authorization: Bearer $API_KEY"

Reports render as json (default), markdown, or html. Every report includes a Check Execution Summary table so "this category found nothing" is never ambiguous with "this check errored or was skipped."

AI analysis (the deep-pentest Claude Code skill)

This repo bundles .claude/skills/deep-pentest/SKILL.md. Open this project in Claude Code and ask for a deep/AI-assisted pentest on a domain you've already registered and verified through the API above. The skill:

  1. Runs the full deterministic check set through this same API.
  2. Reads back the raw findings and reasons across categories for chains a fixed rule/template engine can't see (e.g. correlating a fingerprinted tech stack with a header misconfig and an open port into a single attack path).
  3. For hypotheses worth confirming, issues a small, capped number of safe, read-only verification requests (max 3 per finding, GET/HEAD only, never more than one extra record to prove a data-exposure issue, hard cap of 30 total per scan) and captures real evidence — not "this could happen."
  4. Posts its analysis back via POST /scans/:id/ai-findings, where it merges into the same report, clearly badged as AI-CONFIRMED (with evidence) or AI-HYPOTHESIZED (unconfirmed).

The skill file itself carries the hard rules (ownership-verified only, capped/read-only verification, explicit bans on brute-forcing/DDoS/data modification) so they hold regardless of what's asked of it in conversation — read it before assuming what the AI layer will or won't do.

Architecture notes

  • Stack: Node 22 + TypeScript, Express, Prisma + SQLite (swap to Postgres for production — see the datasource comment in prisma/schema.prisma for what that actually involves), Vitest.
  • Orchestrator (src/scanner/orchestrator.ts): p-queue-based, concurrency-capped, auto-detects the working scheme (http vs https) per target rather than assuming HTTPS.
  • Check modules (src/scanner/checks/): all implement the same CheckModule interface (src/scanner/types.ts) — tool-presence-checked, skip cleanly if the binary isn't installed, never throw for "found nothing," only for genuine execution errors.
  • IPv4-forced networking (src/utils/networkSetup.ts): in sandboxed/ containerized environments without real IPv6 routing, Node's fetch can burn 5+ seconds per request on a doomed dual-stack attempt before falling back. This is forced off by default; revisit if you need to scan IPv6-only targets.

Development

npm test              # vitest
npx tsc --noEmit       # typecheck
npx prisma migrate dev # after schema changes

License

MIT — see LICENSE. This is a penetration-testing tool: having the code doesn't grant authorization to scan anything you don't own or have explicit permission to test, on top of what this tool's own verification already enforces.

Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    668
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    496
  • 3

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    394
  • 4

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    339
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    258
  • 6

    antifox

    antifox-ai/antifox

    AI multi-agent autonomous penetration testing platform that runs recon, attack-surface discovery, exploitation validation and evidence-backed report delivery.

    254

Explore all tools

Browse our collection of tools

View all tools →