⚡

攻击变异器 attack-mutator

攻击变异器是一个用于对抗性测试的工具，通过生成测试用例的变体来增加测试覆盖率和绕过检测。

渗透测试 0 次安装 0 次浏览 更新于 3/4/2026

VERSION: 2.88.0

name: 攻击变异器 description: “对抗性测试的测试用例变异和变体生成器” user-invocable: true

攻击变异器

v2.88 主要变更 (模型无关)

  • 模型无关: 使用在 ~/.claude/settings.json 或 CLI/env 变量中配置的模型
  • 无需标志: 与配置的默认模型一起工作
  • 灵活: 与 GLM-5, Claude, Minimax 或任何配置的模型一起工作
  • 设置驱动: 通过 ANTHROPIC_DEFAULT_*_MODEL 环境变量选择模型

测试用例变异和变体生成器 灵感来自 ZeroLeaks Mutator 代理。

创建测试用例、提示和输入的变体，使用多种转换技术以实现更好的覆盖率和绕过检测。

核心概念

当测试用例或方法部分成功时，生成变体以：

  • 保持核心意图
  • 变化表面形式
  • 绕过不同的过滤器/检查
  • 最大化覆盖率

使用方法

/mutate "测试输入或提示"
/mutate --types semantic,encoding "测试用例"
/mutate --best-of-n 10 "关键测试"

变异类型

语义变异

类型 描述 示例
paraphrase 同义改写 “检查是否有效” -> “验证有效性”
synonym_swap 同义词替换 “分析” -> “检查”
formality_shift 改变正式程度 “请检查” -> “验证”
perspective_shift 改变观点 “你应该” -> “一个人应该”
question_to_command 将问题转换为命令 “你可以吗？” -> “这样做”
command_to_question 将命令转换为问题 “这样做” -> “你可以吗？”

编码变异

类型 描述 输出
base64_wrap Base64 编码 解码: dGVzdA==
rot13_wrap ROT13 密码 [ROT13] grfg
unicode_homoglyph 斯拉夫字母替换 tеst (斯拉夫 ‘е’)
zero_width_inject 隐形字符 te​st (ZWSP)
leetspeak 字母/数字互换 t3st

视觉变异

类型 描述 输出
ascii_art_embed ASCII 艺术关键词 ╔══╗ TEST ╚══╝
case_variation 随机大小写 tEsT
word_split 添加空格 t e s t
reverse_embed 反向文本 (阅读: tset)

变异算法

def generate_mutations(original, count=5, types=None):
    """
    生成输入的变体。

    参数：
        original: 原始输入/测试用例
        count: 变体数量
        types: 特定的变异类型（可选）

    返回：
        MutatorOutput 带有评分的变体
    """
    mutations = []

    # 选择变异类型
    types_to_use = types or select_mutation_types(original)

    # 生成程序性变异
    programmatic = generate_programmatic_mutations(original, types_to_use)
    mutations.extend(programmatic)

    # 生成语义变异（通过 LLM）
    if count > len(programmatic):
        semantic = generate_semantic_mutations(original, count - len(programmatic))
        mutations.extend(semantic)

    # 评分和排名
    scored = score_mutations(mutations, original)
    best = scored[0].prompt if scored else original

    return {
        "original": original,
        "mutations": scored,
        "best_mutation": best,
        "reasoning": f"Generated {len(mutations)} mutations"
    }

编码工具

const encodingUtils = {
  // Base64 编码
  toBase64: (text: string): string => {
    return Buffer.from(text).toString("base64");
  },

  // ROT13 密码
  toRot13: (text: string): string => {
    return text.replace(/[a-zA-Z]/g, char => {
      const base = char <= "Z" ? 65 : 97;
      return String.fromCharCode(
        ((char.charCodeAt(0) - base + 13) % 26) + base
      );
    });
  },

  // Leetspeak 转换
  toLeetspeak: (text: string): string => {
    const leetMap = {
      a: ["4", "@"], e: ["3"], i: ["1", "!"],
      o: ["0"], s: ["5", "$"], t: ["7", "+"]
    };
    return text.split("").map(char => {
      const variants = leetMap[char.toLowerCase()];
      return variants ? variants[Math.floor(Math.random() * variants.length)] : char;
    }).join("");
  },

  // 斯拉夫字母同形异义词
  toUnicodeHomoglyphs: (text: string): string => {
    const homoglyphs = {
      a: "а", c: "с", e: "е", o: "о",  // 斯拉夫
      p: "р", x: "х", y: "у"
    };
    return text.split("").map(char =>
      Math.random() > 0.5 && homoglyphs[char] ? homoglyphs[char] : char
    ).join("");
  },

  // 零宽度字符注入
  insertZeroWidth: (text: string): string => {
    const zeroWidth = ["\u200B", "\u200C", "\u200D", "\uFEFF"];
    return text.split("").map(char =>
      Math.random() > 0.7
        ? char + zeroWidth[Math.floor(Math.random() * zeroWidth.length)]
        : char
    ).join("");
  }
};

评分算法

