漏洞扫描器(免费版)

概述

漏洞扫描器免费版是一款面向开发者和安全工程师的静态安全分析工具。基于 OWASP Top 10:2025 最新标准,覆盖供应链安全(新增A03)、异常条件处理(新增A10)、密钥检测、代码模式分析等核心检测能力。采用4阶段扫描方法论(侦察/发现/分析/报告),结合CVSS+EPSS双维度风险优先级排序,帮助用户聚焦真正重要的安全风险.

核心能力

OWASP Top 10:2025 检测

处理: 解析OWASP Top 10:2025 检测的输入参数,完成核心逻辑,返回结构化响应. 输出: 返回OWASP Top 10:2025 检测的响应数据,包含状态码、结果和日志.

免费版与专业版对比

处理: 解析免费版与专业版对比的输入参数,完成核心逻辑,返回结构化响应. 输出: 返回免费版与专业版对比的响应数据,包含状态码、结果和日志.

核心功能执行

用input_params参数进行配置.

处理: 解析核心功能执行的输入参数,完成核心逻辑,返回结构化响应. 输出: 返回核心功能执行的响应数据,包含状态码、结果和日志.

• 执行此能力时使用input_params参数,支持创建/查询/导出操作 能力覆盖范围：本skill的核心能力覆盖以下场景关键词：含供应链安全、密钥检测、代码模式分析与风、险优先级排序、核心能力、静态安全分析、供应链安全检查、硬编码密钥与凭证、高危代码模式识别、XSS、反序列化、CVSS、风险优先级排序等。这些关键词对应description中声明的使用场景,均已在上述能力点中提供对应的操作支持.

使用场景

场景一:全面安全扫描

输入格式

# 全量扫描项目
python （请参考skill目录中的脚本文件） /path/to/project
# ...
# 指定扫描类型
python （请参考skill目录中的脚本文件） /path/to/project --scan-type all
python （请参考skill目录中的脚本文件） /path/to/project --scan-type deps
python （请参考skill目录中的脚本文件） /path/to/project --scan-type secrets
python （请参考skill目录中的脚本文件） /path/to/project --scan-type patterns
python （请参考skill目录中的脚本文件） /path/to/project --scan-type config
# ...
# 输出摘要
python （请参考skill目录中的脚本文件） /path/to/project --output summary

场景二:供应链安全检查

# 依赖说明
# 检查项:
# - 依赖包是否来自可信源
# - 锁文件是否已提交
# - CI/CD管道是否有权限控制
# - 是否存在typosquatting(拼写欺骗)
# ...
import json
from pathlib import Path
# ...
class SupplyChainChecker:
    """供应链安全检查器"""
# ...
    KNOWN_TYPOSQUATS = {
        "reqeusts": "requests",
        "nodemon": "nodemon",
        "cross-env": "cross-env",
        "lodash-es": "lodash-es"
    }
# ...
    def check_dependencies(self, project_path):
        """检查依赖安全"""
        findings = []
# ...
        # 检查package-lock.json
        lockfile = Path(project_path) / "package-lock.json"
        if not lockfile.exists():
            findings.append({
                "severity": "MEDIUM",
                "issue": "缺少锁文件(package-lock.json)",
                "fix": "执行 npm install 生成锁文件并提交到版本控制"
            })
# ...
        # 检查requirements.txt
        reqfile = Path(project_path) / "requirements.txt"
        if reqfile.exists():
            with open(reqfile) as f:
                for line in f:
                    package = line.split("==")[0].split(">=")[0].strip().lower()
                    if package in self.KNOWN_TYPOSQUATS:
                            "severity": "HIGH",
                            "issue": f"可能的typosquatting: {package}",
                            "fix": f"检查是否应为: {self.KNOWN_TYPOSQUATS[package]}"
                        })
# ...
        # 检查固定版本
        if reqfile.exists():
            with open(reqfile) as f:
                for line in f:
                    if "==" not in line and line.strip() and not line.startswith("#"):
                            "severity": "MEDIUM",
                            "issue": f"未固定版本: {line.strip()}",
                            "fix": "使用 == 固定版本号"
                        })
# ...
        return findings

场景三:密钥泄露检测

import re
# ...
class SecretDetector:
    """硬编码密钥检测器"""
# ...
    SECRET_PATTERNS = [
        (r"AKIA[0-9A-Z]{16}", "AWS Access Key ID", "CRITICAL"),
        (r"gh[pousr]_[A-Za-z0-9_]{36}", "GitHub Token", "CRITICAL"),
        (r"sk-[A-Za-z0-9]{48}", "OpenAI API Key", "CRITICAL"),
        (r"-----BEGIN.*PRIVATE KEY-----", "Private Key", "CRITICAL"),
        (r"AIza[0-9A-Za-z_\-]{35}", "Google API Key", "HIGH"),
        (r"eyJ[A-Za-z0-9_\-]*\.eyJ[A-Za-z0-9_\-]*\.[A-Za-z0-9_\-]*", "JWT Token", "HIGH"),
        (r"password\s*[:=]\s*['\"][^'\"]{8,}['\"]", "Hardcoded Password", "HIGH"),
        (r"api[_-]?key\s*[:=]\s*['\"][^'\"]{20,}['\"]", "API Key", "HIGH"),
        (r"secret\s*[:=]\s*['\"][^'\"]{16,}['\"]", "Secret", "HIGH"),
        (r"token\s*[:=]\s*['\"][^'\"]{20,}['\"]", "Token", "HIGH"),
    ]
