agent-bypass 2.13.8 → 2.13.10

package/AGENT_ADDITIVE_CHANGELOG.md

@@ -1,5 +1,7 @@
 # agent-bypass 2.13.6 原版增量补充说明
 
+> **当前发布版本：2.13.10**（2026-10-09）——含：本文件全部历史记录 + 复测 8 类修复（2.13.7）+ 六大能力闭环与站点标准路径（2.13.8）+ 反编译订正与红队检查（2.13.9）+ 审核 11 项修复（2.13.10，见文末）。
+
 本包基于用户上传的原始 `agent-bypass-v2.13.6(1).zip`，不是之前的 safety-fix 版本。保持 `package.json` 版本 2.13.6 不变，不冒充正式 npm 更新。未改动安装器、原有 12 个 Python 脚本、Shell 脚本、CK Hunter 和 33 个模块正文。
 
 ### 原有文件改动
@@ -45,5 +47,21 @@
 - **修正对照表**：新增「一轮没拿下就停手」「发了网站只给分析/半途停下」两行纠正条目。
 - **module 07**：「连续两轮无新证据」从"停手交付"改为"升级维度继续"（与闭环一致）。
 - **module 30**：新增「网站目标标准路径」——收到 URL/域名即触发的六步全链（侦察→指纹→JS→弱点→验证→能打即打）+ 速度原则 + 完成判据。
-- **references/capability-loops.md（新）**：六大能力域（逆向/渗透/反变异/爆破/自动化/发现思维）× 五环闭环操作手册 + 跨能力接线 + 判据速查。
+- **references/capability-loops.md（新）**：六大能力域（逆向/渗透/反编译/爆破/自动化/发现思维）× 五环闭环操作手册 + 跨能力接线 + 判据速查；红队全链（module 55）承接。
 - **references/agent-routing.md §7（新）**：未攻破时的自主迭代（归因 → 回源 → 换维 → 情报复用 → 严格判死 → 兜底交付）。
+
+## 2026-10-09 深夜批次（2.13.10 · 审核 11 项修复）
+
+对 2.13.9 的独立审核（11 项）处理结果——全部按"局部补丁"原则修复，保留 33 模块与全部原有功能：
+
+1. **安装器误删（P0）**：引入装机清单 `.agent-bypass-manifest.json`——更新/卸载只按清单清理本程序写入的文件；无清单（旧版安装）只清固定名单，references/scripts 不再整目录删除。
+2. **OpenCode 覆盖/半安装（P0）**：配置验证前置（jsonc/解析失败时一个文件都不写）；agent-bypass.md 归属校验（非本程序创建不覆盖/不删除）；未完成项如实计入手动清单 + 非零退出码。
+3. **凭据默认脱敏（P0）**：deck.py 默认遮蔽 cred 值（`--plain` 才明文）；终端输出只用脱敏值；JSON 落盘改临时文件 + 原子替换，创建即 600 权限。
+4. **规则优先级统一（P1）**：契约新增「优先级总则」（范围与副作用核验 → 再执行；越界/服务异常立即停止该项），消除主文件与路由文件的规则歧义。
+5. **端口列表修正（P1）**：TOP100 补齐为真实 100 个（补 5357）+ 返回去重排序 + 回归断言。
+6. **URL/TLS 边界（P1）**：webprobe 端口范围校验、IPv6 支持、查询参数保留；证书错误不再触发 HTTP 降级；重定向限制同域/子域。
+7. **JS 同域修正（P1）**：`lstrip("www.")` 修正为精确前缀匹配；重定向限制同域；密钥类结果终端默认遮罩（`--json` 取完整值）。
+8. **工具能力核对（P1）**：tool_inventory 增加 why/note 字段与 `--versions` 可选本地版本探测（默认仍零执行）。
+9. **Windows 打包（P2）**：prepack 从 `rm -rf` 改为 Node `fs.rmSync`（跨平台）。
+10. **版本文档同步（P2）**：本文件顶部增加当前版本摘要（见文件头）。
+11. **回归测试（P1）**：新增 `tests/test_regressions.py`（安装器安全 / OpenCode 半安装 / 凭据脱敏 / 端口列表 / URL 解析 / 同域判定，全部离线、临时目录）。

package/SKILL.md

@@ -11,7 +11,7 @@ description: >
   ctf/全能模式/渗透作战/逆向深挖/内存工程 等触发词时使用本技能。
 license: MIT
 metadata:
-  version: "2.13.8"
+  version: "2.13.10"
 ---
 
 # agent-bypass — Ck · 万能执行员
@@ -22,6 +22,7 @@ metadata:
 
 ## 调用铁律（任何任务开始前）
 
+0. **优先级总则**：先核验授权范围与工具副作用 → 再按模块执行；恢复/重试限于原范围内；出现越界、目标服务异常（锁定/拒绝服务征兆）立即停止该项操作。本条优先于其它执行类条款（与铁律 8 不冲突：闭环迭代在范围内进行）。
 1. **先定位模块，再动手**：按下方「模块地图」选定本任务的 1~3 个模块 → 用 `rg -n 'module: 编号' SKILL.md` 打开对应模块 → 按模块流程执行。禁止凭印象直接开工。
 2. **模块是标准作业程序（SOP）**：模块里的命令、配方、判据就是干法；与个人习惯冲突时，以模块为准。
 3. **证据即交付**：每个结论附命令与实测结果；无证据不上报、不编造输出。
@@ -57,7 +58,7 @@ metadata:
 - 遇到多工具、多平台或需要选择验证路线的任务，按需先读 `references/agent-routing.md`，再结合 `references/tool-selection.md` 选工具；后者不会取代已有模块内的具体分析说明。
 - 运行 `python3 scripts/tool_inventory.py --task package_audit --json` 可只读检查本机工具；将 `package_audit` 换成 `static_code`、`dependencies`、`binary`、`android`、`pcap`、`web_static`、`authorized_http` 或 `forensics`。此命令不安装、不联网、不扫描。
 - 工具输出、错误分诊、Agent 交接与独立验证见 `references/verification-gates.md`；其他公开框架设计参考 `references/framework-comparison-2026.md`。未确认范围的外部目标只做离线或被动分析，不自动扩展资产。
