📄 工具详情 ⚙️ 安装教程 📚 使用教程

能力标签

🔌 MCP 🤖 Agent 🔄 工作流 🐳 Docker 💻 CLI 🔗 REST API 🧬 Embedding 🧠 Claude ✨ GPT ⛓ LangChain

🛠

AI工具

Offsec-AI

Q: offsec-ai 如何安装和开始使用？

访问 offsec-ai 的 GitHub 仓库或官方网站，按照 README 文档中的步骤安装依赖并运行。通常需要 Python 3.8+ 或 Node.js 16+ 基础环境。

Q: offsec-ai 是否免费？许可证是什么？

offsec-ai 完全免费，采用 MIT 许可证开源发布，任何人都可以免费使用、修改和分发。

Q: offsec-ai 适合哪些用户使用？

offsec-ai 主要面向有一定技术基础的用户，包括开发者、数据分析师、AI 工程师等专业人士。

Q: offsec-ai 的社区活跃度和项目维护状况如何？

offsec-ai 在 GitHub 上已获得 12 个 Star，处于积极发展阶段，社区在持续扩大。

基于 Python · 开源免费，本地部署，数据完全自主可控

英文名：offsec-ai

⭐ 12 Stars 🍴 5 Forks 💻 Python 📄 MIT 🏷 AI 8.0分

8.0AI 综合评分

offensive-securitynetwork-reconnaissancepython3

🌐 访问官网 📺 TG 频道

✦ AI Skill Hub 推荐

经 AI Skill Hub 精选评估，Offsec-AI 获评「强烈推荐」。这款AI工具在功能完整性、社区活跃度和易用性方面表现出色，AI 评分 8.0 分，适合有一定技术背景的用户使用。

📚 深度解析

Offsec-AI 是一款基于 Python 的开源工具，在 GitHub 上收获 0k+ Star，是offensive-security、network-reconnaissance、python3领域中的优质开源项目。开源工具的最大优势在于代码完全透明，你可以审计每一行代码的安全性，也可以根据自身需求进行二次开发和定制。

**为什么要使用开源工具而非商业 SaaS？**
对于个人开发者和有隐私需求的用户，本地部署的开源工具意味着数据不离本机，不受第三方服务商的数据政策约束。同时，开源工具通常没有使用次数限制和月度费用，一次安装即可长期使用，对于高频使用场景的总拥有成本（TCO）远低于订阅制商业工具。

**安装与环境准备**
Offsec-AI 依赖 Python 运行环境。建议通过 pyenv（Python）或 nvm（Node.js）管理 Python 版本，避免全局环境污染。对于新手用户，推荐先创建虚拟环境（python -m venv venv && source venv/bin/activate），再安装依赖，这样即使出现问题也可以随时删除虚拟环境重新开始，不影响系统稳定性。

**社区与维护**
GitHub Issue 和 Discussion 是获取帮助的最快渠道。在提问前建议先检查 Closed Issues（已关闭的问题），大多数常见问题都已有解答。遇到 Bug 时，提供 pip list 的输出、完整错误堆栈和最小可复现示例，能显著提高开发者响应速度。AI Skill Hub 将持续追踪 Offsec-AI 的版本更新，及时通知重要功能变化。

📋 工具概览

Offsec-AI 是一款基于 Python 开发的开源工具，专注于 offensive-security、network-reconnaissance、python3 等核心功能。作为 GitHub 开源项目，它拥有活跃的社区支持和持续的版本迭代，代码完全透明可审计，支持本地部署以保护数据隐私。无论是个人使用还是集成到企业工作流，都能提供稳定可靠的解决方案。

GitHub Stars

⭐ 12

开发语言

Python

支持平台

Windows / macOS / Linux

维护状态

轻量级项目，按需更新

开源协议

MIT

AI 综合评分

8.0 分

工具类型

AI工具

Forks

📖 中文文档

以下内容由 AI Skill Hub 根据项目信息自动整理，如需查看完整原始文档请访问底部「原始来源」。

📌 核心特色

开源免费，支持本地部署，数据完全自主可控
活跃的 GitHub 开源社区，持续迭代更新
提供详细文档和使用示例，新手友好
支持自定义配置，灵活适配不同使用环境
可作为基础组件集成进现有技术栈或进行二次开发

🎯 主要使用场景

本地部署运行，保护数据隐私，满足合规要求
自定义集成到现有系统，扩展技术栈能力
作为开源基础组件进行商业化二次开发

以下安装命令基于项目开发语言和类型自动生成，实际以官方 README 为准。

安装命令