# ...
    def scan_file(self, filepath):
        """扫描文件中的密钥"""
        findings = []
        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
            content = f.read()
            lines = content.split('\n')
# ...
            for line_num, line in enumerate(lines, 1):
                for pattern, name, severity in self.SECRET_PATTERNS:
                    matches = re.finditer(pattern, line, re.IGNORECASE)
                    for match in matches:
                            "file": filepath,
                            "line": line_num,
                            "type": name,
                            "severity": severity,
                            "evidence": match.group()[:50]
                        })
        return findings

场景四:代码模式分析

class CodePatternAnalyzer:
    """高危代码模式分析器"""
# ...
    HIGH_RISK_PATTERNS = {
        "sql_injection": {
            "pattern": r"SELECT.*FROM.*\$\{.*\}|SELECT.*FROM.*%s.*%|SELECT.*FROM.*\+.*",
            "severity": "CRITICAL",
            "description": "SQL注入: 字符串拼接查询"
        },
        "command_injection": {
            "pattern": r"exec\(.*\$\{.*\}|system\(.*input|subprocess\.call\(.*shell=True",
            "severity": "CRITICAL",
            "description": "命令注入: 用户输入直接执行"
        },
        "code_injection": {
            "pattern": r"eval\(.*input|Function\(.*input|setTimeout\(.*input",
            "severity": "CRITICAL",
            "description": "代码注入: 动态代码执行"
        },
        "unsafe_deserialization": {
            "pattern": r"pickle\.loads|yaml\.load\(|unserialize\(|JSON\.parse\(.*input",
            "severity": "HIGH",
            "description": "不安全反序列化"
        },
        "path_traversal": {
            "pattern": r"\.\./\.\./|readFile\(.*input|open\(.*input",
            "severity": "HIGH",
            "description": "路径遍历"
        },
        "xss": {
            "pattern": r"dangerouslySetInnerHTML|innerHTML\s*=.*input|document\.write\(.*input",
            "severity": "HIGH",
            "description": "XSS: 未消毒的HTML渲染"
        },
        "disabled_security": {
            "pattern": r"verify\s*=\s*False|SSL_VERIFY|rejectUnauthorized\s*:\s*false|--insecure",
            "severity": "MEDIUM",
            "description": "安全验证被禁用"
        }
    }
# ...
    def analyze(self, filepath):
        """分析代码模式"""
        findings = []
        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
# ...
            for line_num, line in enumerate(lines, 1):
                for pattern_id, rule in self.HIGH_RISK_PATTERNS.items():
                    if re.search(rule["pattern"], line, re.IGNORECASE):
                            "pattern": pattern_id,
                            "severity": rule["severity"],
                            "file": filepath,
                            "line": line_num,
                            "code": line.strip()[:80],
                            "description": rule["description"]
                        })
        return findings

快速开始

1. 阅读## 核心能力章节了解skill功能
2. 按## 依赖说明配置环境
3. 执行所需能力对应的命令
4. 参考## 错误处理章节处理异常
5. 查看## FAQ解答常见疑问

安全扫描脚本

#!/usr/bin/env python3
"""安全扫描器 - OWASP 2025静态分析"""
# ...
import os
import re
import json
import argparse
from pathlib import Path
from datetime import datetime
# ...
class SecurityScanner:
    """安全扫描器主类"""
# ...
    SKIP_DIRS = {"node_modules", ".git", "dist", "build", "__pycache__", ".venv", "venv"}
    SCAN_EXTENSIONS = {".js", ".ts", ".jsx", ".tsx", ".py", ".java", ".go", ".php", ".rb", ".json", ".yaml", ".yml", ".env"}
# ...
    def __init__(self):
        self.findings = []
        self.files_scanned = 0
# ...
    def scan(self, target_path, scan_type="all"):
        """执行安全扫描"""
        target = Path(target_path)
# ...
        if target.is_file():
            self._scan_file(target, scan_type)
        else:
            for root, dirs, files in os.walk(target):
                dirs[:] = [d for d in dirs if d not in self.SKIP_DIRS]
                for file in files:
                    filepath = Path(root) / file
                    if filepath.suffix in self.SCAN_EXTENSIONS:
                        self._scan_file(filepath, scan_type)
# ...
        return self._generate_report(target_path)
# ...
    def _scan_file(self, filepath, scan_type):
        """扫描单个文件"""
        self.files_scanned += 1
# ...
        if scan_type in ("all", "secrets"):
            detector = SecretDetector()
            self.findings.extend(detector.scan_file(str(filepath)))
# ...
        if scan_type in ("all", "patterns"):
            analyzer = CodePatternAnalyzer()
            self.findings.extend(analyzer.analyze(str(filepath)))