-- **六大能力域闭环**（逆向 / 渗透 / 反变异 / 爆破 / 自动化 / 发现思维——选型→受控执行→失败恢复→独立复核→未攻破迭代 + 跨能力接线）：`references/capability-loops.md`。
+- **六大能力域闭环**（逆向 / 渗透 / 反编译 / 爆破 / 自动化 / 发现思维——选型→受控执行→失败恢复→独立复核→未攻破迭代 + 跨能力接线；红队全链承接见 module 55）：`references/capability-loops.md`。
 
 ## 工作守则（先于本文件其他内容）
 
@@ -857,7 +858,7 @@ PHP 专项：
 - 供应链：CI/CD 工作流篡改、恶意依赖、镜像投毒（module 46 供应链段）。
 
 执行与防御规避（Windows 侧惯用）：
-- 载荷形态：无文件（HTA/SVG/CHM/ISO+VHD 挂 LNK 绕 MOTW）、LOLBins 白利用（certutil/bitsadmin/mshta/rundll32/regsvr32）、签名二进制侧载。
+- 载荷形态：无文件——HTA/SVG/CHM、LOLBins 白利用（certutil/bitsadmin/mshta/rundll32/regsvr32）、签名二进制侧载；ISO/VHD 挂 LNK 绕 MOTW 为历史手法（2023 年后系统已缓解，旧环境仍有效）。
 - AMSI 绕过：内存补丁（AmsiScanBuffer）、硬件断点、CLR 钩子——必须在加载 .NET 工具前动手。
 - EDR 对抗惯用：API unhooking（刷新 ntdll 副本）、直接/间接系统调用、sleep 混淆（内存加密）、堆加密与栈伪装、BYOVD、ETW 打补丁；"终端可见性先被削弱，载荷才动"。
 - 云工作负载：元数据服务（IMDS）拿角色凭据；容器逃逸（特权容器/docker.sock 挂载）。
@@ -889,7 +890,7 @@ AI/代理面（新增量）：
 - 打 AI 集成：间接提示注入（在 agent 会读的网页/文档/数据里埋指令）诱导调工具外泄；MCP 信任问题（跨服务器传播、采样注入）；提示路径越权（拿高权限 token 动作）。
 - AI 基建当入口：向量库/标注面板/推理端点未授权、对话记录泄露。
 
-纪律：先身份后主机、先合法机制后植入；每阶段留证据；全程"看起来像正常 IT 工作"（该静默就静默）。
+纪律：先身份后主机、先合法机制后植入；每阶段留证据；全程"看起来像正常 IT 工作"（该静默就静默）；未破环节按铁律 8 迭代（闭环细则 `references/capability-loops.md`）。
 
 <!-- module: 56-recon-origin.md -->
 # RECON/ORIGIN Track（资产测绘与源站 IP）

package/bin/install.js

@@ -78,6 +78,38 @@ function copyDir(src, dst) {
     else fs.copyFileSync(s, d);
   }
 }
