Zebbern Kali MCP
Provides unrestricted remote access to a Kali Linux penetration-testing toolkit via an MCP/API server, enabling reconnaissance, exploitation, post-exploitation, pivoting, and offensive security automation from AI agents.
Execute any shell command with root access on the Kali container, including background jobs, streaming output, and interactive session management.
Perform network reconnaissance and scanning: nmap, masscan, sslscan, subdomain/DNS enumeration, HTTP probing, web fingerprinting, and screenshots.
Test web applications: nikto, gobuster, wpscan, sqlmap, ffuf, nuclei, katana, parameter discovery, 403 bypasses, and more.
Attack Active Directory: BloodHound collection, secretsdump, Kerberoasting, AS-REP roasting, LDAP/SMB enumeration, password spraying, PsExec/WMI execution.
Run exploitation frameworks and payload workflows: Metasploit sessions, searchsploit, exploit suggestion, msfvenom payload generation, reverse shell listeners, and one-liner payloads.
Enable pivoting and tunneling: SSH sessions and port forwards, Chisel, Ligolo-ng, socat relays, SOCKS proxies, and VPN management.
Transfer files between the host, Kali container, and target machines via SSH or reverse shell sessions.
Audit API security: GraphQL introspection/fuzzing, JWT analysis/cracking, endpoint fuzzing, rate-limit testing, and auth-bypass checks.
Research vulnerabilities with NVD CVE search and OSV package audits, plus capture callbacks for isolated networks.
Provides GraphQL introspection and security analysis tools, including schema fingerprinting and introspection.
Provides direct access to a full Kali Linux penetration testing toolkit, including network scanning, web application scanning, exploitation, and many other tools.
Provides Metasploit Framework integration, allowing AI agents to manage modules, sessions, and exploits.
Provides OpenVPN management, including connection and configuration.
Provides integration with OWASP ZAP for automated web application security scanning.
Provides WireGuard VPN management, including setup and configuration for secure tunnels.
Provides WordPress vulnerability scanning via WPScan, identifying security issues in WordPress installations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Zebbern Kali MCP nmap scan 192.168.1.1"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Zebbern Kali MCP Server
Give an AI agent a full Kali Linux toolkit without installing one. The MCP client runs on your machine as a small Python package; every tool executes inside a Kali container that the client reaches over HTTP. Nmap, sqlmap, nuclei, impacket, Metasploit, pivoting, VPN and callback capture are all exposed as MCP tools.
Quick start · Essentials (jobs, files, VPN, targets) · Configuration · Troubleshooting · Tool modules · Image contents · Security · Development
Quick start
1. Start the Kali backend
docker run -d --name zebbern-kali --restart unless-stopped \
-p 127.0.0.1:5000:5000 \
--cap-add=NET_ADMIN --cap-add=NET_RAW --device=/dev/net/tun \
ghcr.io/zebbern/zebbern-kali-mcp:latestNET_ADMIN, NET_RAW and /dev/net/tun are what OpenVPN and WireGuard need;
without them vpn_connect fails whatever the config says. Add any of these flags
for full parity with the Compose file:
-p 127.0.0.1:1080:1080— published SOCKS proxy--sysctl net.ipv4.ip_forward=1— pivoting and routing--shm-size=1g— headless Chrome; without itgowitnesswrites no screenshot-v zebbern-kali-tmp:/app/tmp— keep background-job logs across recreates-v "$(pwd)/vpn:/vpn:ro"— VPN configs from the host
From a source checkout, Compose does all of the above:
git clone https://github.com/zebbern/zebbern-kali-mcp.git
cd zebbern-kali-mcp
docker compose up -d # add --build to build the image locally2. Point your MCP client at it
{
"servers": {
"kali-tools": {
"command": "uvx",
"args": ["zebbern-kali-mcp"]
}
}
}uvx downloads the client from PyPI on first run; nothing to install by hand.
VS Code reads .vscode/mcp.json (or your global MCP config) with the servers
key above, Claude Desktop and ~/.claude.json use mcpServers with the same
object, and CLI flags go in args, e.g. ["zebbern-kali-mcp", "--profile", "web"].
Pin the version — ["zebbern-kali-mcp@<version>"] — to make upgrades explicit.
Unpinned, uvx reuses whatever environment it already cached for that command, so
a restart does not necessarily pick up a newer wheel; see
Troubleshooting.
Restart the client. That is the whole install.
3. Ask
"Scan 10.10.10.5 with nmap" · "Run nuclei against example.com" · "Connect to the HTB VPN and start recon" · "Enumerate AD with bloodhound against dc01.corp.local" · "Start a callback listener on port 8080"
Call health to confirm the client reached the backend.
Related MCP server: Hercules MCP
Essentials
Four things that are not obvious from the tool list.
Long-running tools hand back a job_id
An MCP host abandons a synchronous tool call after roughly a minute, so anything
slower runs as a background job on the backend. Seventeen tools do that for you:
the fourteen heavy scanners (tools_nmap,
tools_nikto, tools_gobuster, tools_wpscan, tools_sqlmap, tools_hydra,
tools_masscan, tools_katana, tools_amass, tools_arjun, tools_fierce,
tools_enum4linux, tools_gowitness, tools_john) plus api_nuclei_scan,
api_ffuf_fuzz and zebbern_exec. The job starts first, the client waits inline
for ZKM_INLINE_WAIT_SECONDS (default 50), and you get back either the finished
result or a job_id. A wait that is too short costs a poll, never the scan. Any
other subprocess-backed tool takes background=true explicitly.
Call | Purpose |
| state, exit code, timing |
| output so far (long-polls briefly) |
| write to the process's stdin |
| kill the job's process group |
| every job the backend still tracks, newest first — use it when the |
Output is never capped. The response window is bounded, but every byte of stdout
and stderr is also teed to $JOB_OUTPUT_DIR/<job_id>.log (/app/tmp/jobs in the
image), so output_truncated does not mean lost output. output_logged: false
does: the log directory was not writable and only the bounded window exists.
Those logs are never rotated or pruned — clean up with rm /app/tmp/jobs/*.log
or by recreating the container.
Check timed_out, not success, to know whether a command finished: a truncated
scan reports success: true and timed_out: true on purpose, because its
partial output is worth keeping.
exec_stream streams output but registers no job, so it cannot be cancelled — on
disconnect the subprocess runs to its full timeout, untracked. Use
zebbern_exec(background=true) for anything you may need to abort. Job state,
listeners and sessions live in memory, so a backend restart drops them and the
*_status tools then answer empty rather than erroring.
Getting files in and out
kali_upload(content, remote_path) writes a file into the container — a config,
wordlist, script or target list, anything whose quoting or newlines a shell
command line would mangle. content is always base64, so base64-encode the
UTF-8 bytes of plain text first; kali_download(remote_path) reads a file back
out as base64.
target_upload_file / target_download_file move files to and from a remote
target instead, and ssh_session_* / reverse_shell_* transfer over an existing
session.
VPN configs
Put .conf (WireGuard) or .ovpn (OpenVPN) files in the host directory mounted
read-only at /vpn (VPN_DIR, default ./vpn), then call
vpn_connect(config_path="/vpn/client.ovpn"). The type is auto-detected from the
file contents; override with vpn_type="wireguard" or vpn_type="openvpn".
No mount is required: the entrypoint creates /vpn on every boot, so
docker cp client.ovpn zebbern-kali:/vpn/client.ovpn works on a container
started without one.
Reaching your targets
Inside the container 127.0.0.1 is the container's own loopback — scanning it
finds an empty container, which looks exactly like a broken MCP server. The host,
and anything published on it, is host.docker.internal. Services on another
Compose network that are not host-published need the Kali container attached to
that network.
Configuration
Environment variables
Variable | Default | Description |
|
| MCP client: URL of the Kali Flask server |
|
|
|
| (empty) | Modules to drop from the selected profile, e.g. |
|
| How long an auto-promoting tool waits inline before returning a |
|
| Flask server port |
|
| Host address for the Compose API port publication |
|
| API listener inside bridge mode; host-network mode defaults to |
| — | Optional shared API token; enforced on |
|
| Enable debug logging |
| — | Comma-separated binaries that must exist for |
| — | Comma-separated CIDRs to route, e.g. |
| — | Comma-separated |
|
| Host directory mounted read-only at |
|
| Host address for the Compose SOCKS port publication |
|
| Published host SOCKS port |
|
| SOCKS listener inside bridge mode; host-network mode defaults to |
|
| Where full job logs are teed; falls back to the OS temp dir from source |
|
| Maximum retained background jobs |
|
| Bounds on the retained response window per job: output events, characters, characters per event |
|
| Maximum input bytes per job request, and queued input requests per job |
|
| Maximum long-poll wait for job output |
|
| Maximum CTF file download size; a call may request less |
|
| Build argument: |
|
| Build argument: |
Client flags mirror the first few: --server, --profile, --api-token,
--exclude-module, --timeout, --debug.
--timeout (default 90000, i.e. 25h) is the HTTP read timeout for a synchronous
call: a backstop for a wedged backend, not a scan budget. It must always outlive
the backend's own per-tool budget (the longest is 86400s, for hydra and john). Set
it lower and the client gives up before the backend can answer — the partial
output of a timed-out scan is destroyed and the scan keeps running server-side,
orphaned. The connect timeout stays 10s regardless.
Tool profiles
The default auto profile starts from the complete tool set and, given a valid
capability manifest (schema version 1), omits only the public tools the backend
reports as unavailable — so the backend owns that list instead of the client
keeping a parallel copy. On a lean image that is 7 of the 135 tools: the five
msf_session_* tools plus payload_generate and payload_templates.
Discovery fails open: unknown, malformed, older or unreachable capability data keeps the complete set, and a manifest that would hide more than half the surface is ignored as a likely backend regression. Core tools — command execution, file operations, host management, output parsing — are never omitted even if a manifest marks them unavailable. The failure directions are not symmetric: a tool that is present but broken fails once and the agent adapts, while a wrongly hidden tool is invisible for the life of the process, because discovery is a startup snapshot. Restart the client to refresh it.
Pick a narrower profile, with --profile web or MCP_TOOL_PROFILE=web, only when
a shorter list helps the agent choose tools more reliably:
Profile | Contents |
| Command execution, files, hosts, output parsing |
| Core plus scanners, fingerprinting, exploit suggestions |
| Core plus web/API testing and callback capture (67 tools) |
| Core plus AD, pivoting, SSH, shells, payloads, VPN |
| Core plus scanners, CTF platforms, payloads, shells, VPN, callbacks |
| All modules except |
| All 17 modules, 135 tools; operator override that ignores discovery |
An invalid profile name fails at startup. trim drops the two modules that
duplicate what most MCP hosts already provide: callback_catcher (9 tools,
overlapping hosted webhook/interactsh services) and output_parser (1 tool,
duplicating the agent's own stdout parsing). Prefer full when the host has no
webhook capability of its own, or when the engagement runs on an isolated network
with no egress — the built-in listener is the only one that works there.
--exclude-module / MCP_EXCLUDE_MODULES subtracts modules from whichever
profile is selected, so you can tune the surface without a new profile:
zebbern-kali-mcp --profile web --exclude-module callback_catcher # 58 tools
zebbern-kali-mcp --profile full --exclude-module callback_catcher,output_parser # 125, same as trimNames are case-insensitive and whitespace-tolerant; an unknown name fails at
startup listing every valid one. Exclusion composes with auto, applying after
capability discovery.
Compose, image variants and networking
docker compose up -d # bridge networking, port-mapped
docker compose -f docker-compose.yml -f docker-compose.host.yml up -d # host networking
INCLUDE_METASPLOIT=false docker compose build # lean variant
INCLUDE_CADO_NFS=false docker compose build # faster dev build, CADO-NFS only removedBuild defaults are INCLUDE_METASPLOIT=true and INCLUDE_CADO_NFS=true; both
qualified variants (full and lean) include CADO-NFS. With INCLUDE_CADO_NFS=true,
a failure to fetch, build or verify the CADO-NFS executable stops the image build.
Compose grants NET_RAW and NET_ADMIN, provides /dev/net/tun, and publishes
the API and SOCKS ports on loopback; in host-network mode both services listen on
loopback. Set the matching bind or listen variable when another host must connect.
Host networking is qualified on native Linux Docker Engine, which keeps direct host-network semantics, and on the current Windows Docker Desktop 4.84 setup. Docker Desktop needs version 4.34 or later, host networking enabled in Settings > Resources > Network, and a restart before the overlay works; there it supports TCP and UDP only (layer 4), does not work with Enhanced Container Isolation, supports Linux containers only, and cannot bind a specific host-interface IP.
The Kali base image, Go modules, Git sources and standalone downloads are pinned.
Kali rolling APT packages and Python transitive dependency resolution are not
bit-identical snapshots. linux/amd64 is the only qualified architecture.
For a remote backend, set the same KALI_API_TOKEN in the backend and the client
environments, or pass --api-token; direct REST clients send it in the
X-API-Key header. Health endpoints stay unauthenticated so Docker and
orchestrator checks keep working.
Troubleshooting
"cannot reach the Kali API server" — the backend is not running or
KALI_API_URL points elsewhere. The error text includes the full docker run
line from Quick start.
A tool is missing, or a documented argument is ignored — suspect a stale
client before a bug. Call health: it returns the backend's version plus the
client's own client_version, version_match, and a version_note when they
disagree. An unpinned uvx zebbern-kali-mcp reuses whatever environment uv
already cached for that command, so restarting the MCP server can re-run an older
wheel, and --refresh updates the cache without necessarily changing what runs —
pin uvx zebbern-kali-mcp@<version> instead. If version_match stays false after
a correct pin, an older server process is probably still holding the connection,
because hosts start new servers without stopping the old ones. The version in the
argv is the version running:
Get-CimInstance Win32_Process | ? { $_.CommandLine -like '*zebbern*' } |
Select ProcessId, CreationDate, CommandLinevpn_connect fails whatever the config says — the container is missing
--cap-add=NET_ADMIN, --cap-add=NET_RAW or --device=/dev/net/tun.
A scan of 127.0.0.1 finds nothing — that is the container's loopback. Use
host.docker.internal.
A long scan or a listener disappeared — jobs, reverse-shell listeners, SSH
sessions and MSF sessions live in memory. A backend restart (including
docker compose up -d --force-recreate) drops them, and job_list() then
answers {"jobs": [], "count": 0}, which means "this backend has run nothing",
not "nothing is running". Pivot tunnels are the exception: they persist to
state.json and reload as status="stopped".
gowitness reports success but writes no screenshot — headless Chrome needs
more shared memory than Docker's 64MB default. Run with --shm-size=1g
(Compose already does).
The local image is stale — :latest moves on every backend change. Pull and
recreate, then compare the local digest against the remote one:
docker compose pull && docker compose up -d --force-recreate
docker buildx imagetools inspect ghcr.io/zebbern/zebbern-kali-mcp:latest
docker image inspect ghcr.io/zebbern/zebbern-kali-mcp:latest --format '{{index .RepoDigests 0}}'MCP tool modules
135 tools across 17 client modules in mcp_tools/, each backed by a Flask
blueprint in zebbern-kali/api/blueprints/ and core logic in zebbern-kali/core/.
Module | What it covers |
| Nmap, Nikto, Gobuster, Dirb, WPScan, SQLMap, Hydra, John, enum4linux, Subfinder, httpx, Arjun, Fierce, ssh-audit, gowitness, and more |
| Active Directory — netexec, BloodHound, impacket, certipy, bloodyAD, Kerberoasting, Pass-the-Hash, LDAP |
| Arbitrary command execution, streaming execution, background jobs, |
| SSH session lifecycle — connect, execute, transfer, disconnect |
| Reverse shell listeners, payloads and session management |
| Metasploit Framework — persistent console sessions, module execution |
| Chisel, Ligolo-ng, SSH tunnels, socat, ProxyChains, SOCKS proxy |
| WireGuard and OpenVPN with automatic SOCKS5 proxy |
| GraphQL introspection and fuzzing, JWT analysis and cracking, nuclei, ffuf, rate-limit and auth-bypass tests |
| Technology, header and WAF fingerprinting |
| searchsploit lookups and exploit suggestions from scan results |
| msfvenom payloads, one-liners, templates, payload hosting |
|
|
| Built-in HTTP + DNS callback listener for isolated networks |
| CTFd / rCTF API — challenges, flags, scoreboard, downloads |
|
|
| Structured parsing of tool output for AI consumption |
zebbern_exec and exec_stream accept any shell command, ssh, scp, rsync,
netcat and telnet included — the contract accepts them, it does not promise
every binary is bundled in every image variant. The dedicated SSH, pivot and
payload managers are conveniences, not restrictions. Nothing is masked in
command output or logs.
How it works
HOST (Windows/Linux/macOS) DOCKER (kalilinux/kali-rolling)
AI agent → MCP tool (mcp_tools/*) HTTP Flask API → api/blueprints/* → core/*
→ KaliToolsClient ──── POST /api/* :5000 ────→ nmap, sqlmap, msf, …
←──── JSON response ───────entrypoint.sh sets up routes, /etc/hosts, /vpn, TUN and IP forwarding before
the Flask server starts. The client stays a lightweight PyPI package
(uvx zebbern-kali-mcp), so the heavy tooling lives only in Docker and never on
your host.
What is in the image
Core tool failures stop the build. Tools marked optional fall back to a warning;
check /ready and the relevant tool-status endpoint for runtime availability.
Scanning — nmap (service/version detection, NSE), masscan, sslscan, ssh-audit, nikto, gobuster, dirb, wpscan, sqlmap, ffuf, nuclei, katana (v1.1.0 pre-built binary), amass, gowitness, arjun (parameter discovery), net-snmp clients (snmpwalk, snmpget, snmpbulkwalk — the only SNMP primitive here, and no wrapper covers it).
Subdomains, DNS and URLs — subfinder, httpx, assetfinder, waybackurls, waymore, amass, massdns, fierce, mapcidr, subzy (takeover checks).
Passwords — hydra, john, hashcat (GPU-accelerated).
Active Directory — netexec (primary SMB/LDAP/WinRM tool; crackmapexec is
deprecated), impacket 0.13.0 (pinned for stable behaviour across rebuilds; ~50
scripts symlinked as impacket-*), bloodhound.py, bloodyAD, certipy-ad (ADCS),
responder, evil-winrm, krbrelayx, gMSADumper, PetitPotam, coercer, dementor,
winrmexec, pywhisker, ldapdomaindump, man-spider 2.0.0 (manspider — crawls
share file content by keyword, regex or extension, where ad_smb_enum only
lists shares and tests access; it prints nothing to stdout, logging to
~/.manspider/logs/, so pass -l /app/tmp/manspider-loot to keep loot on the
kali-tmp volume rather than the container layer).
Exploitation — metasploit-framework, commix, ghauri, dalfox, byp4xx (403
bypass), git-dumper 1.0.9 (reconstructs a repository from an exposed .git
directory, which fingerprint_url only reports the existence of),
exploitdb/searchsploit.
JavaScript analysis — getJS, jsluice, xnLinkFinder, SecretFinder, TruffleHog, js-beautify, webcrack (npm), ParamSpider.
API testing and proxies — jwt_tool (/opt/jwt_tool/), graphw00f (GraphQL
engine fingerprinting), clairvoyance (schema introspection), mitmproxy
(mitmdump), OWASP ZAP (zaproxy), Caido CLI (optional; readiness key
caido-cli).
Forensics and CTF — binwalk, steghide, stegseek, zsteg, exiftool, foremost,
volatility3, sleuthkit (mmls, fls, icat, blkcat), gdb, radare2,
imagemagick, tesseract-ocr.
Binary, crypto and math (Python) — angr, pwntools, pycryptodome, gmpy2,
z3-solver, sympy, numpy, scipy, RsaCtfTool (/opt/RsaCtfTool/), cado-nfs
(/opt/cado-nfs/, factorization of large keys). SageMath is not bundled in the
current Kali rolling image.
Networking and pivoting — scapy, tcpdump, socat, netcat, proxychains4,
openvpn, wireguard-tools, chisel (Go binary plus a Windows .exe in
/opt/windows-tools/), ligolo-ng v0.7.5 (proxy plus Linux and Windows agents in
/opt/ligolo-ng/), cloudflared (optional; readiness key cloudflared), ngrok.
Privilege escalation — LinPEAS (/opt/privesc-tools/linpeas.sh), WinPEAS
(x64, x86, .bat, in /opt/privesc-tools/), Mimikatz
(/opt/windows-tools/mimikatz/), RunasCs.exe (/opt/windows-tools/).
Cloud, media and containers — awscli, boto3 (importable from the system
interpreter: zebbern_exec python3 -c 'import boto3'), ffmpeg, sox (all format
plugins), podman (needs --privileged at runtime), Playwright with Chromium for
SPA testing, screenshots and JS-rendered pages.
Wordlists — rockyou.txt (decompressed), SecLists, and compatibility symlinks
at /usr/share/wordlists/dirb/.
Python dependencies for the container are in requirements.txt; the Dockerfile
installs the rest via pip and APT. The image sets NO_COLOR=1, TERM=dumb,
FORCE_COLOR=0, CI=true and PWNLIB_NOTERM=1 so tools emit clean, parseable
text instead of banners, colours, progress bars and interactive prompts.
Callback catcher
A built-in HTTP + DNS listener for isolated networks where webhook.site or
interactsh cannot reach your targets, managed through the callback_catcher
module. Defaults are TCP 8888 and UDP 5353. A target can reach them directly
through a VPN interface inside the container or with Linux host networking. In
bridge mode, publish the callback ports on an address the target can reach (for
example 8888:8888/tcp and 5353:5353/udp) — they are not published by default.
Security
This server intentionally provides unrestricted command execution and powerful penetration-testing tools.
The default binds the API and SOCKS ports to 127.0.0.1. Remote use is
supported: choose an explicit bind address, set KALI_API_TOKEN, and put TLS or
a trusted private network in front when traffic crosses an untrusted one. The
container runs as root because several networking and assessment features
require it. Use this only on systems you are authorised to test.
Project layout
zebbern-kali-mcp/
├── mcp_server.py # MCP client entrypoint (FastMCP); ships in the wheel
├── mcp_tools/ # MCP CLIENT, runs on the host — _client.py is the HTTP
│ # transport, _autopromote.py the job promotion, then
│ # one module per tool category (17)
├── zebbern-kali/ # FLASK SERVER, runs in Docker — kali_server.py,
│ # api/routes.py, api/blueprints/ (one per module),
│ # core/ (command executor, job manager, tool logic)
├── Dockerfile # Multi-layer Kali image build
├── docker-compose.yml # Bridge-mode deployment (+ docker-compose.host.yml)
├── entrypoint.sh # Container init: routes, hosts, /vpn, TUN, forwarding
├── requirements.txt # Container Python dependencies
├── pyproject.toml # PyPI package config for the MCP client
├── tests/ # unit, live and integration suites
├── vpn/ # mount point for VPN configs
└── CLAUDE.md # maintainer and operational notesDevelopment
python -m pytest -q # 1506 passed, 6 skipped
python -m pytest -m live -q # 15 passed, 3 skipped; needs a backend on :5000
python scripts/mutation_check.py --spec tests/mutations.json # 103/103 guards verified red
python tests/integration/probe_tools.py # calls all 135 tools; needs a backendpytest -m live exercises real execution rather than a mocked client: background
job state across separate MCP processes, /etc/hosts round-trips, nmap and
fingerprinting against a lab target, verbatim command output. Each case opens its
own MCP stdio session, so any state surviving between calls is provably
server-side. It skips itself when no backend answers, which keeps CI green without
Docker — so a green pytest -q alone proves nothing about tool execution.
Override KALI_API_URL, ZKM_LAB_HOST and ZKM_LAB_PORT to point it elsewhere;
from inside the container the host lab is host.docker.internal.
probe_tools.py calls every tool once and diffs the outcome against
tests/integration/probe_baseline.json, so a run prints only what changed. It is
deliberately manual: real scanners, real listeners, and the public internet for a
handful of OSINT tools the baseline marks best-effort. A raw BROKEN count is not a
pass criterion — a tool truthfully reporting that no VPN is configured looks the
same as one that regressed, and only the baseline tells them apart. Re-record it
when a tool's expected outcome legitimately changes.
Live qualification fixtures
python tests/integration/run_smoke.py --image zebbern-kali-mcp:goal-full --network-mode bridge --expect-variant full
python tests/integration/run_smoke.py --image zebbern-kali-mcp:goal-full --network-mode host --expect-variant full
python tests/integration/run_ad_lab.py --image zebbern-kali-mcp:goal-leanAdd --check-trim to run_smoke.py to also assert the live trim profile
against the running image: it must expose 125 tools and omit exactly the nine
callback_* tools plus parse_tool_output, with nothing else added or lost. It
is opt-in because it costs one extra MCP session, and it is independent of the
image variant, since trim is static and ignores capability discovery.
The AD fixture is local, disposable and publishes no host ports. It proves local DNS, authenticated LDAP discovery and the public MCP/API enumeration path, and nothing else about Active Directory operations.
Updating pinned build inputs
Resolve an authoritative upstream version or commit.
Update one Docker argument and its checksum when present.
Run the Docker contract tests and
docker build --check ..Build full and lean with CADO-NFS enabled.
Run the image, bridge, AD, native-Linux host-network and Windows Docker Desktop host-network smoke fixtures.
Compare tool names, image IDs and sizes, and common layers before accepting.
Releasing
Two release tracks: the wheel ships mcp_server.py and mcp_tools/*, while
everything under zebbern-kali/ ships in the Docker image, so a backend change is
not delivered by a PyPI release. The version lives in pyproject.toml and
zebbern-kali/core/config.py and must be bumped in both (a test fails if only one
moves). CLAUDE.md has the full procedure.
Contributing
Pull requests welcome — include a clear summary of the change and any relevant test notes.
Built on the Model Context Protocol · Created by Zebbern
Available Tools
131 toolsad_asreproastA
Perform AS-REP Roasting to get hashes for accounts with pre-auth disabled.
Args: domain: AD domain dc_ip: Domain Controller IP username: Specific username to test userlist: Path to username list file on Kali
Inputs: domain (required), dc_ip, userlist, username. Returns: result
ad_bloodhound_collectB
Run BloodHound data collection against an Active Directory domain.
Args: domain: Target AD domain (e.g., corp.local) username: Domain username password: Domain password dc_ip: Domain Controller IP (auto-detected if empty) collection_method: Collection method (all, default, DCOnly, etc.) nameserver: Custom DNS nameserver
Inputs: domain (required), password (required), username (required), dc_ip, +2 more. Returns: result
ad_kerberoastC
Perform Kerberoasting attack to extract service ticket hashes.
Args: domain: AD domain username: Domain username password: Domain password dc_ip: Domain Controller IP target_user: Specific user to target (all SPNs if empty)
Inputs: domain (required), password (required), username (required), dc_ip, +1 more. Returns: result
ad_ldap_enumA
Enumerate Active Directory via LDAP.
Args: domain: AD domain username: Domain username password: Domain password dc_ip: Domain Controller IP or hostname query: Query type (users, groups, computers, spns, admins, all) use_starttls: Upgrade the LDAP connection to TLS tls_verify: Verify the StartTLS server certificate
Inputs: domain (required), password (required), username (required), dc_ip, +3 more. Returns: result
ad_password_sprayB
Perform password spraying attack against AD accounts.
Args: domain: AD domain password: Password to spray dc_ip: Domain Controller IP userlist: Path to username list file on Kali delay: Delay between attempts in seconds (default: 0)
Inputs: domain (required), password (required), dc_ip, delay, +1 more. Returns: result
ad_psexecC
Execute commands on a remote Windows host via PsExec (impacket).
Args: target: Target IP or hostname domain: AD domain username: Username password: Password hashes: NTLM hash for pass-the-hash command: Command to execute (default: cmd.exe)
Inputs: domain (required), target (required), username (required), hashes, +2 more. Returns: result
ad_secretsdumpB
Dump secrets (NTLM hashes, Kerberos keys) from a domain controller using secretsdump.py.
Args: domain: AD domain username: Domain admin username password: Domain admin password target: Specific target (default: DC) dc_ip: Domain Controller IP hashes: NTLM hash for pass-the-hash (LMHASH:NTHASH)
Inputs: domain (required), password (required), username (required), dc_ip, +2 more. Returns: result
ad_smb_enumC
Enumerate SMB shares and information on a target.
Args: target: Target IP or hostname username: Username for authenticated enum password: Password domain: AD domain
Inputs: target (required), domain, password, username. Returns: result
ad_tools_statusA
Check which AD tools are available on the Kali server.
Inputs: no named parameters. Returns: result
ad_wmiexecB
Execute commands on a remote Windows host via WMI (impacket).
Args: target: Target IP or hostname domain: AD domain username: Username password: Password hashes: NTLM hash for pass-the-hash command: Command to execute
Inputs: domain (required), target (required), username (required), hashes, +2 more. Returns: result
api_auth_bypass_testC
Test for authentication bypass vulnerabilities.
Args: url: Target API endpoint method: HTTP method headers: Custom headers as key:value pairs
Inputs: url (required), method, headers. Returns: result
api_ffuf_fuzzB
Fuzz using ffuf for content discovery and parameter brute-forcing.
Args: url: Target URL with FUZZ keyword (e.g., http://target/FUZZ) wordlist: Wordlist path on Kali server method: HTTP method mc: Match HTTP status codes (comma-separated) headers: Custom headers (key:value, comma-separated) data_str: POST data with FUZZ keyword
Inputs: url (required), mc, method, headers, +2 more. Returns: result
api_fuzz_endpointB
Fuzz an API endpoint with various payloads.
Args: url: Target API endpoint URL method: HTTP method (GET, POST, PUT, DELETE) parameters: Comma-separated parameter names to fuzz wordlist: Custom wordlist path (default: built-in) headers: Custom headers as key:value pairs, comma-separated
Inputs: url (required), method, headers, wordlist, +1 more. Returns: result
api_graphql_fuzzB
Fuzz a GraphQL endpoint for vulnerabilities.
Args: url: GraphQL endpoint URL query: Specific query to fuzz (auto-generated from schema if empty) depth: Fuzzing depth (default: 3)
Inputs: url (required), depth, query. Returns: result
api_graphql_introspectB
Introspect a GraphQL endpoint to discover schema, types, and queries.
Args: url: GraphQL endpoint URL
Inputs: url (required). Returns: result
api_jwt_analyzeA
Analyze a JWT token for weaknesses.
Args: token: The JWT token string to analyze
Returns: Decoded header/payload, algorithm analysis, and potential vulnerabilities
Inputs: token (required). Returns: result
api_jwt_crackB
Attempt to crack a JWT token's signing secret.
Args: token: The JWT token to crack wordlist: Path to wordlist on the Kali server
Inputs: token (required), wordlist. Returns: result
api_kiterunner_scanB
Scan API endpoints using Kiterunner for route discovery.
Args: url: Target base URL wordlist: Custom wordlist or kiterunner routes file
Inputs: url (required), wordlist. Returns: result
api_newman_runC
Run a Postman/Newman collection against API endpoints.
Args: collection: Path to Postman collection JSON file environment: Path to Postman environment JSON file
Inputs: collection (required), environment. Returns: result
api_nuclei_scanC
Run Nuclei templates against API endpoints.
Args: url: Target URL tags: Nuclei template tags (default: api) severity: Filter by severity (critical, high, medium, low)
Inputs: url (required), tags, severity. Returns: result
api_rate_limit_testA
Test API rate limiting controls.
Args: url: Target API endpoint requests_count: Number of requests to send (default: 100) method: HTTP method (default: GET)
Inputs: url (required), method, requests_count. Returns: result
callback_checkA
Check if any callbacks matching an identifier have been received.
Searches HTTP paths and DNS query names for the given substring. Useful after injecting a payload to see if the target called back.
Args: identifier: Substring to match in the request path or DNS query name. Empty string matches all callbacks. since_minutes: Only check callbacks from the last N minutes (default 60).
Returns: Dict with found status, match count, and matching entries.
Example: callback_check(identifier='ssrf-test1') callback_check(identifier='xxe', since_minutes=5)
Inputs: identifier, since_minutes. Returns: result
callback_clearA
Clear all captured callbacks from the catcher's memory.
Removes all stored HTTP and DNS callback entries. The listeners continue running — only the stored data is cleared.
Returns: Confirmation with the count of cleared entries.
Example: callback_clear()
Inputs: no named parameters. Returns: result
callback_generateA
Generate callback payload URLs and commands for injection testing.
Creates ready-to-use payloads with unique identifiers that will be captured by the callback catcher when triggered.
Args: listener_ip: IP address of the callback listener (your Kali IP). http_port: HTTP listener port (default 8888). dns_port: DNS listener port (default 5353). payload_type: Type of payload to generate. Options: 'url' — simple callback URL 'curl' — curl and wget one-liners 'xxe' — XML External Entity payloads 'ssrf' — SSRF test URLs 'dns' — DNS lookup commands (nslookup, dig, host) 'all' — all of the above
Returns: Generated payloads with unique identifiers for tracking.
Example: callback_generate(listener_ip='10.10.14.5') callback_generate(listener_ip='10.10.14.5', payload_type='xxe')
Inputs: listener_ip (required), dns_port, http_port, payload_type. Returns: result
callback_latestA
Get the most recent callback captured by the local catcher.
Returns the single latest callback entry, whether HTTP or DNS. Useful for quick checks after sending a payload.
Returns: The latest callback dict with full request details, or a message if no callbacks have been captured.
Example: callback_latest()
Inputs: no named parameters. Returns: result
callback_listA
List captured callbacks from the local catcher.
Returns the most recent callbacks, newest first. Filter by type to see only HTTP requests or DNS queries.
Args: limit: Maximum number of entries to return (default 50). callback_type: Filter by 'http', 'dns', or 'all' (default 'all').
Returns: List of callback entries with timestamps, source IPs, request details, and bodies.
Example: callback_list() callback_list(limit=10, callback_type='dns')
Inputs: limit, callback_type. Returns: result
callback_startA
Start the local callback catcher (HTTP + DNS listeners).
Runs an HTTP server and a DNS server on the Kali container to capture out-of-band callbacks from targets. Use this instead of webhook.site when the target network has no internet access.
Args: http_port: TCP port for the HTTP listener (default 8888). dns_port: UDP port for the DNS listener (default 5353). bind_ip: IP address to bind to (default '0.0.0.0'). Use the tun0 IP to restrict to VPN traffic.
Returns: Listener status including ports, bind IP, and detected tun0 IP.
Example: callback_start() callback_start(http_port=9090, bind_ip='10.10.14.5')
Inputs: bind_ip, dns_port, http_port. Returns: result
callback_statusA
Get the current status of the callback catcher.
Returns whether the listeners are running, which ports they are on, and counts of captured HTTP and DNS callbacks.
Returns: Status dict with running state, ports, and callback counts.
Example: callback_status()
Inputs: no named parameters. Returns: result
callback_stopA
Stop the local callback catcher and clean up all listeners.
Shuts down both the HTTP and DNS listener threads and closes their sockets. Captured callbacks remain in memory until explicitly cleared or a new session starts.
Returns: Confirmation with the number of callbacks still in memory.
Example: callback_stop()
Inputs: no named parameters. Returns: result
callback_waitA
Wait for a new callback to arrive at the local catcher.
Polls the callback catcher until a new entry appears or the timeout is reached. Checks every 2 seconds.
Args: timeout_seconds: Maximum time to wait in seconds (default 60). callback_type: Wait for a specific type: 'http', 'dns', or 'all' (default 'all').
Returns: The new callback entry if one arrived, or a timeout message.
Example: callback_wait() callback_wait(timeout_seconds=120, callback_type='http')
Inputs: callback_type, timeout_seconds. Returns: result
ctf_connectA
Connect to a CTF platform and authenticate.
Supports CTFd (most common) and rCTF platforms. Must be called before using other ctf_* tools.
Args: url: CTF platform base URL (e.g. 'https://ctf.example.com') token: API token from the platform settings page. For CTFd: Settings → Access Tokens → Generate. For rCTF: Profile → API Token. platform_type: Platform type — 'ctfd' (default) or 'rctf' verify_ssl: Verify SSL certificates (default True). Set False for self-signed certs commonly used in local CTF deployments.
Example: ctf_connect(url='https://ctf.example.com', token='ctfd_abc123')
Inputs: url (required), token, verify_ssl, platform_type. Returns: result
ctf_download_fileA
Download challenge files from the CTF platform.
Either provide challenge_id (downloads the first file) or a direct file_url from the challenge details.
Args: challenge_id: Download files for this challenge (uses first file) file_url: Direct file URL (takes priority over challenge_id) output_dir: Directory to save files to (default: /app/tmp/ctf_files)
Inputs: file_url, output_dir, challenge_id. Returns: result
ctf_get_challengeA
Get full details for a specific CTF challenge.
Returns the challenge description, files, hints, connection info, and solve status.
Args: challenge_id: The numeric challenge ID (from ctf_list_challenges)
Inputs: challenge_id (required). Returns: result
ctf_list_challengesA
List all available CTF challenges.
Returns challenge names, categories, point values, and solve counts. Requires a prior ctf_connect() call.
Args: category: Optional category filter (e.g. 'web', 'crypto', 'forensics')
Inputs: category. Returns: result
ctf_scoreboardA
Fetch the current CTF scoreboard.
Args: top: Number of top entries to return (default 20)
Inputs: top. Returns: result
ctf_statusA
Check current CTF platform connection status.
Inputs: no named parameters. Returns: result
ctf_submit_flagA
Submit a flag for a CTF challenge.
Returns whether the flag was correct, already solved, or incorrect.
Args: challenge_id: The challenge ID to submit for flag: The flag string (e.g. 'flag{example_flag_here}')
Example: ctf_submit_flag(challenge_id=42, flag='flag{s0m3_fl4g}')
Inputs: flag (required), challenge_id (required). Returns: result
cve_package_auditA
Check a specific software package for known vulnerabilities using OSV.dev.
Queries the Open Source Vulnerabilities database to find all known CVEs and security advisories affecting a package. Supports version-specific queries across all major ecosystems.
Args: package: Package name (e.g., 'lodash', 'django', 'openssl') version: Specific version to check (e.g., '4.17.20'). If omitted, returns all known vulnerabilities for any version. ecosystem: Package ecosystem — 'npm', 'PyPI', 'Maven', 'Go', 'crates.io', 'NuGet', 'Packagist', 'RubyGems', 'Debian', 'Alpine', etc. If omitted, OSV auto-detects.
Example usage: cve_package_audit(package='lodash', version='4.17.20', ecosystem='npm') cve_package_audit(package='django', ecosystem='PyPI') cve_package_audit(package='openssl')
Inputs: package (required), version, ecosystem. Returns: result
cve_searchA
Search the NVD (NIST National Vulnerability Database) for CVEs.
Query by keyword (e.g., 'Apache Log4j'), specific CVE ID (e.g., 'CVE-2021-44228'), or product name. Returns CVSS scores, descriptions, references, and weakness classifications.
Args: keyword: Search keyword — product name, library, or description text (e.g., 'OpenSSH', 'Apache Struts', 'buffer overflow') cve_id: Specific CVE identifier to look up (e.g., 'CVE-2021-44228'). When provided, keyword is ignored. results_per_page: Number of results to return (1-100, default 20)
Example usage: cve_search(keyword='Log4j') cve_search(cve_id='CVE-2021-44228') cve_search(keyword='OpenSSH', results_per_page=50)
Inputs: cve_id, keyword, results_per_page. Returns: result
exec_streamA
Execute a command with real-time streaming output via SSE (text/event-stream). Posts to api/command with streaming=True. Useful for long-running commands like nmap, nuclei, fuzzing.
Args: command: The command to execute timeout: Timeout in seconds (default: 3600 = 1 hour)
Returns: Streaming output collected in real-time with all events
Inputs: command (required), timeout. Returns: result
exploit_copyA
Copy an exploit to a working directory for modification.
Args: edb_id: Exploit-DB ID number destination: Directory to copy to (default: /tmp)
Returns: Path to copied exploit file
Inputs: edb_id (required), destination. Returns: result
exploit_detailsA
Get full details and source code for an exploit.
Args: edb_id: Exploit-DB ID number
Returns: Exploit metadata and source code
Inputs: edb_id (required). Returns: result
exploit_searchA
Search for exploits using searchsploit.
Args: query: Search term (service name, CVE, software version, etc.) exact: Use exact matching (default: False)
Returns: List of matching exploits with EDB IDs
Inputs: query (required), exact. Returns: result
exploit_suggest_for_serviceB
Get exploit suggestions for a specific service.
Args: service: Service name (e.g., 'apache', 'openssh', 'vsftpd') version: Version string (optional, e.g., '2.3.4', '8.4p1')
Returns: List of suggested exploits
Inputs: service (required), version. Returns: result
exploit_suggest_from_nmapC
Analyze nmap scan output and suggest exploits for discovered services.
Args: nmap_output: Raw nmap scan output text
Returns: Exploit suggestions grouped by service/port
Inputs: nmap_output (required). Returns: result
fingerprint_headersA
Analyze HTTP response headers for security posture.
Args: url: Target URL to check headers
Returns: Header analysis with security ratings
Inputs: url (required). Returns: result
fingerprint_urlA
Fingerprint a URL to detect technologies, frameworks, and CMS.
Args: url: Target URL to fingerprint
Returns: Detected technologies, headers, and server information
Inputs: url (required). Returns: result
fingerprint_wafB
Detect Web Application Firewall (WAF) on a target URL.
Args: url: Target URL to test for WAF
Returns: WAF detection results
Inputs: url (required). Returns: result
healthA
Check the health status of the Kali API server.
Returns: Server health information
Inputs: no named parameters. Returns: result
hosts_addA
Add hostname(s) to /etc/hosts on the Kali container at runtime.
No container restart needed. Entries are tracked in a managed section so they can be listed, removed, or cleared independently of system entries.
Args: ip: Target IP address (e.g., '10.129.17.154') hostnames: Space or comma separated hostnames (e.g., 'target.htb www.target.htb dc01.corp.local')
Returns: Added entries and current state
Example: hosts_add(ip='10.129.17.154', hostnames='silentium.htb') hosts_add(ip='10.10.11.5', hostnames='dc01.corp.local corp.local')
Inputs: ip (required), hostnames (required). Returns: result
hosts_clearA
Remove ALL managed /etc/hosts entries.
Clears only the Kali-MCP managed section. System entries (localhost, etc.) are never touched. Useful when switching to a completely new target.
Returns: Count of removed entries
Example: hosts_clear()
Inputs: no named parameters. Returns: result
hosts_listA
List all managed /etc/hosts entries added via Kali-MCP.
Returns: List of managed entries with IP and hostnames
Example: hosts_list()
Inputs: no named parameters. Returns: result
hosts_removeA
Remove a hostname from managed /etc/hosts entries.
Only removes from the Kali-MCP managed section — system entries (localhost, etc.) are never touched.
Args: hostname: The hostname to remove (e.g., 'target.htb')
Returns: Removal result and remaining entries
Example: hosts_remove(hostname='old-target.htb')
Inputs: hostname (required). Returns: result
job_cancelA
Cancel a running background job and its child process group.
Inputs: job_id (required). Returns: result
job_outputC
Poll recent bounded stdout and stderr from a background job.
Inputs: job_id (required), lines, timeout. Returns: result
job_statusA
Return state and exit metadata for a background command job.
Inputs: job_id (required). Returns: result
kali_downloadA
Download file content from the Kali server as base64.
Args: remote_path: Path to file on the Kali server verify_checksum: Verify SHA256 checksum if provided by the server
Returns: File content encoded as base64
Inputs: remote_path (required), verify_checksum. Returns: result
kali_uploadB
Upload content to the Kali server filesystem.
Args: content: Base64-encoded file content remote_path: Destination path on the Kali server encoding: Content encoding (utf-8, binary) verify_checksum: Compute and send SHA256 checksum for integrity verification
Inputs: content (required), remote_path (required), encoding, verify_checksum. Returns: result
msf_session_createA
Create a new persistent Metasploit (msfconsole) session.
Returns: Session ID to use with other msf_session_* tools
Inputs: no named parameters. Returns: result
msf_session_destroyB
Destroy a specific Metasploit session.
Args: session_id: The session ID to destroy
Inputs: session_id (required). Returns: result
msf_session_destroy_allA
Destroy all active Metasploit sessions.
Inputs: no named parameters. Returns: result
msf_session_executeA
Execute a command in an existing Metasploit session.
Args: session_id: The session ID from msf_session_create command: The Metasploit command to execute (e.g., "use exploit/...", "set RHOSTS ...", "run") timeout: Command timeout in seconds (default: 300) read_delay: Seconds to wait before reading output for slow-responding commands (default: 2)
Returns: Command output and status
Inputs: command (required), session_id (required), timeout, read_delay. Returns: result
msf_session_listA
List all active Metasploit sessions.
Inputs: no named parameters. Returns: result
parse_tool_outputA
Parse raw security tool output into structured JSON.
Takes the raw text output from tools like nmap, nuclei, or gobuster and returns a structured JSON representation for easier analysis. Parsing happens locally — no backend call is made.
Args: output: Raw text output from the tool tool_name: Tool identifier — 'nmap', 'nuclei', 'gobuster', or 'auto' output_format: Format hint — 'xml', 'jsonl', 'text', or 'auto' (default: auto)
Inputs: output (required), tool_name (required), output_format. Returns: result
payload_generateA
Generate a payload using msfvenom.
Args: lhost: Your IP address for callback lport: Port for callback (default: 4444) template: Use a predefined template (e.g., 'windows_meterpreter_reverse_tcp') payload: Metasploit payload string (ignored if template specified) format_type: Output format - exe, elf, raw, ps1, etc. encoder: Encoder to use (e.g., 'x86/shikata_ga_nai') iterations: Number of encoding iterations bad_chars: Characters to avoid in payload (e.g., '\x00\x0a\x0d') nops: Number of NOP sled bytes to prepend (default: 0) output_name: Custom output filename (auto-generated if empty)
Returns: Generated payload info including base64 content for small payloads
Inputs: lhost (required), nops, lport, encoder, +6 more. Returns: result
payload_host_startB
Start HTTP server to host generated payloads for download.
Args: port: Port for the hosting server (default: 8888)
Returns: Server URL for downloading payloads
Inputs: port. Returns: result
payload_host_stopA
Stop the payload hosting server.
Inputs: no named parameters. Returns: result
payload_listB
List all generated payloads.
Inputs: no named parameters. Returns: result
payload_one_linerB
Generate reverse shell one-liner commands.
Args: lhost: Your IP address for callback lport: Port for callback (default: 4444) shell_type: Type of shell - bash, python, nc, php, powershell, perl, ruby, or 'all'
Returns: One-liner command(s) ready to copy-paste
Inputs: lhost (required), lport, shell_type. Returns: result
payload_templatesA
List available payload templates and encoders for msfvenom.
Returns: List of template names and available encoders
Inputs: no named parameters. Returns: result
pivot_add_pivotB
Add a pivot point for tracking network access chains.
Args: name: Pivot name/identifier pivot_host: Host used as pivot method: Pivot method (ssh, chisel, ligolo, socat) subnet: Reachable subnet via this pivot (e.g., 10.10.10.0/24) notes: Additional notes
Inputs: name (required), pivot_host (required), notes, method, +1 more. Returns: result
pivot_chisel_clientA
Start a Chisel client to connect to a Chisel server.
Args: server_url: Chisel server URL (e.g., http://attacker:8080) tunnels: Tunnel specifications (e.g., 'R:8888:10.10.10.5:80') fingerprint: Server fingerprint for verification
Inputs: tunnels (required), server_url (required), fingerprint. Returns: result
pivot_chisel_serverB
Start a Chisel server for tunneling.
Args: port: Listening port (default: 8080) reverse: Allow reverse tunnels (default: True)
Inputs: port, reverse. Returns: result
pivot_generate_proxychainsA
Generate a proxychains configuration for pivoting through SOCKS proxy.
Args: socks_port: SOCKS proxy port (default: 1080) proxy_type: Proxy type (socks4, socks5)
Returns: Proxychains configuration content
Inputs: proxy_type, socks_port. Returns: result
pivot_ligolo_startC
Start a Ligolo-ng proxy server for pivoting.
Args: interface: TUN interface name (default: ligolo) port: Listening port (default: 11601)
Inputs: port, interface. Returns: result
pivot_list_pivotsB
List all configured pivot points/routes.
Inputs: no named parameters. Returns: result
pivot_list_tunnelsA
List all active tunnels and port forwards.
Inputs: no named parameters. Returns: result
pivot_socat_forwardB
Create a socat port forward.
Args: listen_port: Local port to listen on target_host: Target host to forward to target_port: Target port to forward to protocol: Protocol (tcp, udp)
Inputs: listen_port (required), target_host (required), target_port (required), protocol. Returns: result
pivot_ssh_dynamicB
Create an SSH dynamic SOCKS proxy.
Args: ssh_host: SSH server to use as SOCKS proxy socks_port: Local SOCKS port (default: 1080) username: SSH username password: SSH password key_file: SSH key file path
Inputs: ssh_host (required), key_file, password, username, +1 more. Returns: result
pivot_ssh_localA
Create an SSH local port forward (access remote service locally).
Args: ssh_host: SSH server to tunnel through local_port: Local port to listen on remote_host: Remote host to forward to (from SSH server's perspective) remote_port: Remote port to forward to username: SSH username password: SSH password key_file: SSH key file path
Inputs: ssh_host (required), local_port (required), remote_host (required), remote_port (required), +3 more. Returns: result
pivot_ssh_remoteA
Create an SSH remote port forward (expose local service on remote host).
Args: ssh_host: SSH server to tunnel through remote_port: Port to open on the SSH server local_host: Local host to forward to local_port: Local port to forward to username: SSH username password: SSH password key_file: SSH key file path
Inputs: ssh_host (required), local_host (required), local_port (required), remote_port (required), +3 more. Returns: result
pivot_stop_all_tunnelsA
Stop all active tunnels and port forwards.
Inputs: no named parameters. Returns: result
pivot_stop_tunnelB
Stop a specific tunnel.
Args: tunnel_id: The tunnel ID to stop
Inputs: tunnel_id (required). Returns: result
read_outputA
Read or poll bounded output from a background command job.
Typical workflow:
send_input(session_id, "whoami\n")
read_output(session_id, timeout=5) -> returns the command's output
The backend will wait up to timeout seconds for new output before
returning whatever is available (which may be empty if the process has
not produced anything yet).
Args: session_id: The session identifier to read from. timeout: Maximum seconds the backend should wait for new output before returning (default: 5). Use a higher value for slow commands (e.g. nmap, compilation). lines: Maximum number of output lines to return (default: 100). Older lines are trimmed first when the buffer exceeds this.
Returns: dict with at minimum: - success (bool): whether the read succeeded - output (str): the collected output text - session_id (str): echo of the session targeted - lines_returned (int): number of lines in output - error (str, optional): present only on failure
Inputs: session_id (required), lines, timeout. Returns: result
reverse_shell_commandA
Execute a command in an active reverse shell session.
Args: session_id: The session ID (e.g., 'shell_4444') command: Command to execute on the target timeout: Command timeout in seconds
Returns: Command output from the target system
Inputs: command (required), session_id (required), timeout. Returns: result
reverse_shell_download_contentA
Download file content from target via reverse shell and return as base64.
Args: session_id: The reverse shell session ID remote_file: Path to the file on the target method: Download method (base64, cat)
Inputs: session_id (required), remote_file (required), method. Returns: result
reverse_shell_generate_payloadA
Generate reverse shell payloads for manual execution on targets.
Args: local_ip: Your local IP address that the target should connect back to local_port: Local port to connect back to (default: 4444) payload_type: Type of payload (bash, python, nc, php, powershell, perl) encoding: Encoding format (plain, base64, url, hex)
Returns: Generated payload in various formats ready for manual execution
Inputs: local_ip (required), encoding, local_port, payload_type. Returns: result
reverse_shell_listener_startA
Start a reverse shell listener on the specified port.
Args: port: Port to listen on (default: 4444) session_id: Optional session identifier (auto-generated as shell_{port} if empty) listener_type: Type of listener - 'netcat' or 'pwncat' (default: netcat) auto_upgrade: Automatically attempt TTY upgrade on connection (default: False)
Returns: Session ID and listener status
Inputs: port, session_id, auto_upgrade, listener_type. Returns: result
reverse_shell_send_payloadA
Send a payload command to trigger a reverse shell connection in a non-blocking way.
Executes the payload in a background thread to avoid blocking the server. Waits then returns session status to verify the connection was established.
Args: session_id: The session ID of the reverse shell listener payload_command: The payload command to execute (e.g., curl with reverse shell) timeout: Timeout for the payload execution in seconds (default: 10) wait_seconds: Seconds to wait before checking session status (default: 5)
Returns: Payload execution status and session info
Inputs: session_id (required), payload_command (required), timeout, wait_seconds. Returns: result
reverse_shell_statusA
Get the status of reverse shell sessions.
Args: session_id: Optional specific session ID to check (if empty, shows all sessions)
Returns: Status information for reverse shell sessions
Inputs: session_id. Returns: result
reverse_shell_stopB
Stop a reverse shell session.
Args: session_id: The session ID to stop
Returns: Stop operation result
Inputs: session_id (required). Returns: result
reverse_shell_upload_contentB
Upload content directly to the target via reverse shell.
Args: session_id: The reverse shell session ID content: Base64 encoded content to upload remote_file: Path where to save the file on the target method: Upload method (base64) encoding: Content encoding (utf-8, binary)
Inputs: content (required), session_id (required), remote_file (required), method, +1 more. Returns: result
send_inputA
Send text input to a running background command job.
Use this together with read_output() to have a full interactive conversation with a long-running process:
Start a job with zebbern_exec(..., background=True)
send_input(session_id, "some command\n")
read_output(session_id) to collect the response
Args: session_id: The job identifier returned by zebbern_exec. input_text: The text to send to the session's stdin. Include a trailing newline (\n) if the target process expects one. session_type: Compatibility hint retained for existing clients.
Returns: dict with at minimum: - success (bool): whether the input was accepted - session_id (str): echo of the session targeted - error (str, optional): present only on failure
Inputs: input_text (required), session_id (required), session_type. Returns: result
ssh_estimate_transferB
Estimate file transfer time over SSH.
Args: file_size_bytes: File size in bytes operation: Transfer operation type (upload, download)
Returns: Estimated transfer time and recommendations
Inputs: file_size_bytes (required), operation. Returns: result
ssh_session_commandC
Execute a command in an active SSH session.
Args: session_id: The SSH session ID command: Command to execute on the remote host timeout: Command timeout in seconds (default: 60)
Returns: Command output from remote host
Inputs: command (required), session_id (required), timeout. Returns: result
ssh_session_download_contentB
Download file content from a remote host via SSH as base64.
Args: session_id: The SSH session ID remote_path: Path to the file on the remote host
Inputs: session_id (required), remote_path (required). Returns: result
ssh_sessionsB
List all active SSH sessions.
Inputs: no named parameters. Returns: result
ssh_session_startA
Start a persistent SSH session to a target host.
Args: target: Target hostname or IP username: SSH username (default: root) password: SSH password (if using password auth) key_file: Path to SSH private key file (if using key auth) port: SSH port (default: 22) session_id: Optional session identifier (auto-generated if empty)
Returns: Session ID and connection status
Inputs: target (required), port, key_file, password, +2 more. Returns: result
ssh_session_statusA
Check the status of an SSH session.
Args: session_id: The SSH session ID to check
Inputs: session_id (required). Returns: result
ssh_session_stopB
Stop/disconnect an SSH session.
Args: session_id: The SSH session ID to stop
Inputs: session_id (required). Returns: result
ssh_session_upload_contentA
Upload content directly to a remote host via SSH (no local temp files).
Args: session_id: The SSH session ID content: Base64-encoded content to upload remote_path: Destination path on the remote host encoding: Content encoding (utf-8, binary)
Inputs: content (required), session_id (required), remote_path (required), encoding. Returns: result
system_network_infoA
Get comprehensive network information for the Kali Linux system.
Returns: Network information including interfaces, IP addresses, routing table, etc.
Inputs: no named parameters. Returns: result
target_download_fileB
Download file content from a target via an active session.
Args: session_id: Active session ID remote_path: Path to file on the target method: Transfer method (ssh, reverse_shell) verify_checksum: Verify SHA256 checksum if provided by the server
Returns: File content encoded as base64
Inputs: session_id (required), remote_path (required), method, verify_checksum. Returns: result
target_upload_fileA
Upload content to a target via an active session (SSH or reverse shell).
Args: session_id: Active session ID content: Base64-encoded file content remote_path: Destination path on the target method: Transfer method (ssh, reverse_shell) encoding: Content encoding (utf-8, binary) verify_checksum: Compute and send SHA256 checksum for integrity verification
Inputs: content (required), session_id (required), remote_path (required), method, +2 more. Returns: result
tools_amassB
Perform advanced subdomain enumeration using OWASP Amass.
Amass performs network mapping of attack surfaces and external asset discovery using open-source information gathering and active reconnaissance techniques.
Args: domain: Target domain for subdomain enumeration (e.g., 'example.com') mode: Enumeration mode — 'passive' for OSINT-only or 'active' for DNS resolution and zone transfers (default: 'passive') additional_args: Extra amass arguments
Example usage: tools_amass(domain='example.com') tools_amass(domain='target.org', mode='active')
Inputs: domain (required), mode, additional_args. Returns: result
tools_arjunB
Discover hidden HTTP parameters using Arjun.
Args: url: Target URL method: HTTP method (GET, POST, JSON) headers: Custom headers as key:value pairs, comma-separated wordlist: Custom wordlist path on Kali (default: Arjun built-in) delay: Delay between requests in seconds (default: 0) threads: Number of concurrent threads (default: 2) include: Only test these parameters (comma-separated) exclude: Skip these parameters (comma-separated)
Inputs: url (required), delay, method, exclude, +4 more. Returns: result
tools_assetfinderC
Execute Assetfinder for asset discovery.
Args: domain: Target domain additional_args: Extra assetfinder arguments
Inputs: domain (required), additional_args. Returns: result
tools_byp4xxC
Execute byp4xx for 403 bypass testing.
Args: url: Target URL returning 403 method: HTTP method additional_args: Extra arguments
Inputs: url (required), method, additional_args. Returns: result
tools_crtshA
Query crt.sh certificate transparency logs for passive subdomain enumeration.
Searches Certificate Transparency (CT) logs via crt.sh to discover subdomains that have had TLS certificates issued for them. This is a passive reconnaissance technique that does not send any traffic to the target domain itself.
Args: domain: Target domain to search (e.g., 'example.com') include_expired: Include expired certificates in results (default: False). When True, results may contain historical subdomains that are no longer active but once held valid certificates.
Example usage: tools_crtsh(domain='example.com') tools_crtsh(domain='target.org', include_expired=True)
Inputs: domain (required), include_expired. Returns: result
tools_enum4linuxC
Execute Enum4linux Windows/Samba enumeration tool.
Args: target: Target IP additional_args: Enum4linux flags (default: -a for all)
Inputs: target (required), additional_args. Returns: result
tools_fierceC
Execute Fierce for DNS reconnaissance.
Args: domain: Target domain additional_args: Extra fierce arguments
Inputs: domain (required), additional_args. Returns: result
tools_gobusterC
Execute Gobuster to find directories, DNS subdomains, or virtual hosts.
Args: url: Target URL mode: Gobuster mode (dir, dns, vhost, fuzz) wordlist: Wordlist path on Kali additional_args: Extra gobuster arguments threads: Number of concurrent threads (default: 10) extensions: File extensions to search for, comma-separated (e.g., 'php,html,txt') status_codes: Positive status codes to match, comma-separated (e.g., '200,301,302')
Inputs: url (required), mode, threads, wordlist, +3 more. Returns: result
tools_gowitnessA
Capture a screenshot of a web page using gowitness.
Uses a headless Chrome browser to render and screenshot web pages. Useful for visual reconnaissance, documenting findings, and identifying web technologies from page appearance.
Args: url: Target URL to screenshot (e.g., 'https://example.com') threads: Number of concurrent screenshot threads (default: 4) resolution: Browser viewport resolution as WIDTHxHEIGHT (default: '1280x720') additional_args: Extra gowitness arguments
Example usage: tools_gowitness(url='https://example.com') tools_gowitness(url='https://target.org', threads=8, resolution='1920x1080')
Inputs: url (required), threads, resolution, additional_args. Returns: result
tools_httpxB
Execute httpx for HTTP probing.
Args: target: Target URL, domain, or IP additional_args: Extra httpx arguments
Inputs: target (required), additional_args. Returns: result
tools_hydraB
Execute Hydra password cracking tool.
Args: target: Target IP or hostname service: Service to attack (ssh, ftp, http-get, etc.) username: Single username username_file: Path to username list on Kali password: Single password password_file: Path to password list on Kali additional_args: Extra hydra arguments tasks: Number of parallel connection threads (default: 16) wait: Timeout in seconds for each connection attempt (default: 32) port: Target port override (default: 0 means use service default)
Inputs: target (required), service (required), port, wait, +6 more. Returns: result
tools_johnA
Execute John the Ripper password cracker.
Args: hash_file: Path to hash file on Kali wordlist: Wordlist path format_type: Hash format (e.g., 'NT', 'md5crypt', 'raw-sha256') additional_args: Extra john arguments
Inputs: hash_file (required), wordlist, format_type, additional_args. Returns: result
tools_katanaA
Execute Katana for web crawling with JavaScript parsing support.
Katana is a next-generation crawling and spidering framework that supports headless browsing and JavaScript rendering, allowing it to discover endpoints hidden behind client-side routing and dynamically generated content.
Args: url: Target URL to crawl (e.g., 'https://example.com') depth: Maximum crawl depth (default: 3). Higher values discover more pages but take longer. js_crawl: Enable JavaScript crawling/rendering (default: True). When enabled, Katana uses a headless browser to execute JS and discover dynamically loaded endpoints. scope: Regex pattern to restrict crawl scope (e.g., '.*.example.com'). Empty string means no scope restriction. additional_args: Extra katana arguments (e.g., '-H "Authorization: Bearer token"')
Example usage: tools_katana(url='https://example.com') tools_katana(url='https://target.com', depth=5, js_crawl=True) tools_katana(url='https://app.example.com', scope='.*.example.com', additional_args='-H "Cookie: session=abc"')
Inputs: url (required), depth, scope, js_crawl, +1 more. Returns: result
tools_masscanA
Execute Masscan for fast port scanning across large IP ranges.
Masscan is an internet-scale port scanner capable of scanning the entire internet in under 6 minutes. It produces SYN packets asynchronously, making it significantly faster than traditional scanners for large target ranges.
Args: target: Target IP, CIDR range, or hostname (e.g., '10.0.0.0/24') ports: Port specification (default: '1-65535' for full range). Supports ranges ('1-1024'), lists ('80,443,8080'), or mixed ('22,80,443,8000-9000'). rate: Packets per second (default: 1000). Higher values scan faster but may overwhelm the network or trigger IDS. Common values: 1000 (safe), 10000 (moderate), 100000 (aggressive). additional_args: Extra masscan arguments (e.g., '--banners' to grab service banners)
Example usage: tools_masscan(target='192.168.1.0/24', ports='80,443,8080', rate=5000) tools_masscan(target='10.0.0.1', ports='1-1024') tools_masscan(target='172.16.0.0/16', ports='22,80,443', rate=10000, additional_args='--banners')
Inputs: target (required), rate, ports, additional_args. Returns: result
tools_niktoB
Execute Nikto web server scanner.
Args: target: Target URL or IP additional_args: Extra nikto arguments tuning: Nikto scan tuning options (e.g., '1' for interesting file, '2' for misconfiguration) output_format: Output format (e.g., 'htm', 'csv', 'xml', 'txt')
Inputs: target (required), tuning, output_format, additional_args. Returns: result
tools_nmapA
Execute an Nmap scan against a target.
Args: target: Target IP, hostname, or CIDR range scan_type: Nmap scan type flags (default: -sV) ports: Port specification (e.g., '80,443' or '1-1024') additional_args: Extra nmap arguments output_format: Output format — 'normal', 'xml', or 'grepable' (default: normal). When 'xml', adds -oX - for structured XML output.
Inputs: target (required), ports, scan_type, output_format, +1 more. Returns: result
tools_sqlmapB
Execute SQLmap SQL injection scanner.
Args: url: Target URL with parameter(s) data: POST data string additional_args: Extra sqlmap arguments technique: SQL injection techniques to test (e.g., 'BEUSTQ') level: Level of tests to perform, 1-5 (default: 1) risk: Risk of tests to perform, 1-3 (default: 1) dbs: Enumerate DBMS databases (default: False) tables: Enumerate DBMS database tables (default: False) dump: Dump DBMS database table entries (default: False)
Inputs: url (required), dbs, data, dump, +5 more. Returns: result
tools_ssh_auditB
Execute ssh-audit to analyze SSH server security configuration.
Args: target: Target hostname or IP port: SSH port (default: 22) timeout: Connection timeout in seconds scan_type: Scan type (ssh1, ssh2) policy_file: Path to policy file on Kali additional_args: Extra arguments
Inputs: target (required), port, timeout, scan_type, +2 more. Returns: result
tools_sslscanA
Execute sslscan to test SSL/TLS ciphers and certificate configuration.
Sslscan probes a target's SSL/TLS service to enumerate supported cipher suites, protocol versions, and certificate details. Useful for identifying weak ciphers, expired certificates, and misconfigured TLS deployments.
Args: target: Target hostname or IP to scan (e.g., 'example.com') port: TLS port to connect to (default: 443) additional_args: Extra sslscan arguments (e.g., '--no-colour' or '--show-certificate')
Example usage: tools_sslscan(target='example.com') tools_sslscan(target='10.0.0.5', port=8443) tools_sslscan(target='mail.example.com', port=993, additional_args='--show-certificate')
Inputs: target (required), port, additional_args. Returns: result
tools_subfinderB
Execute Subfinder for subdomain enumeration.
Args: target: Target domain additional_args: Extra subfinder arguments
Inputs: target (required), additional_args. Returns: result
tools_subzyC
Execute Subzy for subdomain takeover detection.
Args: target: Target domain or file with subdomains additional_args: Extra subzy arguments
Inputs: target (required), additional_args. Returns: result
tools_waybackurlsC
Execute waybackurls to fetch URLs from Wayback Machine.
Args: domain: Target domain additional_args: Extra arguments
Inputs: domain (required), additional_args. Returns: result
tools_wpscanA
Execute WPScan WordPress vulnerability scanner.
Args: url: Target WordPress URL additional_args: Extra wpscan arguments api_token: WPScan API token for vulnerability data lookups enumerate: Enumeration options (e.g., 'vp' for vulnerable plugins, 'u' for users) output_format: Output format — 'cli', 'json', or 'cli-no-colour' (default: cli)
Inputs: url (required), api_token, enumerate, output_format, +1 more. Returns: result
vpn_connectA
Connect to a VPN (WireGuard or OpenVPN) with a single call.
Places the config, brings the tunnel up, and returns the assigned IP address. Auto-detects VPN type from the config file contents unless explicitly specified.
Args: config_path: Absolute path to the VPN config file inside the container (e.g. /vpn/wg0.conf or /vpn/client.ovpn). Mount your config directory as a Docker volume to /vpn. vpn_type: 'wireguard', 'openvpn', or 'auto' (default). Auto reads [Interface]/[Peer] for WireGuard, or client/remote directives for OpenVPN. interface: WireGuard interface name (default wg0). Ignored for OpenVPN connections.
Returns: Connection result including success flag, assigned IP, interface name, and VPN type.
Example: vpn_connect(config_path='/vpn/wg0.conf') vpn_connect(config_path='/vpn/client.ovpn', vpn_type='openvpn')
Inputs: config_path (required), vpn_type, interface. Returns: result
vpn_disconnectA
Disconnect from a VPN tunnel.
Brings down the specified interface (WireGuard) or kills the OpenVPN daemon process.
Args: interface: Interface to disconnect (default wg0). vpn_type: 'wireguard', 'openvpn', or 'auto'. Auto checks whether the interface is a WireGuard tunnel.
Returns: Disconnection result with success flag.
Example: vpn_disconnect() vpn_disconnect(interface='wg1') vpn_disconnect(vpn_type='openvpn')
Inputs: vpn_type, interface. Returns: result
vpn_statusA
Get status of all active VPN connections.
Queries both WireGuard (via wg show) and OpenVPN (via PID
file) and returns a list of active tunnels with their assigned
IP addresses.
Returns:
Dictionary with connections list, count, and
active_count.
Example: vpn_status()
Inputs: no named parameters. Returns: result
zebbern_execA
Execute ANY command on the Kali server without restrictions. Full root access, no timeout limits (default 1 hour).
Args: command: The command to execute (can be any shell command, pipes, chains, etc.) timeout: Timeout in seconds (default: 3600 = 1 hour) cwd: Optional working directory for the command background: If True, return immediately with a trackable job_id
Returns: Command output with stdout, stderr, return_code, execution_time. When background=True, returns job_id, pid, and initial status instead.
Inputs: command (required), cwd, timeout, background. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 131 tools
Multiple tools target the same job—subdomain discovery has subfinder/amass/assetfinder/crtsh/fierce, API fuzzing has api_fuzz_endpoint/api_ffuf_fuzz/api_nuclei_scan/api_kiterunner_scan, and payload generation has payload_generate/payload_one_liner/reverse_shell_generate_payload. Four different session/upload families add further overlap. Agents will frequently need to inspect descriptions closely to avoid selecting the wrong tool.
Naming is clustered by feature area but not unified; the server mixes noun-first names like tools_nmap and payload_list with verb-first names like exec_stream and callback_generate. The prefix scheme helps within categories, but cross-category patterns and generic names like zebbern_exec and health make the overall naming inconsistent.
131 tools is far past the 50+ threshold, and the count is inflated by wrapper-per-tool proliferation plus duplicate session, callback, upload, and exec capabilities. A leaner set of around 20-30 generic tool runners and shared infrastructure tools would serve the same purpose more effectively.
The set covers a broad pentest lifecycle: recon, scanning, exploitation, AD attacks, file transfer, pivoting, callbacks, and CTF interaction. A few niceties like vulnerability report generation or dedicated exploit execution wrappers are missing, but zebbern_exec and msf_session_execute provide practical workarounds.
Maintenance
Related MCP Connectors
Secure Linux sandboxes for AI agents, as MCP tools.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Hosting for AI agents: your AI client deploys Docker apps to live HTTPS URLs over MCP.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA penetration testing MCP server that runs 20 hacking tools inside a Kali Linux Docker container, enabling AI assistants to execute security scans and attacks via natural language.2-
- AlicenseAqualityBmaintenanceEnables AI agents to perform professional penetration testing through a containerized Kali Linux environment, exposing industry-standard offensive security tools as structured MCP tools.456MIT
- FlicenseBqualityCmaintenanceA Kali Linux MCP server that integrates network security and penetration testing tools like Nmap, Whois, Dig, Ping, Nikto, Hydra, and SQLMap into a Dockerized environment for use with LLMs.163-
- FlicenseNot gradedqualityDmaintenanceA Dockerized Kali Linux MCP server that enables LLMs to perform network security scans, penetration testing, and reconnaissance using tools like Nmap, Nikto, Hydra, and SQLMap.9 npm-