# ...
    def _generate_report(self, target):
        """生成扫描报告"""
        critical = sum(1 for f in self.findings if f.get("severity") == "CRITICAL")
        high = sum(1 for f in self.findings if f.get("severity") == "HIGH")
        medium = sum(1 for f in self.findings if f.get("severity") == "MEDIUM")
# ...
        risk_level = "CRITICAL" if critical > 0 else "HIGH" if high > 0 else "MEDIUM" if medium > 0 else "LOW"
# ...
        return {
            "scan_time": datetime.now().isoformat(),
            "target": str(target),
            "files_scanned": self.files_scanned,
            "risk_level": risk_level,
            "summary": {"CRITICAL": critical, "HIGH": high, "MEDIUM": medium},
            "total_findings": len(self.findings),
            "findings": self.findings
        }
# ...
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="OWASP 2025安全扫描器")
    parser.add_argument("path", help="扫描目标路径")
    parser.add_argument("--scan-type", choices=["all", "deps", "secrets", "patterns", "config"],
                        default="all", help="扫描类型")
    parser.add_argument("--output", choices=["summary", "full", "json"], default="full")
# ...
    args = parser.parse_args()
# ...
    scanner = SecurityScanner()
    report = scanner.scan(args.path, args.scan_type)
# ...
    if args.output == "json":
        print(json.dumps(report, indent=2, ensure_ascii=False))
    elif args.output == "summary":
        print(f"风险等级: {report['risk_level']}")
        print(f"扫描文件: {report['files_scanned']}")
        print(f"发现问题: {report['total_findings']}")
        print(f"  CRITICAL: {report['summary']['CRITICAL']}")
        print(f"  HIGH: {report['summary']['HIGH']}")
        print(f"  MEDIUM: {report['summary']['MEDIUM']}")
    else:
        print(json.dumps(report, indent=2, ensure_ascii=False, default=str))

示例

风险优先级矩阵

风险 = 可能性 × 影响
# ...
高影响 + 高可能性 → CRITICAL (立即修复)
高影响 + 低可能性 → HIGH (优先修复)
低影响 + 高可能性 → MEDIUM (计划修复)
低影响 + 低可能性 → LOW (稍后处理)
# ...
优先级决策树:
是否被积极利用(EPSS > 0.5)?
├── 是 → CRITICAL: 立即行动
└── 否 → 检查CVSS
         ├── CVSS ≥9.0 → HIGH
         ├── CVSS 7.0-8.9 → 考虑资产价值
         └── CVSS <7.0 → 计划稍后修复

严重程度分类

最佳实践

1. 安全专家思维

2. 4阶段扫描方法论

1. 侦察(Reconnaissance)
   ├── 理解技术栈
   ├── 识别入口点
   └── 映射数据流
# ...
2. 发现(Discovery)
   ├── 配置审查
   ├── 依赖分析
   └── 代码模式搜索
# ...
3. 分析(Analysis)
   ├── 消除误报
   ├── 风险评分
   └── 攻击链映射
# ...
4. 报告(Reporting)
   ├── 清晰的复现步骤
   ├── 业务影响分析
   └── 修复指导建议

3. 反模式警示

常见问题

Q1: 静态分析能发现所有漏洞吗?

A: 不能。静态分析专注源代码,无法发现运行时漏洞。需要动态分析(DAST)补充。编译后的二进制文件不适用.

Q2: 如何减少误报?

A: 结合上下文判断。例如 process.env 在配置文件中正常,在传输到外部时则是风险。维护已验证的基线,标记已知的安全模式.

Q3: 扫描速度如何?

A: 100个文件约需5-10秒。大型项目(1000+文件)约需30-60秒。可通过 --scan-type 指定扫描类型加速.

Q4: 如何获取动态扫描和CVE关联?

A: 免费版提供静态分析。专业版增加动态扫描(DAST)、软件组合分析(SCA)、CVE+EPSS数据库关联和CI/CD集成.

依赖说明

运行环境

• Agent平台: 支持SKILL.md的任意AI Agent(Claude Code / Cursor / Codex / Gemini CLI等)
• 操作系统: Windows / macOS / Linux
• Python版本: 3.8+

第三方依赖

API Key 配置

• 免费版无需API Key,所有扫描在本地执行

可用性分类

• 分类: MD+EXEC(纯Markdown指令,部分功能需exec命令行执行)
• 说明: 基于Markdown的AI Skill,通过自然语言指令驱动Agent执行静态安全分析任务

错误处理

已知限制

• 需LLM支持,无LLM环境不可用
• 复杂业务场景建议结合人工经验判断
• 执行效率受模型能力与网络环境影响
• 当前为免费版本,如需完整功能请升级到付费版获取全部能力

输出格式

{
  "success": true,
  "data": {
    "result": "漏洞扫描器(免费版)处理结果",
    "execution_time": "0.5s",
    "metadata": {
      "version": "1.0",
      "processor": "vulnerability scanner"
    }
  },
  "execution_log": ["解析输入参数", "执行核心处理", "格式化输出结果"],
  "error": null
}