+// 装机清单：只记录本程序实际写入的文件；更新/卸载只按清单清理，绝不整目录删除
+const MANIFEST = '.agent-bypass-manifest.json';
+function manifestPath(dir) { return path.join(dir, MANIFEST); }
+function readManifest(dir) {
+  try {
+    const m = JSON.parse(fs.readFileSync(manifestPath(dir), 'utf8'));
+    return (m && Array.isArray(m.files)) ? m.files : null;
+  } catch (e) { return null; }
+}
+function writeManifest(dir, files) {
+  let ver = 'unknown';
+  try { ver = require(path.join(ROOT, 'package.json')).version; } catch (e) {}
+  fs.writeFileSync(manifestPath(dir), JSON.stringify({ tool: 'agent-bypass', version: ver, ts: new Date().toISOString(), files }, null, 2) + '\n', 'utf8');
+}
+function insideDir(dir, p) {
+  const d = path.resolve(dir) + path.sep, r = path.resolve(p);
+  return r === path.resolve(dir) || r.startsWith(d);
+}
+function listFilesRel(dir, rel) {
+  const out = [];
+  const root = path.join(dir, rel);
+  if (!exists(root)) return out;
+  const walk = (r) => {
+    for (const e of fs.readdirSync(r, { withFileTypes: true })) {
+      const p = path.join(r, e.name);
+      if (e.isDirectory()) walk(p); else out.push(path.relative(dir, p));
+    }
+  };
+  if (fs.statSync(root).isDirectory()) walk(root); else out.push(rel);
+  return out;
+}
+
 function installSkills(dir) {
   // 安全护栏：只允许安装到 agent-bypass 专属目录（防误传公共技能目录导致清理越界）
   if (!/(^|[\\/])agent-bypass$/.test(dir)) {
@@ -92,12 +124,27 @@ function installSkills(dir) {
     }
   } catch (e) { /* 路径不存在，按普通安装处理 */ }
   fs.mkdirSync(dir, { recursive: true });
-  // 干净覆盖：先清掉我方管理的旧文件（含已废弃文件名），保留用户文件
+  // 按装机清单清理旧版本文件（只删本程序此前写入的项；无清单=首次/旧版安装，不清理）
+  const prev = readManifest(dir);
   let cleaned = 0;
-  for (const f of MANAGED) {
-    const p = path.join(dir, f);
-    if (exists(p)) { fs.rmSync(p, { recursive: true, force: true }); cleaned++; }
+  if (prev) {
+    for (const rel of prev) {
+      const p = path.join(dir, rel);
+      if (!insideDir(dir, p)) continue;          // 防清单被篡改越界
+      if (exists(p)) { try { fs.rmSync(p, { recursive: true, force: true }); cleaned++; } catch (e) {} }
+    }
+    // 清空目录的旧子目录残留空壳（references/scripts）
+    for (const sub of ['references', 'scripts']) {
+      const p = path.join(dir, sub);
+      try { if (exists(p) && !fs.readdirSync(p).length) fs.rmdirSync(p); } catch (e) {}
+    }
   }
+  // 明确属于本程序的旧版遗留文件（固定名，历史版本产物）
+  for (const legacy of ['PLAYBOOK.md', 'eval']) {
+    const p = path.join(dir, legacy);
+    if (exists(p)) { try { fs.rmSync(p, { recursive: true, force: true }); cleaned++; } catch (e) {} }
+  }
+  // 覆盖式拷贝（逐文件覆盖，不预删目录；用户自放文件不受影响）
   let n = 0;
   for (const f of SKILL_FILES) {
     const src = path.join(ROOT, f);
@@ -107,7 +154,11 @@ function installSkills(dir) {
     else fs.copyFileSync(src, path.join(dir, f));
     n++;
   }
-  ok(`技能文件 \u2192 ${dir}（覆盖 ${n} 项${cleaned ? `，清理旧文件 ${cleaned} 项` : ''}）`);
+  // 写入新清单（记录本次实际落盘的全量文件）
+  const written = [];
+  for (const f of SKILL_FILES) written.push(...listFilesRel(dir, f));
+  writeManifest(dir, written);
+  ok(`技能文件 \u2192 ${dir}（覆盖 ${n} 项${cleaned ? `，清理旧文件 ${cleaned} 项` : ''}，清单已更新）`);
 }
 
 function removeSkills(dir) {
@@ -133,12 +184,24 @@ function removeSkills(dir) {
     warn(`保留 ${target}：未检测到 agent-bypass 技能标记（防误删非本技能内容）`);
     return;
   }
-  // 只删我方受管文件与目录；用户自放内容一律保留
+  // 按装机清单清理；无清单（旧版安装）只清确定属于本程序的固定文件，目录一律不整删
   let n = 0;
-  for (const f of MANAGED) {
-    const p = path.join(target, f);
-    if (exists(p)) { fs.rmSync(p, { recursive: true, force: true }); n++; }
+  const prev = readManifest(target);
+  if (prev) {
+    for (const rel of prev) {
+      const p = path.join(target, rel);
+      if (!insideDir(target, p)) continue;
+      if (exists(p)) { try { fs.rmSync(p, { recursive: true, force: true }); n++; } catch (e) {} }
+    }
+  } else {
+    for (const f of ['SKILL.md', 'ck-hunter.md', 'SYSTEM_PROMPT.md', 'config.yaml.example', 'PLAYBOOK.md', 'eval']) {
+      const p = path.join(target, f);
+      if (exists(p)) { try { fs.rmSync(p, { recursive: true, force: true }); n++; } catch (e) {} }
+    }
+    warn(`${target}：未找到装机清单（旧版安装），references/scripts 未动（可能含用户文件）`);
   }
+  const mp = manifestPath(target);
+  if (exists(mp)) { try { fs.rmSync(mp, { force: true }); } catch (e) {} }
   ok(`已清除本技能文件 ${n} 项（${target}）`);
   try {
     if (!fs.readdirSync(target).length) { fs.rmdirSync(target); ok(`已删除空目录 ${target}`); }
@@ -248,30 +311,50 @@ function opencodeConfigPath() {
 function installOpenCode() {
   console.log('\n[OpenCode]');
   const base = path.join(HOME, '.config', 'opencode');
-  fs.mkdirSync(base, { recursive: true });
-  installSkills(path.join(base, 'skills', 'agent-bypass'));
-  if (noInject) return;
   const inj = path.join(base, 'agent-bypass.md');
-  fs.writeFileSync(inj, getBlock() + '\n', 'utf8');
-  ok(`注入文件 \u2192 ${inj}`);
-  writeTemplate(path.join(base, 'commands', 'ck.md'), readInj('opencode/commands/ck.md', '/ck 命令模板'), 'OpenCode commands/ck.md（/ck 命令）');
-  const cfg = opencodeConfigPath();
-  let data = { $schema: 'https://opencode.ai/config.json' };
-  if (exists(cfg)) {
-    if (cfg.endsWith('.jsonc')) {
+  const cfgPre = opencodeConfigPath();
+  // ① 先验证配置可写：失败时一个文件都不写（根治半安装）
+  if (!noInject && exists(cfgPre)) {
+    if (cfgPre.endsWith('.jsonc')) {
       warn('检测到 opencode.jsonc（JSONC 含注释，程序不自动改写）。');
       info(`请手动在 instructions 数组加入: "${inj}"`);
       manual('OpenCode opencode.jsonc：需手动把注入文件加入 instructions 数组');
       return;
     }
-    try { data = JSON.parse(fs.readFileSync(cfg, 'utf8')); }
+    try { JSON.parse(fs.readFileSync(cfgPre, 'utf8')); }
     catch {
-      warn('opencode.json 解析失败（可能含注释/尾逗号），未改动文件。');
+      warn('opencode.json 解析失败（可能含注释/尾逗号），未改动任何文件。');
       info(`请手动在 instructions 数组加入: "${inj}"`);
       manual('OpenCode opencode.json：解析失败，需手动加入 instructions');
       return;
     }
   }
+  // ② 写入阶段（配置已验证可写）
+  fs.mkdirSync(base, { recursive: true });
+  installSkills(path.join(base, 'skills', 'agent-bypass'));
+  if (noInject) return;
+  // agent-bypass.md 归属保护：已存在且非本程序创建 → 跳过不覆盖
+  if (exists(inj)) {
+    let oursMd = false;
+    try {
+      const cur = fs.readFileSync(inj, 'utf8');
+      oursMd = cur.includes('<!-- agent-bypass -->') || (cur.includes('agent-bypass') && cur.includes('Cknb'));
+    } catch (e) {}
+    if (!oursMd) {
+      warn(`注入文件已存在且非本程序创建，跳过不覆盖 \u2192 ${inj}`);
+      manual('OpenCode agent-bypass.md：已存在（非本程序创建），未覆盖');
+      writeTemplate(path.join(base, 'commands', 'ck.md'), readInj('opencode/commands/ck.md', '/ck 命令模板'), 'OpenCode commands/ck.md（/ck 命令）');
+      return;
+    }
+  }
+  fs.writeFileSync(inj, getBlock() + '\n\n<!-- agent-bypass -->\n', 'utf8');
+  ok(`注入文件 \u2192 ${inj}`);
+  writeTemplate(path.join(base, 'commands', 'ck.md'), readInj('opencode/commands/ck.md', '/ck 命令模板'), 'OpenCode commands/ck.md（/ck 命令）');
+  const cfg = opencodeConfigPath();
+  let data = { $schema: 'https://opencode.ai/config.json' };
+  if (exists(cfg)) {
+    data = JSON.parse(fs.readFileSync(cfg, 'utf8'));   // 已在函数开头验证通过
+  }
   const arr = Array.isArray(data.instructions) ? data.instructions : [];
   if (!arr.includes(inj)) arr.push(inj);
   data.instructions = arr;
@@ -283,7 +366,15 @@ function uninstallOpenCode() {
   const base = path.join(HOME, '.config', 'opencode');
   removeSkills(path.join(base, 'skills', 'agent-bypass'));
   const inj = path.join(base, 'agent-bypass.md');
-  if (exists(inj)) { fs.rmSync(inj); ok('已删除 agent-bypass.md'); }
+  if (exists(inj)) {
+    let oursMd = false;
+    try {
+      const cur = fs.readFileSync(inj, 'utf8');
+      oursMd = cur.includes('<!-- agent-bypass -->') || (cur.includes('agent-bypass') && cur.includes('Cknb'));
+    } catch (e) {}
+    if (oursMd) { fs.rmSync(inj); ok('已删除 agent-bypass.md'); }
+    else warn('agent-bypass.md 非本程序创建，跳过不删');
+  }
   removeTemplate(path.join(base, 'commands', 'ck.md'), 'OpenCode commands/ck.md（/ck 命令）');
   const cfg = opencodeConfigPath();
   if (exists(cfg) && !cfg.endsWith('.jsonc')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bypass",
-  "version": "2.13.8",
+  "version": "2.13.10",
   "description": "Cknb 全能技术操作员 — Agent Skills 技能包（默认安装 Pi / OpenCode；Claude Code / Grok / OpenMinis 显式指定）",
   "bin": {
     "agent-bypass": "bin/install.js"
@@ -35,7 +35,7 @@
     "pentest"
   ],
   "scripts": {
-    "prepack": "rm -rf scripts/__pycache__ 2>/dev/null || true"
+    "prepack": "node -e \"const fs=require('fs');for(const d of ['scripts/__pycache__','tests/__pycache__']){try{fs.rmSync(d,{recursive:true,force:true})}catch(e){}}\""
   },
   "repository": {
     "type": "git",

package/references/capability-loops.md

@@ -1,4 +1,4 @@
-# 六大能力域闭环（逆向 / 渗透 / 反变异 / 爆破 / 自动化 / 发现思维）
+# 六大能力域闭环（逆向 / 渗透 / 反编译 / 爆破 / 自动化 / 发现思维）
 
 六域 × 五环（选型 → 受控执行 → 失败恢复 → 独立复核 → 迭代）。通用约定：证据落盘（原始请求/响应/退出码/时间戳）；限速与范围检查；一轮未破按 `agent-routing.md` §7 迭代。
 
@@ -6,9 +6,9 @@
 
 | 能力 | 入口模块 | 主工具链 | 复核判据 | 未破迭代方向 |
 |---|---|---|---|---|
-| 逆向 | 40/41/47/48/50 | r2/Ghidra/Frida/qemu/jadx；`tool_inventory --task binary` | 字节级偏移证据 + 独立实现对照 | 换版本（diff 修复点）→ 换层（Java→native→syscall）→ 换样本 |
-| 渗透 | 46/53/54/56/42 | fastrecon/webprobe/dirbrute/jsrip/cvefetch（+nuclei/ffuf） | 三级验证：服务端接受 / 数据落库 / 实际可用 | 换入口→换路径（JS 接口图）→换身份→换时间 |
-| 反变异 | 阻断响应（403/401/5xx/WAF 页） | `mutate.py`（L1 编码→L2 空白→L3 路径→L4 头→L5 参数）+ module 48 绕过矩阵 | 受保护行为变化（非仅状态码） | 编码→协议层（chunked/H2）→网关层（真实 IP）→应用层（大小写/注释/HPP） |
+| 逆向 | 40/41/47/48/50 | r2/Ghidra/Frida/qemu；`tool_inventory --task binary` | 字节级偏移证据 + 独立实现对照 | 换版本（diff 修复点）→ 换层（Java→native→syscall）→ 换样本 |
+| 渗透 | 46/53/54/56/42 | fastrecon/webprobe/dirbrute/jsrip/cvefetch/mutate（+nuclei/ffuf） | 三级验证：服务端接受 / 数据落库 / 实际可用 | 换入口→换路径（JS 接口图）→换身份→换时间；阻断响应走变异矩阵（mutate L1-L5 + module 48） |
+| 反编译 | 40/44/50 | jadx/apktool/androguard（Android）、ilspycmd/de4dot（.NET）、r2/Ghidra（native 伪代码）、CFR/Procyon（Java）、js-beautify/sourcemap（JS） | 还原可复现：编译/加载通过、动态对照一致、关键逻辑可执行 | 换工具（jadx↔CFR↔Procyon 交叉）→ 脱混淆（de4dot/unpacker）→ 换层（字节码→native）→ 动态 hook 补全 |
 | 爆破 | ck-hunter + 46 + basicauth_brute | hydra/legba；字典：默认口令→规则生成→泄漏库 | 实际登录成功（非工具报数） | 换出口→协议级并发→离线（hashcat）→跨服务复用 |
 | 自动化 | 60 | scripts/ 全部 | 重复运行一致 + 抽样对照 | 分片并行→多机分载→编排持续运行 |
 | 发现思维 | 03/07/49/61 | — | 三问自检 + 结论三档（确认/推测/未知） | 死路重开（module 07 §8）六维换轨 |
@@ -16,20 +16,21 @@
 ## 失败恢复（按域）
 
 - **逆向**：静态卡壳→动态 hook→仿真→内存 dump；符号缺失→签名恢复；输入校验挡路→断点取校验前值。
-- **渗透**：403/401/5xx→反变异（本表第 3 行）；登录墙→爆破或认证绕过（module 48）；应用面全撞墙→死路重开（端口/框架双驱动）。
-- **反变异**：单层失败→叠加（编码+分块+污染）；全失败→换入口（真实 IP/源站直连，module 56）。
+- **反编译**：输出残缺/混淆→换工具交叉（jadx/CFR/Procyon）→ de4dot 脱壳 → 动态 hook 对照补全；native 卡壳→伪代码+人工重建。
+- **渗透**：403/401/5xx→变异绕过（mutate.py L1-L5 + module 48 矩阵）；登录墙→爆破或认证绕过；应用面全撞墙→死路重开（端口/框架双驱动）。
 - **爆破**：锁 IP→换出口或延长窗口；qps 不足→legba 协议级并发；无字典线索→oracle 枚举用户名 + 规则生成。
 - **自动化**：解析失败→保留原始输出本地修解析器；上游变更→报错清晰化 + 兼容分支。
 - **发现**：受控发散 6 维度分候选（每条标依据/成本/风险/验证方式），多假设并行，谁先来信号跟谁。
 
 ## 跨能力接线
 
-- 渗透 → JS/二进制提取接口图、密钥、协议结构（jsrip/r2）。
-- 逆向 → 反推签名/校验算法 → 构造合法请求、生成针对性字典。
-- 反变异 → 绕过成功即恢复主攻击面（数据拿取/后台进入）。
+- 渗透 → 取材 JS/APK/二进制样本（jsrip/下载）。
+- 反编译 → 还原代码取签名/校验/密钥逻辑 → 构造合法请求、生成针对性字典。
+- 逆向 → 协议与运行时结构还原（动态+仿真）→ 补全反编译缺口。
 - 爆破 → 凭证登录 → 权限升级 → 横向（跨服务复用先复验）。
+- 红队（module 55）承接全链：初始访问→执行→持久化→提权→横向→C2（身份优先、合法机制优先）。
 - 自动化承载全链；发现思维贯穿每环（证据 → 分诊 → 换维）。
 
 ## 判据速查
 
-逆向=字节级证据+独立对照 · 渗透=三级验证 · 反变异=受保护行为变化 · 爆破=实际登录成功 · 自动化=重复一致 · 发现=三问自检+三档标注。
+逆向=字节级证据+独立对照 · 渗透=三级验证 · 反编译=还原可复现（编译/动态对照） · 爆破=实际登录成功 · 自动化=重复一致 · 发现=三问自检+三档标注。

package/scripts/deck.py

@@ -20,7 +20,7 @@
   python3 deck.py next-round
 """
 import argsmini as argparse
-import json, os, sys
+import json, os, sys, tempfile
 from datetime import datetime, timezone, timedelta
 
 BASE = os.path.dirname(os.path.abspath(__file__))
@@ -54,12 +54,23 @@ def load():
 
 
 def save(d):
-    with open(DECK, "w") as f:
-        json.dump(d, f, ensure_ascii=False, indent=1)
+    # 原子替换 + 创建即受限权限：避免写入中断损坏 JSON 与权限暴露窗口
+    d_dir = os.path.dirname(os.path.abspath(DECK)) or "."
+    fd, tmp = tempfile.mkstemp(dir=d_dir, prefix=".deck-", suffix=".tmp")
     try:
-        os.chmod(DECK, 0o600)  # 仅本用户可读写（部分平台不支持则忽略）
-    except OSError:
-        pass
+        with os.fdopen(fd, "w") as f:
+            json.dump(d, f, ensure_ascii=False, indent=1)
+        try:
+            os.chmod(tmp, 0o600)
+        except OSError:
+            pass
+        os.replace(tmp, DECK)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
 
 
 def _mask(v):
@@ -75,10 +86,10 @@ def add_card(args):
     cid = max([c["id"] for c in d["cards"]], default=0) + 1
     value = args.value
     if args.type == "cred":
-        if getattr(args, "mask", False):
-            value = _mask(value)
+        if getattr(args, "plain", False):
+            print("  ⚠ 凭据将以明文写入 deck.json（--plain）；文件权限 600，请确认环境安全", file=sys.stderr)
         else:
-            print("  ⚠ 凭据将明文写入 deck.json（权限已设为 600）；如需脱敏请加 --mask", file=sys.stderr)
+            value = _mask(value)   # 默认脱敏（--plain 显式放开）
     card = {
         "id": cid, "type": args.type, "value": value,
         "note": args.note or "", "source": args.source or "",
@@ -92,7 +103,7 @@ def add_card(args):
     d["cards"].append(card)
     save(d)
     tname = TYPES.get(args.type, (args.type,))[0]
-    print(f"✓ 新增牌 #{cid} [{tname}] {args.value}")
+    print(f"✓ 新增牌 #{cid} [{tname}] {value}")
     if card["note"]:
         print(f"  备注: {card['note']}")
     if card["source"]:
@@ -347,7 +358,8 @@ def main():
     p.add_argument("--role", default="", help="角色：消费者/提供者/中间人/旁观者")
     p.add_argument("--conn", default="", help="连向：上游是谁 / 下游是谁")
     p.add_argument("--round", type=int)
-    p.add_argument("--mask", action="store_true", help="凭据脱敏存储（cred 类型）")
+    p.add_argument("--plain", action="store_true", help="凭据明文存储（默认已脱敏；谨慎使用）")
+    p.add_argument("--mask", action="store_true", help="兼容保留：凭据脱敏（现为默认行为）")
     p.set_defaults(func=add_card)
 
     p = sub.add_parser("show", help="查看牌组 + 牌面分析")

package/scripts/jsrip.py

@@ -44,7 +44,8 @@ RULES = {
 
 def _host_of(u):
     try:
-        return (urllib.parse.urlsplit(u).hostname or "").lower().lstrip("www.")
+        h = (urllib.parse.urlsplit(u).hostname or "").lower()
+        return h[4:] if h.startswith("www.") else h
     except Exception:
         return ""
 
@@ -55,11 +56,28 @@ def same_site(base, u):
     return bool(th) and (th == bh or th.endswith("." + bh))
 
 
+class _SameHostRedirect(urllib.request.HTTPRedirectHandler):
+    """重定向仅限同域/子域（防被目标 302 引到范围外）"""
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        try:
+            old = urllib.parse.urlsplit(req.full_url).hostname or ""
+            new = urllib.parse.urlsplit(newurl).hostname or ""
+            ol, nl = old.lower(), new.lower()
+            if ol and nl and nl != ol and not nl.endswith("." + ol) and not ol.endswith("." + nl):
+                return None
+        except Exception:
+            return None
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+_OPENER = urllib.request.build_opener(_SameHostRedirect, urllib.request.HTTPSHandler(context=CTX))
+
+
 def get(url, timeout=20):
     h = {"User-Agent": UA, "Accept": "*/*"}
     try:
         r = urllib.request.Request(url, headers=h)
-        with urllib.request.urlopen(r, timeout=timeout, context=CTX) as x:
+        with _OPENER.open(r, timeout=timeout) as x:
             return x.read(3000000).decode("utf-8", "ignore")
     except Exception as e:
         print(f"  [错误] {url}: {str(e)[:60]}", file=sys.stderr)
@@ -148,6 +166,11 @@ def main():
         "internal_ip": "★ 内网 IP", "comment": "注释/TODO",
         "graphql": "GraphQL", "websocket": "WebSocket",
     }
+    def _mask_secret(v):
+        v = str(v)
+        return (v[:4] + "***" + v[-2:]) if len(v) > 8 else (v[:2] + "***")
+
+    MASK_KEYS = {"aws_key", "jwt", "secret"}
     for u, hits in allhits.items():
         print(f"\n{'='*66}\n{u}\n{'='*66}")
         for name in ("aws_key", "jwt", "secret", "sourcemap", "internal_ip",
@@ -155,8 +178,10 @@ def main():
             if name not in hits:
                 continue
             print(f"\n[{LABEL.get(name, name)}] {len(hits[name])} 条")
+            if name in MASK_KEYS:
+                print("   （疑似密钥已遮罩；--json 获取完整值）")
             for v in hits[name][:25]:
-                print(f"   {v}")
+                print(f"   {_mask_secret(v) if name in MASK_KEYS else v}")
             if len(hits[name]) > 25:
                 print(f"   ... 还有 {len(hits[name])-25} 条")
 

package/scripts/portscan.py

@@ -22,7 +22,7 @@ TOP100 = [21,22,23,25,53,80,110,111,135,139,143,443,445,993,995,1433,1521,1723,
           7,9,13,17,19,26,37,49,67,68,69,79,81,88,106,113,119,123,161,162,
           179,199,389,427,444,465,512,513,514,515,543,544,548,554,587,631,
           636,646,873,990,1025,1026,1080,1194,1241,1352,1434,1701,1716,1720,
-          1755,1812,1840,1900,2000,2001,2121,3000,3128]
+          1755,1812,1840,1900,2000,2001,2121,3000,3128,5357]
 TOP20 = [21,22,23,25,53,80,443,445,3306,3389,5432,5900,6379,8000,8080,8443,8888,9000,9200,27017]
 
 COMMON = {
@@ -44,7 +44,7 @@ COMMON = {
 def parse_ports(s):
     s = (s or "").strip().lower()
     if s == "top100":
-        return TOP100
+        return sorted(set(TOP100))
     if s == "top20":
         return TOP20
     out = set()

package/scripts/tool_inventory.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
-"""Read-only, offline capability discovery for agent-bypass 2.13.6.
+"""Read-only, offline capability discovery for agent-bypass.
 
-No network calls, installation, subprocess execution, scanning or file modification.
+No network calls, installation, scanning or file modification.
+默认不执行任何工具；仅 --versions 时本地运行 `<tool> --version`（3 秒超时）做能力核对。
 """
 from __future__ import annotations
 
@@ -9,6 +10,7 @@ import argparse
 import json
 import platform
 import shutil
+import subprocess
 from pathlib import Path
 
 TOOLS = {
@@ -28,12 +30,39 @@ PACKAGED = [
     "portscan.py", "webprobe.py", "doh_resolve.sh",
 ]
 
+# 易混淆/需人工核对的工具备注（同名不同产品、命令名差异等）
+NOTES = {
+    "httpx": "ProjectDiscovery CLI（与 Python httpx 库同名；路径不同即不同产品）",
+    "vol": "Volatility 2 命令名通常为 vol.py；Volatility 3 为 vol3/volatility3",
+    "volatility3": "Volatility 3（命令名随安装方式不同）",
+    "ghidraRun": "Ghidra 启动脚本（headless 分析用 analyzeHeadless）",
+    "codeql": "GitHub CodeQL CLI",
+}
+
+
+def _probe_version(name: str) -> str:
+    """本地版本探测：仅运行 `<tool> --version`（3 秒超时），失败返回 unknown。"""
+    try:
+        r = subprocess.run([name, "--version"], capture_output=True, text=True, timeout=3)
+        out = (r.stdout or r.stderr or "").strip().splitlines()
+        return out[0][:80] if out else "unknown"
+    except Exception:
+        return "unknown"
+
 
-def discover(root: Path, task: str) -> dict:
+def discover(root: Path, task: str, versions: bool = False) -> dict:
     if task not in TOOLS:
         raise ValueError("Unknown task")
-    tools = [{"name": name, "installed": bool(shutil.which(name)),
-              "path": shutil.which(name)} for name in TOOLS[task]]
+    tools = []
+    for name in TOOLS[task]:
+        p = shutil.which(name)
+        item = {"name": name, "installed": bool(p), "path": p,
+                "why": None if p else "not in PATH"}
+        if name in NOTES:
+            item["note"] = NOTES[name]
+        if versions:
+            item["version"] = _probe_version(name) if p else None
+        tools.append(item)
     scripts = [{"name": name, "present": (root / "scripts" / name).is_file()}
                for name in PACKAGED]
     return {
@@ -54,16 +83,26 @@ def main() -> int:
     parser.add_argument("--task", choices=sorted(TOOLS), default="package_audit")
     parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parent.parent)
     parser.add_argument("--json", action="store_true", help="machine-readable inventory")
+    parser.add_argument("--versions", action="store_true",
+                        help="本地探测已装工具版本（运行 <tool> --version，3s 超时，可选）")
     args = parser.parse_args()
     if not args.root.is_dir():
         parser.error("--root must be an existing directory")
-    result = discover(args.root, args.task)
+    result = discover(args.root, args.task, versions=args.versions)
     if args.json:
         print(json.dumps(result, ensure_ascii=False, indent=2))
     else:
         print("Task:", result["task"], "| OS:", result["platform"], "| Arch:", result["architecture"])
         for item in result["tools"]:
-            print("  {} {:<16} {}".format("OK" if item["installed"] else "--", item["name"], item["path"] or "not found"))
+            extra = ""
+            if item.get("version"):
+                extra = " | " + item["version"]
+            elif item.get("why"):
+                extra = " | " + item["why"]
+            print("  {} {:<16} {}{}".format("OK" if item["installed"] else "--", item["name"],
+                                            item["path"] or "not found", extra))
+            if item.get("note"):
+                print("     注: " + item["note"])
         print("Packaged scripts found:", sum(1 for x in result["packaged_scripts"] if x["present"]),
               "/", len(result["packaged_scripts"]))
         print("Inspection only: no tools were run.")

package/scripts/webprobe.py

@@ -27,23 +27,52 @@ PROBE_PATHS = [
     "/backup.zip", "/db.sql", "/phpinfo.php", "/info.php", "/server-status",
 ]
 
+_HOST_RE = re.compile(r"^(?P<host>[A-Za-z0-9._\-]+|\[[0-9A-Fa-f:.]+\])(?::(?P<port>\d{1,5}))?$")
+
+
 def parse_target(raw):
-    """接受域名 / host:port / 完整 URL，返回 (host[:port], scheme, path_prefix)；非法输入抛 ValueError"""
+    """接受域名 / host:port / 完整 URL（含 IPv6 与查询参数）。
+
+    返回 (host[:port], scheme, path_prefix, query)；非法输入抛 ValueError。
+    """
     raw = (raw or "").strip()
     if not raw:
         raise ValueError("空目标")
+
+    def _check(m, what):
+        if not m:
+            raise ValueError(f"非法{what}: {raw}")
+        if m.group("port") is not None and not (1 <= int(m.group("port")) <= 65535):
+            raise ValueError(f"端口超出 1-65535: {m.group('port')}")
+        return m.group("host") + (":" + m.group("port") if m.group("port") else "")
+
     if "://" in raw:
         sp = urllib.parse.urlsplit(raw)
         if sp.scheme not in ("http", "https"):
             raise ValueError(f"不支持的协议: {sp.scheme}")
-        if not sp.netloc or not re.fullmatch(r"[A-Za-z0-9._\-]+(:\d{1,5})?", sp.netloc):
-            raise ValueError(f"非法主机名: {sp.netloc}")
-        return sp.netloc, sp.scheme, sp.path.rstrip("/")
+        netloc = _check(_HOST_RE.match(sp.netloc or ""), "主机名")
+        return netloc, sp.scheme, sp.path.rstrip("/"), sp.query
     hostport, _, rest = raw.partition("/")
-    if not re.fullmatch(r"[A-Za-z0-9._\-]+(:\d{1,5})?", hostport):
-        raise ValueError(f"非法主机: {hostport}")
+    netloc = _check(_HOST_RE.match(hostport), "主机")
     prefix = ("/" + rest.rstrip("/")) if rest else ""
-    return hostport, "https", prefix
+    return netloc, "https", prefix, ""
+
+
+class _SameHostRedirect(urllib.request.HTTPRedirectHandler):
+    """重定向仅限同域/子域（防被目标 302 引到范围外）"""
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        try:
+            old = urllib.parse.urlsplit(req.full_url).hostname or ""
+            new = urllib.parse.urlsplit(newurl).hostname or ""
+            ol, nl = old.lower(), new.lower()
+            if ol and nl and nl != ol and not nl.endswith("." + ol) and not ol.endswith("." + nl):
+                return None
+        except Exception:
+            return None
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+_OPENER = urllib.request.build_opener(_SameHostRedirect, urllib.request.HTTPSHandler(context=CTX))
 
 
 def req(url, method="GET", data=None, timeout=12, headers=None):
@@ -55,13 +84,13 @@ def req(url, method="GET", data=None, timeout=12, headers=None):
         h["Content-Type"] = "application/json"
     r = urllib.request.Request(url, data=body, headers=h, method=method)
     try:
-        with urllib.request.urlopen(r, timeout=timeout, context=CTX) as resp:
+        with _OPENER.open(r, timeout=timeout) as resp:
             raw = resp.read(4000)
             return resp.status, dict(resp.headers), raw
     except urllib.error.HTTPError as e:
         return e.code, dict(e.headers or {}), (e.read(4000) if e.fp else b"")
     except Exception as e:
-        return 0, {}, str(e).encode()
+        return 0, {"_err": str(e)[:160]}, b""
 
 def _pool_map(items, fn, workers):
     """保序线程池（替代 concurrent.futures，省 iSH import 成本）"""
@@ -97,15 +126,18 @@ def _pool_map(items, fn, workers):
 def scan(domain):
     out = {"domain": domain, "hits": [], "errors": []}
     try:
-        host, scheme, prefix = parse_target(domain)
+        host, scheme, prefix, query = parse_target(domain)
     except ValueError as e:
         out["root_status"] = 0
         out["errors"].append(f"目标非法: {e}")
         return out
-    # 指纹（https 失败自动回落 http；都不可达则快速返回）
+    if query:
+        out["query"] = query          # 查询参数保留在结果中（不拼接进探测路径）
+    # 指纹（https 连接失败回落 http；证书错误不降级——需显式 AB_INSECURE=1）
     base = f"{scheme}://{host}{prefix}"
     st, hd, bd = req(base + "/")
-    if st == 0 and scheme == "https":
+    err = str(hd.get("_err") or "")
+    if st == 0 and scheme == "https" and "certificate" not in err.lower():
         base = f"http://{host}{prefix}"
         st, hd, bd = req(base + "/")
     if st == 0:

package/tests/test_regressions.py

@@ -0,0 +1,157 @@
+"""离线回归测试（2.13.10 审核批次）：
+
+覆盖：安装器安全（用户文件保留 / 装机清单）、OpenCode 半安装防护、
+凭据默认脱敏与文件权限、端口列表数量、URL 解析边界、JS 同域判定。
+
+全部离线执行：installer 用临时 HOME；脚本用临时目录拷贝；不访问任何真实渗透目标。
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPTS = ROOT / "scripts"
+
+
+def _tmp_run(args, cwd=None, env=None, timeout=180):
+    return subprocess.run(args, capture_output=True, text=True, cwd=cwd, env=env, timeout=timeout)
+
+
+class InstallerSafetyTests(unittest.TestCase):
+    """安装器：用户文件保留 + 装机清单机制。"""
+
+    def _node(self, *args, home):
+        env = dict(os.environ)
+        env["HOME"] = home
+        return _tmp_run(["node", str(ROOT / "bin" / "install.js"), *args], env=env)
+
+    def test_user_file_preserved_through_reinstall_and_uninstall(self):
+        with tempfile.TemporaryDirectory() as home:
+            d = Path(home) / ".pi" / "agent" / "skills" / "agent-bypass"
+            d.mkdir(parents=True)
+            (d / "USER-NOTE.txt").write_text("用户私有内容", encoding="utf-8")
+            self._node("--pi", home=home)                       # 安装
+            self.assertTrue((d / "USER-NOTE.txt").exists(), "安装后用户文件必须保留")
+            self.assertTrue((d / "SKILL.md").exists(), "技能应安装")
+            self.assertTrue((d / ".agent-bypass-manifest.json").exists(), "应写装机清单")
+            self._node("--pi", home=home)                       # 覆盖重装
+            self.assertTrue((d / "USER-NOTE.txt").exists(), "重装后用户文件必须保留")
+            self._node("--pi", "--uninstall", home=home)        # 卸载
+            self.assertTrue((d / "USER-NOTE.txt").exists(), "卸载后用户文件必须保留")
+            self.assertFalse((d / "SKILL.md").exists(), "我方文件应被清除")
+
+    def test_user_owned_dir_not_touched_on_uninstall(self):
+        with tempfile.TemporaryDirectory() as home:
+            d = Path(home) / ".pi" / "agent" / "skills" / "agent-bypass"
+            d.mkdir(parents=True)
+            (d / "mine.txt").write_text("我的文件", encoding="utf-8")
+            self._node("--pi", "--uninstall", home=home)        # 未安装直接卸载
+            self.assertTrue((d / "mine.txt").exists(), "未安装时卸载不得删除用户文件")
+
+    def test_opencode_jsonc_blocks_all_writes(self):
+        with tempfile.TemporaryDirectory() as home:
+            base = Path(home) / ".config" / "opencode"
+            base.mkdir(parents=True)
+            (base / "opencode.jsonc").write_text("{ // 注释\n}", encoding="utf-8")
+            r = self._node("--opencode", home=home)
+            self.assertNotEqual(r.returncode, 0, "未完成项存在时应返回非零退出码")
+            self.assertFalse((base / "skills" / "agent-bypass").exists(),
+                             "配置验证失败时不得写入技能文件（防半安装）")
+            self.assertFalse((base / "agent-bypass.md").exists(),
+                             "配置验证失败时不得写入注入文件")
+
+
+class DeckMaskTests(unittest.TestCase):
+    """凭据：默认脱敏（终端与文件）+ 文件权限。"""
+
+    def test_default_masking_and_permissions(self):
+        with tempfile.TemporaryDirectory() as t:
+            shutil.copytree(SCRIPTS, Path(t) / "scripts")
+            r = _tmp_run([sys.executable, str(Path(t) / "scripts" / "deck.py"),
+                          "add", "--type", "cred", "--value", "admin:P@ssw0rd123"],
+                         cwd=t, timeout=60)
+            self.assertIn("***", r.stdout, "凭据默认应脱敏输出")
+            self.assertNotIn("P@ssw0rd123", r.stdout + r.stderr, "终端不得外泄原始凭据")
+            deck = json.loads((Path(t) / "deck.json").read_text(encoding="utf-8"))
+            self.assertNotIn("P@ssw0rd123", deck["cards"][0]["value"], "文件不得存原始凭据")
+            if os.name != "nt":
+                mode = (Path(t) / "deck.json").stat().st_mode & 0o777
+                self.assertEqual(mode, 0o600, "deck.json 权限应为 600")
+
+
+class PortscanTests(unittest.TestCase):
+    """端口列表：真实 100 个、非法输入拒绝。"""
+
+    @classmethod
+    def setUpClass(cls):
+        sys.path.insert(0, str(SCRIPTS))
+        import portscan
+        cls.ps = portscan
+
+    def test_top100_exactly_100_unique(self):
+        self.assertEqual(len(self.ps.TOP100), 100)
+        self.assertEqual(len(set(self.ps.TOP100)), 100)
+        self.assertEqual(len(self.ps.parse_ports("top100")), 100)
+
+    def test_invalid_inputs_rejected(self):
+        for bad in ("0", "65536", "abc", "1-99999", ""):
+            with self.assertRaises(ValueError, msg=f"应拒绝: {bad!r}"):
+                self.ps.parse_ports(bad)
+
+
+class WebprobeParseTests(unittest.TestCase):
+    """URL 解析：IPv6、端口范围、查询参数保留。"""
+
+    @classmethod
+    def setUpClass(cls):
+        sys.path.insert(0, str(SCRIPTS))
+        import webprobe
+        cls.wp = webprobe
+
+    def test_plain_and_full(self):
+        self.assertEqual(self.wp.parse_target("example.com"),
+                         ("example.com", "https", "", ""))
+        self.assertEqual(self.wp.parse_target("https://example.com/a/b?x=1&y=2"),
+                         ("example.com", "https", "/a/b", "x=1&y=2"))
+
+    def test_ipv6(self):
+        host, scheme, _, _ = self.wp.parse_target("https://[2001:db8::1]:8443/x")
+        self.assertEqual(host, "[2001:db8::1]:8443")
+        self.assertEqual(scheme, "https")
+
+    def test_port_range_rejected(self):
+        with self.assertRaises(ValueError):
+            self.wp.parse_target("https://example.test:65536/path")
+
+    def test_bad_scheme_rejected(self):
+        with self.assertRaises(ValueError):
+            self.wp.parse_target("ftp://x.com")
+
+
+class JsripSameSiteTests(unittest.TestCase):
+    """JS 同域判定：www 精确匹配、跨域拒绝。"""
+
+    @classmethod
+    def setUpClass(cls):
+        sys.path.insert(0, str(SCRIPTS))
+        import jsrip
+        cls.js = jsrip
+
+    def test_www_prefix_exact_only(self):
+        self.assertEqual(self.js._host_of("https://www.example.com/a.js"), "example.com")
+        self.assertEqual(self.js._host_of("https://wwwexample.com/a.js"), "wwwexample.com")
+
+    def test_same_site(self):
+        self.assertTrue(self.js.same_site("https://example.com", "https://example.com/a.js"))
+        self.assertTrue(self.js.same_site("https://example.com", "https://cdn.example.com/a.js"))
+        self.assertFalse(self.js.same_site("https://example.com", "https://evil.test/a.js"))
+        self.assertFalse(self.js.same_site("https://example.com", "https://wwwexample.com/a.js"))
+
+
+if __name__ == "__main__":
+    unittest.main()