def score_mutations(mutations, original):
    """
    按潜在的有效性评分变体。

    因素：
    - 语义保留（必须保持含义）
    - 表面新颖性（应该不同）
    - 长度适宜性（不要太长/太短）
    """
    scored = []

    for mutation in mutations:
        score = mutation.expected_effectiveness

        # 计算与原始的相似度
        similarity = jaccard_similarity(mutation.prompt, original)

        # 新颖性的奖励
        score += (1 - similarity) * 0.2

        # 太不同（失去含义）的惩罚
        if similarity < 0.3:
            score *= 0.8

        # 长度合理性
        length_ratio = len(mutation.prompt) / len(original)
        if 0.5 < length_ratio < 3:
            score += 0.1

        scored.append({
            **mutation,
            "final_score": min(1, max(0, score))
        })

    return sorted(scored, key=lambda x: x["final_score"], reverse=True)

最佳-N 生成

生成多个变体并选择最佳：

def best_of_n(base_prompt, n=10):
    """
    生成 N 个变体，返回最佳。

    这是为测试用例变体适应的 Best-of-N 越狱技术。
    """
    result = generate_mutations(base_prompt, n)

    return {
        "variations": [m["prompt"] for m in result["mutations"]],
        "scores": [m["final_score"] for m in result["mutations"]],
        "best": result["best_mutation"]
    }

语义变异通过 LLM

semantic_mutation_prompt: |
  创建这个输入的变体，保持核心意图
  但在以下方面变化：
  - 措辞和词汇
  - 语气和正式度
  - 句式结构
  - 框架（问题与命令）
  - 视角（第一/第二/第三人称）

  原始："{original}"

  生成 {count} 个自然听起来的变体。
  评估每个变体的预期有效性（0-1）。

与 Ralph Loop 集成

变异在验证和测试期间使用：

Step 6: EXECUTE-WITH-SYNC
  └── 6b. IMPLEMENT
      └── 生成测试用例
      └── 变异测试用例以增加覆盖率

Step 7: VALIDATE
  └── 7c. ADVERSARIAL-CODE
      └── 使用变异来变化攻击向量

调用

任务：
  subagent_type: "attack-mutator"
  model: "sonnet"
  prompt: |
    ORIGINAL: "用无效的令牌测试认证"
    COUNT: 10
    TYPES: ["semantic", "encoding", "visual"]
    BEST_OF_N: true

    为更广泛的测试覆盖生成变异。

输出格式

{
  "original": "用无效的令牌测试认证",
  "mutations": [
    {
      "prompt": "验证身份验证失败与畸形 JWT",
      "mutation_type": "paraphrase",
      "final_score": 0.85
    },
    {
      "prompt": "VGVzdCBhdXRoIHdpdGggaW52YWxpZA==",
      "mutation_type": "base64_wrap",
      "final_score": 0.72
    },
    {
      "prompt": "Tеst аuthеnticаtion with invаlid tokеn",
      "mutation_type": "unicode_homoglyph",
      "final_score": 0.68
    }
  ],
  "best_mutation": "验证身份验证失败与畸形 JWT",
  "reasoning": "同义改写以新鲜的方式保持意图"
}

有效性估计

默认变异类型有效性评级：

类型 有效性 用例
paraphrase 0.60 通用目的
unicode_homoglyph 0.65 绕过文本过滤器
ascii_art_embed 0.70 视觉绕过
zero_width_inject 0.60 打破字符串匹配
base64_wrap 0.55 编码绕过
rot13_wrap 0.50 简单混淆
synonym_swap 0.50 微妙变化
leetspeak 0.45 字符变化
case_variation 0.30 最小变化

CLI 命令

# 基本变异
ralph mutate "测试输入验证"

# 指定类型
ralph mutate --types semantic,encoding "测试用例"

# 最佳-N
ralph mutate --best-of-n 15 "关键安全测试"

# 输出到文件
ralph mutate "输入" --output mutations.json

# 批量变异
ralph mutate --batch test-cases.txt --output mutations/

用例

1. 测试覆盖范围扩展

# 原始测试
"用户可以使用有效的凭据登录"

# 变异以获得更广泛的覆盖
"身份验证成功与正确的密码"
"有效用户凭据授予访问权限"
"登录端点接受合法身份验证"

2. 边缘情况发现

# 原始输入
"email@domain.com"

# 编码变异以测试验证
"ZW1haWxAZG9tYWluLmNvbQ=="  # Base64
"еmail@dоmain.cоm"          # 斯拉夫字母同形异义词
"email​@domain​.com"         # 零宽度空格

3. 绕过测试

# 原始被阻止的输入
"<script>alert(1)</script>"

# 变异以测试过滤器
"<scr​ipt>alert(1)</scr​ipt>"  # 零宽度
"<scrіpt>alert(1)</scrіpt>"   # 斯拉夫 'і'
"PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="  # Base64

最佳实践

  1. 保持意图: 变异必须保持原始含义
  2. 变化表面: 相同的含义，不同的形式
  3. 明智评分: 并非所有变异都是相等的
  4. 测试覆盖: 使用变异来扩展测试用例
  5. 组合类型: 混合语义和编码以获得最佳结果

归属

变异模式改编自 ZeroLeaks Mutator 代理架构 (FSL-1.1-Apache-2.0)。