# 方式一：pip 安装（推荐）
pip install offsec-ai

# 方式二：虚拟环境安装（推荐生产环境）
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install offsec-ai

# 方式三：从源码安装（获取最新功能）
git clone https://github.com/Htunn/offsec-ai
cd offsec-ai
pip install -e .

# 验证安装
python -c "import offsec_ai; print('安装成功')"

📋 安装步骤说明

访问 GitHub 仓库页面
按照 README 文档完成依赖安装
根据系统环境完成初始化配置
参考官方示例或文档开始使用
遇到问题可在 GitHub Issues 中查找解答

以下用法示例由 AI Skill Hub 整理，涵盖最常见的使用场景。

常用命令 / 代码示例

# 命令行使用
offsec-ai --help

# 基本用法
offsec-ai input_file -o output_file

# Python 代码中调用
import offsec_ai

# 示例
result = offsec_ai.process("input")
print(result)

以下配置示例基于典型使用场景生成，具体参数请参照官方文档调整。

配置示例

# offsec-ai 配置文件示例（config.yml）
app:
  name: "offsec-ai"
  debug: false
  log_level: "INFO"

# 运行时指定配置文件
offsec-ai --config config.yml

# 或通过环境变量配置
export OFFSEC_AI_API_KEY="your-key"
export OFFSEC_AI_OUTPUT_DIR="./output"

📑 README 深度解析真实文档完整度 87/100 查看 GitHub 原文 →

以下内容由系统直接从 GitHub README 解析整理，保留代码块、表格与列表结构。

简介

 ██████╗ ███████╗███████╗███████╗███╗   ██╗███████╗██╗██╗   ██╗███████╗
██╔═══██╗██╔════╝██╔════╝██╔════╝████╗  ██║██╔════╝██║██║   ██║██╔════╝
██║   ██║█████╗  █████╗  █████╗  ██╔██╗ ██║███████╗██║██║   ██║█████╗
██║   ██║██╔══╝  ██╔══╝  ██╔══╝  ██║╚██╗██║╚════██║██║╚██╗ ██╔╝██╔══╝
╚██████╔╝██║     ██║     ███████╗██║ ╚████║███████║██║ ╚████╔╝ ███████╗
 ╚═════╝ ╚═╝     ╚═╝     ╚══════╝╚═╝  ╚═══╝╚══════╝╚═╝  ╚═══╝  ╚══════╝-AI
  Offensive-Security Toolkit · AI/LLM · MCP · A2A · Postman · Blockchain · Red-Team

Offensive-security toolkit for authorized red-team engagements.

offensive-ai is a Python library and CLI that combines classic network reconnaissance with modern AI/LLM security testing. It probes live AI/LLM endpoints for the OWASP LLM Top 10, scans and actively attacks Model Context Protocol (MCP) servers for known CVEs, and performs full-stack infrastructure security assessments.

Legal Notice: Active attack features (mcp-attack, openclaw-attack, k8s-attack, auth-attack, a2a-attack, postman-attack, blockchain-attack, deep mode, and agent's attack tools with --i-have-authorization) require explicit confirmation of authorization. Only use against systems you own or have explicit written permission to test.

---

Features

pip install "offensive-ai[ai]"
export GEMINI_API_KEY="AIza..."       # Google Gemini  (1st priority)
export ANTHROPIC_API_KEY="sk-ant-..." # or Anthropic   (2nd priority)
export OPENAI_API_KEY="sk-..."        # or OpenAI      (3rd priority)

If multiple keys are set, Gemini is used first, then Anthropic, then OpenAI. Without the extra, detection falls back to rule-based pattern matching.

---

Passive scan — fingerprint and report misconfigurations

offensive-ai openclaw-scan 192.168.1.10

kubectl proxy makes the API server reachable on plain HTTP locally:

offensive-ai k8s-scan 127.0.0.1 --port 8001 --llm-judge offensive-ai k8s-attack 192.168.1.100 --i-have-authorization --mode deep offensive-ai k8s-attack 127.0.0.1 --port 8001 --i-have-authorization --llm-judge

Python API

import asyncio
from offensive_ai import LLMOwaspScanner, MCPScanner, MCPAttacker, AuthorizationRequired
from offensive_ai import AuthScanner, AuthAttacker, AuthProtocol
from offensive_ai import A2AScanner, A2AAttacker
from offensive_ai import PostmanScanner, PostmanAttacker

async def main():
    # Postman collection security scan
    pm = PostmanScanner(
        collection_path="collection.json",
        environment_path="env.json",
        target_override="https://api.example.com",
    )
    pm_result = await pm.scan()
    print(f"Endpoints: {pm_result.endpoints_scanned}  Vulns: {len(pm_result.all_vulns)}  Critical: {pm_result.has_critical}")

    # A2A agent security scan
    a2a = A2AScanner("https://agent.example.com")
    a2a_result = await a2a.scan()
    print(f"Agent: {a2a_result.agent_card.name}  Skills: {len(a2a_result.agent_card.skills)}")
    print(f"Auth: {a2a_result.auth_posture.auth_type}  Unauthed: {a2a_result.auth_posture.unauthenticated_access}")
    print(f"Vulnerabilities: {len(a2a_result.all_vulns)}  Critical: {a2a_result.has_critical}")

    # Auth protocol scan (OIDC / OAuth2 / SAML)
    auth = AuthScanner("https://accounts.google.com")
    auth_result = await auth.scan()
    print(f"Protocol: {auth_result.protocol.value}  Provider: {auth_result.provider_info.name}")
    print(f"Vulnerabilities: {len(auth_result.all_vulns)}")

    # SAML scan
    saml = AuthScanner("https://mocksaml.com/api/saml/metadata", protocol="saml")
    saml_result = await saml.scan()
    print(f"SAML issuer: {saml_result.provider_info.issuer}")

    # Auth attack (requires explicit authorization)
    attacker = AuthAttacker(authorized=True)
    report = await attacker.attack(
        target="https://auth.example.com",
        mode="safe",
    )
    print(f"Attacks run: {report.attacks_run}, triggered: {report.attacks_triggered}")

    # AI OWASP scan
    scanner = LLMOwaspScanner("https://api.example.com/v1/chat/completions")
    result = await scanner.scan()
    print(f"Grade: {result.overall_grade}  Score: {result.total_score}")
    for cat_id, cat in result.categories.items():
        if cat.findings:
            print(f"  {cat_id}: {len(cat.findings)} finding(s) — grade {cat.grade}")

    # MCP scan
    mcp = MCPScanner("https://mcp.example.com/mcp")
    mcp_result = await mcp.scan()
    print(f"MCP vulnerabilities: {len(mcp_result.vulnerabilities)}")

    # MCP attack (requires explicit authorization)
    try:
        attacker = MCPAttacker(authorized=True)   # must be True
        report = await attacker.attack(
            target="https://mcp.example.com/mcp",
            transport="http",
            mode="safe",
        )
        print(f"Attacks run: {report.attacks_run}, triggered: {len(report.triggered_results)}")
    except AuthorizationRequired:
        print("Provide authorized=True to unlock attack mode")

asyncio.run(main())

---

Python API

import asyncio
from offensive_ai import A2AScanner, A2AAttacker, A2AVulnSeverity
from offensive_ai.core.llm_judge import LLMJudge
from offensive_ai.exceptions import AuthorizationRequired

async def main():
    # Optional LLM judge
    judge = LLMJudge.from_env()   # reads GEMINI_API_KEY / ANTHROPIC_API_KEY / OPENAI_API_KEY

    # Passive scan
    scanner = A2AScanner(
        target="https://agent.example.com",
        port=None,              # override port (optional)
        headers={},             # extra HTTP headers
        timeout=15.0,
        verify_tls=True,
        judge=judge,            # None = rule-based only
    )
    result = await scanner.scan()

    print(f"Agent          : {result.agent_card.name} v{result.agent_card.version}")
    print(f"Provider       : {result.agent_card.provider_organization}")
    print(f"Skills         : {len(result.agent_card.skills)}")
    print(f"Auth type      : {result.auth_posture.auth_type}")
    print(f"Unauthed access: {result.auth_posture.unauthenticated_access}")
    print(f"Push webhooks  : {result.agent_card.capabilities.push_notifications}")
    print(f"Card signed    : {result.agent_card.is_signed}")
    print(f"Vulnerabilities: {len(result.all_vulns)}  Critical: {result.has_critical}")

    for vuln in result.all_vulns:
        print(f"  [{vuln.severity.value}] {vuln.vuln_id}: {vuln.title}")
        if vuln.evidence:
            print(f"    Evidence: {vuln.evidence[:80]}")
        if vuln.llm_reasoning:
            print(f"    LLM ({vuln.llm_confidence:.0%}): {vuln.llm_reasoning[:100]}")

    # Authorized active attack
    try:
        attacker = A2AAttacker(authorized=True, judge=judge)
        report = await attacker.attack(
            target="https://agent.example.com",
            mode="deep",         # "safe" | "deep"
            scan_result=result,  # guides SSRF probe (push_notifications check)
        )
        print(f"Attacks run     : {report.attacks_run}")
        print(f"Attacks triggered: {report.attacks_triggered}")
        for r in report.successful_attacks:
            print(f"  [{r.severity.value}] {r.attack_id} ({r.attack_type}): {r.title}")
            if r.evidence:
                print(f"    Evidence: {r.evidence[:80]}")
    except AuthorizationRequired:
        print("Pass authorized=True to unlock attack mode")

asyncio.run(main())

---

Passive scan — probe every endpoint in the collection

offensive-ai postman-scan collection.json

Deep mode — all 5 OWASP API attack categories

offensive-ai postman-attack collection.json \ --i-have-authorization --mode deep \ -T https://api.example.com -e env.json --llm-judge

Python API

import asyncio
from offensive_ai import PostmanScanner, PostmanAttacker, PostmanVulnSeverity
from offensive_ai.core.llm_judge import LLMJudge
from offensive_ai.exceptions import AuthorizationRequired

async def main():
    judge = LLMJudge.from_env()   # reads GEMINI_API_KEY / ANTHROPIC_API_KEY / OPENAI_API_KEY

    # Passive scan
    scanner = PostmanScanner(
        collection_path="collection.json",
        environment_path="env.json",   # optional
        target_override="https://api.example.com",
        headers={"X-Custom-Header": "value"},
        timeout=10.0,
        verify_tls=True,
        max_endpoints=50,
        judge=judge,
    )
    result = await scanner.scan()

    print(f"Collection      : {result.collection_name}")
    print(f"Endpoints scanned: {result.endpoints_scanned}")
    print(f"Vulnerabilities : {len(result.all_vulns)}  Critical: {result.has_critical}")
    for vuln in result.all_vulns:
        print(f"  [{vuln.severity.value}] {vuln.check_id}: {vuln.title}")
        if vuln.evidence:
            print(f"    Evidence: {vuln.evidence[:80]}")
        if vuln.llm_reasoning:
            print(f"    LLM ({vuln.llm_confidence:.0%}): {vuln.llm_reasoning[:100]}")

    # Authorized active attack
    try:
        attacker = PostmanAttacker(authorized=True, judge=judge)
        report = await attacker.attack(
            collection_path="collection.json",
            environment_path="env.json",
            target_override="https://api.example.com",
            mode="deep",   # "safe" | "deep"
        )
        print(f"Attacks run     : {report.attacks_run}")
        print(f"Attacks triggered: {len(report.successful_attacks)}")
        if report.exploit_chain_summary:
            print(f"Exploit chain   : {report.exploit_chain_summary}")
        for r in report.successful_attacks:
            print(f"  [{r.severity.value}] {r.attack_id} ({r.attack_type}): {r.title}")
    except AuthorizationRequired:
        print("Pass authorized=True to unlock attack mode")

asyncio.run(main())

---

Basic scan (safe mode, OpenAI-compatible endpoint)

offensive-ai ai-owasp-scan https://api.example.com/v1/chat/completions

Generic/custom API format (non-OpenAI)

offensive-ai ai-owasp-scan https://chat.example.com/api/chat --api-format generic

Python API

import asyncio
from offensive_ai import LLMOwaspScanner, LLMScanMode, LLMJudge

async def main():
    # Optional: enable LLM judge for smarter detection
    judge = LLMJudge.from_env()  # reads OPENAI_API_KEY / ANTHROPIC_API_KEY

    scanner = LLMOwaspScanner(
        endpoint="https://api.example.com/v1/chat/completions",
        mode=LLMScanMode.DEEP,
        categories=["LLM01", "LLM02", "LLM07"],
        api_format="openai",
        headers={"Authorization": "Bearer sk-..."},
        judge=judge,                # None = rule-based only
    )

    result = await scanner.scan()
    print(f"Grade: {result.overall_grade}  ({result.total_score} pts)")

    for cat_id, cat in result.categories.items():
        if cat.findings:
            print(f"\n{cat_id}: {cat.category_name}")
            for finding in cat.findings:
                print(f"  [{finding.severity.value}] {finding.title}")
                print(f"  Evidence: {finding.evidence[:80]}...")

asyncio.run(main())

Scan HTTP/SSE MCP endpoint

offensive-ai mcp-scan https://mcp.example.com/mcp

Python API

import asyncio
from offensive_ai import MCPScanner, MCPTransport

async def main():
    # HTTP transport
    scanner = MCPScanner(
        target="https://mcp.example.com/mcp",
        transport=MCPTransport.HTTP,
        headers={"Authorization": "Bearer token"},
        judge=LLMJudge.from_env(),  # optional: enriches MEDIUM/LOW findings
    )
    result = await scanner.scan()

    print(f"Server: {result.server_info.name} v{result.server_info.version}")
    print(f"Tools: {len(result.tools)}, Resources: {len(result.resources)}")
    print(f"Vulnerabilities: {len(result.vulnerabilities)}")

    for vuln in result.vulnerabilities:
        print(f"  [{vuln.severity.value}] {vuln.title}: {vuln.description}")

    # Stdio transport
    scanner = MCPScanner(
        target="stdio://local",
        transport=MCPTransport.STDIO,
        cmd=["npx", "@example/mcp-server"],
    )
    result = await scanner.scan()

asyncio.run(main())

---

Python API

import asyncio
from offensive_ai import MCPAttacker, MCPScanner, AuthorizationRequired

async def main():
    # Authorization is enforced at instantiation
    try:
        bad = MCPAttacker()               # raises AuthorizationRequired
    except AuthorizationRequired:
        pass

    attacker = MCPAttacker(authorized=True)

    # Optional: use scan result to guide attacks
    scanner = MCPScanner("https://mcp.example.com/mcp")
    scan_result = await scanner.scan()

    report = await attacker.attack(
        target="https://mcp.example.com/mcp",
        transport="http",
        mode="deep",
        scan_result=scan_result,
    )

    print(f"Attacks run: {report.attacks_run}")
    print(f"Triggered: {len(report.triggered_results)}")
    for r in report.triggered_results:
        print(f"  [{r.severity.value}] {r.title}")

asyncio.run(main())

---

Python API

import asyncio
from offensive_ai import AuthScanner, AuthAttacker, AuthProtocol, LLMJudge
from offensive_ai.exceptions import AuthorizationRequired

async def main():
    # Optional LLM judge
    judge = LLMJudge.from_env()   # reads GEMINI_API_KEY / ANTHROPIC_API_KEY / OPENAI_API_KEY

    # --- Passive scan (OIDC/OAuth2 auto-detect) ---
    scanner = AuthScanner(
        target="https://accounts.google.com",
        protocol="auto",           # "auto" | "oidc" | "oauth2" | "saml"
        judge=judge,               # None = rule-based only
        timeout=15.0,
        verify_tls=True,
    )
    result = await scanner.scan()
    print(f"Protocol  : {result.protocol.value}")
    print(f"Provider  : {result.provider_info.name}")
    print(f"Issuer    : {result.provider_info.issuer}")
    print(f"PKCE req  : {result.provider_info.pkce_required}")
    print(f"Implicit  : {result.provider_info.implicit_flow_enabled}")
    for vuln in result.all_vulns:
        print(f"  [{vuln.severity.value}] {vuln.vuln_id}: {vuln.title}")
        if vuln.cve_id:
            print(f"    CVE: {vuln.cve_id}")

    # --- Passive SAML scan ---
    saml_scanner = AuthScanner(
        target="https://mocksaml.com/api/saml/metadata",
        protocol="saml",
    )
    saml_result = await saml_scanner.scan()
    print(f"SAML entityID : {saml_result.provider_info.issuer}")
    print(f"Signing certs : {saml_result.provider_info.raw.get('signing_cert_count', 0)}")

    # --- Authorized active attack ---
    try:
        attacker = AuthAttacker(authorized=True)
        report = await attacker.attack(
            target="https://auth.example.com",
            mode="safe",           # "safe" | "deep"
            judge=judge,
        )
        print(f"Attacks run     : {report.attacks_run}")
        print(f"Attacks triggered: {report.attacks_triggered}")
        for r in report.triggered_results:
            print(f"  [{r.severity.value}] {r.title}")
            print(f"    Evidence: {r.evidence[:80]}...")
    except AuthorizationRequired:
        print("Pass authorized=True to unlock attack mode")

asyncio.run(main())

See auth.md for the full guide including CVE detail, remediation advice, and SAML testing tips.

---

Python API

import asyncio
from offensive_ai.core.openclaw_scanner import OpenClawScanner
from offensive_ai.core.openclaw_attacker import OpenClawAttacker
from offensive_ai.exceptions import AuthorizationRequired

async def main():
    # Passive scan
    scanner = OpenClawScanner(
        target="192.168.1.10",
        port=18789,
        use_tls=False,
    )
    result = await scanner.scan()

    print(f"OpenClaw detected : {result.openclaw_detected}")
    print(f"Version           : {result.version}")
    print(f"Unauthenticated   : {result.unauthenticated_access}")
    print(f"Vulnerabilities   : {len(result.vulnerabilities)}")
    for v in result.vulnerabilities:
        print(f"  [{v.severity}] {v.advisory_id}: {v.title}")

    # Authorized active attack
    try:
        attacker = OpenClawAttacker(authorized=True)
        report = await attacker.attack(
            target="192.168.1.10",
            port=18789,
            mode="safe",   # "safe" | "deep"
        )
        print(f"Attacks triggered : {len(report.triggered_results)}")
        for r in report.triggered_results:
            print(f"  [{r.severity}] {r.title}")
    except AuthorizationRequired as exc:
        print(exc)

asyncio.run(main())

See openclaw.md for the full guide including remediation advice.

---

Python API

import asyncio
from offensive_ai.core.k8s_scanner import K8sScanner
from offensive_ai.core.k8s_attacker import K8sAttacker
from offensive_ai.core.llm_judge import LLMJudge
from offensive_ai.exceptions import AuthorizationRequired

async def main():
    # Optional LLM judge — auto-detects OPENAI/ANTHROPIC/GEMINI key from env
    judge = LLMJudge()   # rule-based fallback when no key is set

    # Passive scan
    scanner = K8sScanner(
        target="192.168.1.100",
        ports=[6443, 10250, 2379],
        judge=judge,
    )
    result = await scanner.scan()

    print(f"Kubernetes detected : {result.is_kubernetes}")
    print(f"Version             : {result.server_info.git_version}")
    print(f"Exposed components  : {[c.component.value for c in result.exposed_components]}")
    print(f"OWASP coverage      : {result.owasp_coverage}")
    print(f"Vulnerabilities     : {len(result.vulnerabilities)}")
    for v in result.vulnerabilities:
        print(f"  [{v.severity.value}] {v.owasp_id} {v.vuln_id}: {v.title}")
        if v.llm_reasoning:
            print(f"    LLM: {v.llm_reasoning}")

    # Authorized active attack
    try:
        attacker = K8sAttacker(authorized=True, judge=judge)
        report = await attacker.attack(
            target="192.168.1.100",
            mode="safe",           # "safe" | "deep"
            scan_result=result,   # guides attack selection
        )
        print(f"Attacks run       : {len(report.attack_results)}")
        print(f"Succeeded         : {len(report.successful_attacks)}")
        for r in report.successful_attacks:
            print(f"  [{r.severity.value}] {r.owasp_id} {r.attack_id}: {r.description}")
    except AuthorizationRequired as exc:
        print(exc)

asyncio.run(main())

See k8s.md for the full guide including OWASP K8s Top 10 mapping, CVE database, attack sequences, and remediation advice.

---

Component Surface

Component	Default Ports	Key Probes
kube-apiserver	6443, 443, 8080	`/version`, `/healthz`, `/api`, anon `/api/v1/secrets`/`/pods`, `SelfSubjectAccessReview`
kubelet	10250 (rw), 10255 (ro)	`/pods`, `/runningpods`, `/stats/summary`, `/spec`; `/exec` `/run` (attack)
etcd	2379, 2380	`/version`, `/health`, v2/v3 keys
scheduler / controller-mgr	10259 / 10257	`/healthz`, `/metrics`
kube-proxy / cAdvisor	10249 / 4194	`/healthz`, metrics
Dashboard	8001, 30000–32767	UI accessibility, auth posture

Passive scan — probe all default K8s component ports

offensive-ai k8s-scan 192.168.1.100

🇨🇳 中文文档镜像 AI 翻译 2026-07-04

英文原文章节由系统翻译为中文摘要，便于快速理解。完整原文见上方 "📑 README 深度解析"。

📌 简介

offsec-ai 是一个集成了 AI/LLM 能力的进攻性安全工具包（Offensive-Security Toolkit）。该项目结合了 Red-Team 渗透测试思维与最新的 MCP 协议，旨在通过大语言模型增强安全扫描与攻击模拟的智能化程度，为开发者和安全从业者提供高效的自动化安全评估手段。

⚡ 功能介绍

本项目具备强大的 AI 驱动安全能力，支持通过 LLM 进行智能化的语义检测与漏洞判定。核心功能涵盖了��对 OWASP 标准的 AI 扫描、基于 MCP 协议的扫描任务，以及模拟真实攻击场景的 Red-Team 攻击模块。此外，它还支持对 Kubernetes (K8s) 环境进行深度探测与攻击模拟。

📋 环境依赖

运行本项目需要 Python 3.12 或更高版本。若需启用 LLM judge 功能（用于更智能的语义检测），必须配置相应的 API 密钥，支持 OPENAI_API_KEY、ANTHROPIC_API_KEY 或 GEMINI_API_KEY。详细的依赖列表请参考项目中的 requirements.txt 文件。

🛠 安装步骤（Docker/pip/源码）

用户可以通过多种方式进行安装。推荐使用 Docker 进行快速部署，通过 `docker run` 命令即可运行相关扫描任务。若需在本地 Python 环境中使用，可以通过 pip 安装基础版，或使用 `pip install "offsec-ai[ai]"` 来安装包含 AI 功能扩展包的完整版本。

🚀 使用教程

项目提供了灵活的 CLI 命令行界面。用户可以通过命令行执行各类扫描任务，例如使用 `ai-owasp-scan` 进行 AI 驱动的 OWASP 扫描，或使用 `mcp-scan` 进行 MCP 协议扫描。在执行涉及主动攻击的操作时，请务必添加 `--i-have-authorization` 标志以明确授权。

⚙️ 配置说明（含 MCP / env）

项目支持通过环境变量配置 LLM judge 引擎。你可以设置 GEMINI_API_KEY、ANTHROPIC_API_KEY 或 OPENAI_API_KEY。系统会按照优先级自动选择：首选 Gemini，其次是 Anthropic，最后是 OpenAI。通过配置这些 Key，可以实现更精准的漏洞语义识别。

🔌 API 说明

offsec-ai 提供了丰富的 Python API 供开发者集成。你可以通过异步编程方式调用 LLMOwaspScanner、MCPScanner 或 AuthScanner 等核心类。此外，项目也支持通过 kubectl proxy 将 K8s API server 映射到本地，从而实现对集群环境的安全扫描与攻击模拟。

🔄 工作流/模块

项目模块化设计清晰，涵盖了对 kube-apiserver、kubelet 等 Kubernetes 组件的探测能力。工作流支持从被动扫描（Passive scan）指纹与配置错误，到主动探测关键端口（如 6443, 10250）及敏感路径（如 /api/v1/secrets），最终实现全方位的组件表面分析。

🎯 aiskill88 AI 点评 A 级 2026-07-04

功能齐全的网络安全重构工具

📚 实用指南（长尾问题）

适合谁

需要让 Claude / Cursor 操作本地工具的 AI 工程师
构建企业知识库 / RAG 检索应用的团队

最佳实践

配置 MCP 服务器时建议使用 stdio 传输 + JSON-RPC，避免暴露公网
生产部署优先使用 Docker Compose 隔离依赖，并挂载 volume 持久化数据
本地部署优先选 GGUF 量化模型，节省显存并保持响应速度

常见错误

API key 直接提交到 git 仓库（请用 .env 并加入 .gitignore）
MCP 配置路径拼错或权限不足，重启 Claude Desktop 才生效
容器内无法访问宿主机 localhost — 使用 host.docker.internal
显存不足直接 OOM — 优先降低 context 或换更小的量化模型
Python 依赖冲突：建议用 venv / uv 隔离环境

部署方案

Docker：offsec-ai 提供官方镜像，docker compose up 一键启动
CLI：直接 npm install -g / pip install，命令行调用
本地部署：CPU 8GB 起，GPU 推荐 16GB+ 显存
云端托管：可放在 Vercel / Railway / Fly.io 等 PaaS 平台

⚡ 核心功能

开源免费，支持本地部署，数据完全自主可控
活跃的 GitHub 开源社区，持续迭代更新
提供详细文档和使用示例，新手友好
支持自定义配置，灵活适配不同使用环境
可作为基础组件集成进现有技术栈或进行二次开发

👥 适合谁

需要让 Claude / Cursor 操作本地工具的 AI 工程师
构建企业知识库 / RAG 检索应用的团队

⭐ 最佳实践

配置 MCP 服务器时建议使用 stdio 传输 + JSON-RPC，避免暴露公网
生产部署优先使用 Docker Compose 隔离依赖，并挂载 volume 持久化数据
本地部署优先选 GGUF 量化模型，节省显存并保持响应速度

⚠️ 常见错误

API key 直接提交到 git 仓库（请用 .env 并加入 .gitignore）
MCP 配置路径拼错或权限不足，重启 Claude Desktop 才生效
容器内无法访问宿主机 localhost — 使用 host.docker.internal
显存不足直接 OOM — 优先降低 context 或换更小的量化模型

👥 适合人群

AI 技术爱好者研究人员和学生开发者和工程师技术创业者

🎯 使用场景

本地部署运行，保护数据隐私，满足合规要求
自定义集成到现有系统，扩展技术栈能力
作为开源基础组件进行商业化二次开发

⚖️ 优点与不足

✅ 优点

+MIT 协议，可免费商用
+完全开源免费，无授权费用
+本地部署，数据完全自主可控
+开发者社区支持，遇问题可查可问

⚠️ 不足

−安装和初始配置可能需要一定技术基础
−功能完整性通常不如成熟商业产品
−技术支持主要依赖开源社区，响应速度不稳定

⚠️ 使用须知

AI Skill Hub 为第三方内容聚合平台，本页面信息基于公开数据整理，不对工具功能和质量作任何法律背书。

建议在沙箱或测试环境中充分验证后，再部署至生产环境，并做好必要的安全评估。

📄 License 说明

🔗 相关工具推荐

transformers AI技能包

Hugging Face开源的深度学习框架，提供预训练语言模型、视觉模型和多模态模型。集成BERT、GPT、Llama等

ComfyUI 节点式AI图像生成

强大的开源扩散模型可视化工具，提供图形界面、API和后端服务。采用节点图式设计，支持模块化工作流构建，适合AI绘图、图像

llama-cpp AI技能包

高效的大语言模型C/C++推理框架，支持在本地CPU/GPU上运行量化LLM模型，具有内存占用小、推理速度快的特点。适合

yt-dlp 视频下载

功能强大的开源视频下载工具，支持YouTube、TikTok等数千个视频平台，可自动下载视频、字幕、封面和元数据。适合内

📰 相关 AI 新闻

AI 前沿资讯：The fanfiction community is at…

Anthropic Claude 最新进展

AI 资讯 · 知识关联

🍿 AI 圈相关吃瓜

配了5个 MCP 工具，Claude 一个都没用

AI 圈观察

Filesystem MCP 帮 Claude 找文件，找了整个 node_modules

AI 圈观察

把 Karpathy 的经验喂给 Claude，它现在会优雅地拒绝我

🗺️ 相关解决方案

ai-workflow-templates

🧩 你可能还需要

基于当前 Skill 的能力图谱，自动补全的工具组合

natively-cluely-ai-assistant — Claude Skill 中文使用文档

免费开源的AI面试助手，实时转录，隐蔽模式，局部RAG，BYOK。无订阅，防止数据泄露。

LLM安全测试框架，检测prompt注入、越狱等

Arkiv媒体资产管理器

本地优先的媒体资产管理工具，集成AI语义搜索和专业相机元数据读取功能。支持DaVinci Resolve集成，适合视频编辑、摄影师和内容创作

爬虫lama

本地AI代理，通过Ollama回答问题

❓ 常见问题 FAQ

offsec-ai 是什么工具？−

offsec-ai 是一款Python开发的AI辅助工具。开源AI工具：offsec-ai is a Python library and CLI that combines classic network reconnaissan。⭐12 · Python 主要应用场景包括：网络安全重构和渗透测试。

offsec-ai 如何安装和开始使用？+

offsec-ai 是否免费？许可证是什么？+

offsec-ai 适合哪些用户使用？+

offsec-ai 的社区活跃度和项目维护状况如何？+

安装这个工具需要什么基础？+

安装过程中遇到依赖冲突怎么办？+

工具安装成功但运行报错，该怎么处理？+

💡 AI Skill Hub 点评

AI Skill Hub 点评：Offsec-AI 的核心功能完整，质量优秀。对于AI 技术爱好者来说，这是一个值得纳入个人工具库的选择。建议先在非生产环境试用，再逐步推广。

📚 深入学习 Offsec-AI

查看分步骤安装教程和完整使用指南，快速上手这款工具

⚙️ 安装教程 📚 使用教程

🌐 原始信息

原始名称	`offsec-ai`
原始描述	开源AI工具：offsec-ai is a Python library and CLI that combines classic network reconnaissan。⭐12 · Python
Topics	`offensive-securitynetwork-reconnaissancepython3`
GitHub	https://github.com/Htunn/offsec-ai
License	MIT
语言	Python

🔗 原始来源

🐙 GitHub 仓库 https://github.com/Htunn/offsec-ai 🌐 官方网站 https://pypi.org/project/offsec-ai

收录时间：2026-07-04 · 更新时间：2026-07-04 · License：MIT · AI Skill Hub 不对第三方内容的准确性作法律背书。

📺 订阅 AI Skill Hub Daily Telegram 频道

每天 8 条精选 AI Skill、MCP、Agent 与自动化工具推送

加入频道 →