本文记录一个跑在鸿蒙 PC 上的登录审计工作台 Hydra。它不是把上游 Hydra 的源码搬过来编译,而是一个在 Electron 壳里重新写出来的应用:主进程 875 行负责窗口、18 条 IPC、四个只监听 127.0.0.1 的内置靶场与真实的 TCP 握手,渲染层 752 行负责左栏五个配置块、右栏四个面板与一条 400 毫秒的进度轮询,七个纯函数引擎合计 1547 行负责字典变异规则的编译、字典解析、目标准入、四套协议状态机、并发调度、靶场账号与三种报告出口。整套应用一共 16 个文件、134,643 字节,其中引擎占 39.0%,没有一行第三方库。

文章按源码走一遍完整链路:一条规则串怎么被编译成步骤链再套到词上,字典去重为什么把 203 条候选压到 158 条,回环准入为什么坚持在解析阶段就硬拒而不是给一个「强制继续」开关,同一个模块怎么同时当客户端与服务端用而不会出现假命中,并发与限速的节拍是共享的还是各自的,报告里的中文表格靠什么把汉字按两格宽算齐。第四章会给出静态校验时逐条实测出的十处缺陷,其中三处值得先说:包名与标签仍然是模板默认的 com.huawei.ohos_electron 与 Electron,权限表 26 项里有 11 项的 usedScene 指向本工程并不存在的 FormAbility,而 app 目录里 package.json 的 test 脚本指向一个从未存在的 test-hydra-engine.js。

欢迎加入开源鸿蒙 PC 社区:https://harmonypc.csdn.net/

欢迎在 PC 社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper

AtomGit 仓库地址:https://atomgit.com/OpenHarmonyPCDeveloper/ohos_thc-hydra

说明:文中代码包含源码节选;未展示完整函数、类、对象或条件分支的片段需要结合原始上下文阅读,不能独立运行。

一、技术架构分析

1.1 应用形态与观测口径

先把要说清楚的一条写在最前面:这个应用只对本机回环地址上的内置靶场发起认证尝试。这句话不是文档里的免责措辞,是源码里的硬边界——目标解析器在遇到非回环地址时直接返回错误并终止解析,整条链路上没有任何一处提供「我确认已获授权,继续」的放行分支。main.js 开头的注释把这条边界和另外四条并列写进了代码:

* 能力边界(界面上照实写,不做假实现):
 *   - 只对回环地址发起认证尝试,非回环目标在解析阶段就被拒绝,没有「强制继续」开关;
 *   - ssh-lab 是 SSH 风格握手(版本串 + 简化 AUTH 行),不是 RFC 4252,连不上真实 sshd;
 *   - 只支持 FTP 子集、HTTP Basic、HTTP 表单、SSH 风格四个协议,没有 SMB / RDP / MySQL;
 *   - 单进程内存队列:进程退出,任务与靶场一起消失,不做断点续跑;
 *   - 没有隐蔽/规避选项:并发与速率是显式参数,日志逐条记录。

所以本文谈的「适配」有两层:一层是把一个纯前端的桌面工作台装进 Electron 壳再打到鸿蒙 PC 上,另一层是这个壳应用自身在窗口、权限、轮询与脱敏上的稳定性处理。所有结论都来自对仓库里这份源码的静态核对与目录级计数,没有在设备上跑过这个应用,也没有执行 HAP 构建——第五章的三张截图只能作为界面结构与界面自报数字的证据,不能当成运行验证。

观测口径也需要固定。这个工程里同一份应用代码存在两处副本:仓库提交的那一份在 web_engine/src/main/resources/resfile/resources/app 下,另一份是 electron/build/default/intermediates/res/default/resources/resfile/resources/app 下的构建产物。两者实测都是 16 个文件、134,643 字节,逐字节相同。构建系统对这份目录不做任何检查,只是原样拷进 HAP,所以本文所有行号、字节数、行为都以 resfile 这一份为准,改代码也只能改这一份。

1.2 进程与模块分层

应用分成三个层次,边界很干净:主进程碰网络与磁盘,渲染层只碰 DOM,引擎层是纯函数。

七个引擎文件全部用 CommonJS 单一出口,没有 UMD 包装,也没有互相 require——除了 hydra-report.js 需要 hydra-lab.js 来给命中凭据补一句强度判断:

var Lab = require('./hydra-lab.js');

其余六个引擎之间零依赖。这是刻意的:调度器 hydra-task.js 只负责「发多少、怎么排队」,真正怎么跟靶场握手由构造时传进来的 attempt 回调决定。引擎文件头把理由写得很清楚:

* 这里只负责「发多少、怎么排队、并发多少、速率多少、结果怎么记」,
 * 真正怎么跟靶场握手由外部传进来的 attempt(job) 决定——这样调度逻辑可以脱离
 * socket 直接单测,也不会把网络细节漏进统计里。

主进程到引擎的调用方向是单向的:main.js 顶部七个 require 把全部引擎拉进来,渲染层一个引擎都不直接 require,唯一例外是 renderer.js 里为了界面上的强度标签复用了靶场模块:

function strengthOf(pass) {
    /* 与报告使用同一份判定,避免界面和报告给出两种强度 */
    var Lab = require('./engines/hydra-lab.js');
    return Lab.evaluate(pass);
  }

渲染层对 Node 的依赖只有两处:取 ipcRenderer,以及在上面这个函数里取靶场模块。除此以外全部是标准 DOM API。渲染层文件头把这条自我约束写成了三条禁令,而且实测确实一条都没破:

* 所有涉网与涉盘的动作都在主进程;这里没有 alert / innerHTML / 内联样式,
 * 因为鸿蒙渲染层不支持它们(会直接崩或静默失效)。

全文扫描的结果支持这句注释:renderer.js 里 alert 出现 0 次,innerHTML 出现 1 次且只在这段注释里,点号 style 赋值出现 0 次,document.write 出现 0 次。样式表里同样的自我约束也成立——transition、animation、transform 三个词各自只出现在 hydra.css 第 8 行的注释里,实际规则零命中,状态变化全部靠颜色与边框表达。

1.3 文件清单与两条边界

业务代码一共 16 个文件、134,643 字节、4173 行:

文件行数字节职责
main.js87531,314窗口、18 条 IPC、四个回环靶场、TCP 握手、偏好读写
renderer.js75225,589左栏五块配置、右栏四面板、400 毫秒轮询、单一 IPC 漏斗
index.html2129,296顶栏、配置区、运行栏、七个统计格、四个 tab、关于弹层
styles/hydra.css71813,82717 个 CSS 变量、一处 1180 像素断点、零动画
engines/hydra-rules.js2518,14916 个操作符的解析与求值、14 个预设、候选展开
engines/hydra-wordlist.js993,044字典解析、去重、注释剥离、上限截断
engines/hydra-target.js1795,670四个协议元数据、回环判定、单条与多行目标解析
engines/hydra-protocol.js29811,193手写 base64、FTP 与 SSH 风格状态机、两种 HTTP 判定
engines/hydra-lab.js1024,035靶场公开账号、口令强度评估、场景说明与规则提示
engines/hydra-task.js2648,511并发工作线程、共享节拍限速、暂停与停止、快照
engines/hydra-report.js35411,953中文宽度表格、文本/CSV/JSON 三种渲染、文件名
samples/rules.txt14658规则样例,一行写完整套子集
samples/targets.txt15601目标样例,注明端口每次启动都由系统分配
samples/users.txt387用户名样例,空格与换行都能分隔
samples/wordlist.txt19319字典样例,含注释与重复词
package.json18397应用包元数据,license 写 MIT

七个引擎合计 52,555 字节、1547 行,占业务代码字节数的 39.0%、行数的 37.1%。主进程加渲染层 1627 行占去掉引擎与样式后的绝大部分。这个比例说明它不是一个薄壳套网页:规则语言、准入判定、协议状态机、调度与报告这五件事都是这个应用的主体。

两条边界必须写下来。第一条是「改哪一份」:只改 resfile 下的副本,intermediates 下的那份是构建时拷过去的,改了不生效也不会被下次构建保留。第二条是「引擎不能后于渲染层加载」:index.html 里只有一个 script 标签,位置在 body 末尾、全部 DOM 之后,而 renderer.js 一启动就调 app:info,所以它必须在 DOM 之后。这条比前面几篇里四个 script 的顺序问题简单得多,因为它只有一个文件。

二、环境准备

2.1 工程结构与构建入口

仓库根目录只有三样东西:lib.unstripped、ohos_hap 与两份说明文档。lib.unstripped 下是两份未裁剪的带符号库,libelectron.so 1,143,668,440 字节、libadapter.so 15,494,016 字节,那是调试用的,不进包。

ohos_hap 下是标准的 Stage 模型双模块工程,modules 数组里登记了两个:

模块路径类型作用
electron./electronentry原生库、三个 Ability 与两个 ExtensionAbility、页面,应用入口
web_engine./web_engineharElectron 运行时桥接层,静态共享包

electron 模块里注册了三个 Ability——EntryAbility、BrowserAbility、StatelessAbility,外加两个 ExtensionAbility——StatusBarEntryAbility 与 BrowserEmbeddedAbility。应用的入口是 EntryAbility,而它本身几乎不含逻辑,全部转发给 web_engine 导出的 WebAbility:

import { WebAbility } from 'web_engine';

export default class EntryAbility extends WebAbility {
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
    super.onCreate(want, launchParam);
  }

web_engine 是一个 HAR,Index.ets 只做再导出,把 WebAbility、WebWindow、WebSubWindow 等十来个符号暴露出去。它的 src/main/ets 下是这套 Electron 壳的核心:ability 目录四个文件负责生命周期,adapter 目录四十多个文件负责把 Electron 的窗口、剪贴板、通知、打印、蓝牙、文件选择等能力翻译成鸿蒙 API,jsbindings 目录再把 adapter 一个个挂到 JS 侧的 require 上。这套东西不是本文讨论的业务代码,但它解释了一件事——为什么业务侧能直接写 require(‘electron’).ipcRenderer,而不用自己搭桥。

业务代码在 web_engine/src/main/resources/resfile/resources/app 下,resfile 目录本身还带着 Electron 运行时要读的那几样东西:chrome_100_percent.pak 147,793 字节、chrome_200_percent.pak 221,300 字节、icudtl.dat 10,464,144 字节、resources.pak 5,777,343 字节、snapshot_blob.bin 79,090 字节、v8_context_snapshot.bin 214,155 字节、en-US.pak 492,210 字节、zh-CN.pak 498,227 字节,外加一个 6,584 字节的 electron 启动脚本与 resources/app 这个业务目录。

2.2 构建参数与签名

build-profile.json5 里只有一个 product,名字叫 default,关键三项:

"signingConfig": "default",
        "compatibleSdkVersion": "5.0.5(17)",
        "compatibleSdkVersionStage": "release",
        "runtimeOS": "HarmonyOS",
        "buildOption": {
          "nativeLib": {
            "collectAllLibs": true
          }
        }

compatibleSdkVersion 是 5.0.5(17),runtimeOS 是 HarmonyOS。nativeLib 的 collectAllLibs 保持 true,这一项关掉的话应用能构建成功,但启动时会因为找不到 Electron 运行时直接退出。

signingConfigs 里登记的是一套调试签名,四个路径全部指向用户目录下的 .ohos/config,文件名都是 default_ohos_hap_C48AxnDEbjfpPVAdw0mEVdP1itJYseikcLqYVY84JIc 这个前缀加不同后缀:证书 .cer、profile .p7b、密钥库 .p12,keyAlias 是 debugKey,signAlg 是 SHA256withECDSA。这里有一件事必须先做:这套签名材料是按当前的 bundleName 生成的,包名一改就必须重新申请 profile 再重新签名。所以上架前的顺序永远是先定包名,再动签名,反过来的话构建会在签名阶段报错而不是在安装阶段,报错信息通常也指不到真正原因。

electron/build-profile.json5 里 apiType 是 stageMode,buildOptionSet 只有一项 release、开了混淆,targets 登记了 default 与 ohosTest 两个;web_engine/build-profile.json5 里同样是 release 模式开了混淆,规则文件是 obfuscation-rules.txt,另外登记了一个 consumer-rules.txt 关闭混淆继承。这几项都不影响业务代码——resources 下的 app 目录属于纯资源,不参与 ArkTS 编译与混淆。

2.3 权限、上限与编码

权限表写在 web_engine/src/main/module.json5 里,一共 26 项。逐条看下来,与这个应用真正相关的只有 INTERNET 一项:内置靶场绑的是 127.0.0.1,连出也是 127.0.0.1,测的是本机回环,不涉及任何外部主机。GET_NETWORK_INFO 可以用来显示网络状态,但对这个应用没有用处。剩下 24 项与业务毫无关系,包括 LOCATION 三兄弟、MICROPHONE、CAMERA、ACCESS_BLUETOOTH、CUSTOM_SCREEN_CAPTURE、GYROSCOPE、ACCELEROMETER、PRIVACY_WINDOW、WINDOW_TOPMOST 等。这批权限不是这个应用申请的,而是这套 Electron 壳模板自带的——web_engine 是一个通用 HAR,模板把所有可能用到的权限一次列全,下游应用直接继承。这就是为什么必须在上架前裁一遍。

更需要注意的一点:这 26 项声明写在 type 为 har 的模块里,而 HAR 本身不构成独立安装单元,权限最终是从 entry 模块所在的 HAP 生效的。也就是说这份声明在构建期会被合入,但阅读起来完全指不到真正的消费者。

代码里的上限常量集中在 main.js 顶部,一共七个:

var MIN_CONCURRENCY = 1, MAX_CONCURRENCY = TaskMod.MAX_CONCURRENCY;
var MAX_TARGETS = 8;
var MAX_USERS = 16;
var MAX_TOTAL = 200000;
var MAX_REPORT_BYTES = 8 * 1024 * 1024;
var MAX_REQUEST_BYTES = 64 * 1024;
var LAB_IDLE_MS = 10000;

MAX_CONCURRENCY 不是在这一层写死的 16,而是从调度引擎取的 TaskMod.MAX_CONCURRENCY,这样两处只有一个真值。MAX_TOTAL 是 20 万次组合的上限,MAX_REPORT_BYTES 是 8 MB 的报告上限,MAX_REQUEST_BYTES 是 64 KB 的单次请求上限(同时用于靶场侧的缓冲保护与 HTTP 请求体),LAB_IDLE_MS 是靶场连接的空闲超时。

引擎层还有三组上限:规则串最长 60 个字符、候选口令最多 20 万条(hydra-rules.js);字典最多 20 万个词、单个词最长 128 个字符(hydra-wordlist.js);事件缓冲区最多 240 条、快照只回最近 80 条(hydra-task.js)。这几组数字与主进程的常量互相独立,改的时候要一起想。

编码上有一个细节值得单独说。CSV 导出带 BOM,代码里写得很直白:

/* 带 BOM:Windows 上双击用表格打开,中文才不会变成乱码 */
  var bom = String.fromCharCode(0xFEFF);

文本报告与 JSON 不带 BOM,因为这两个是给人看或者给脚本吃的,带了反而碍事。样例文件读取用 utf8,字典解析里还专门剥掉可能残留的 U+FEFF —— Wordlist.parse 的 normalize 函数第一行就是 s.replace(/^\uFEFF/, ‘’),防的是从某些工具里复制粘贴时带进来的 BOM。

三、核心适配流程

3.1 规则语言:十六个操作符与三种错位检测

规则引擎对标上游 hydra 的 -r 写法,实现了其中最常用的一段子集,一共 16 个操作符,分三类。第一类是无参数的单字符操作:冒号原样、l 转小写、u 转大写、c 首字母大写、T 大小写互换、r 反转、d 自身重复两遍、f 反射(词加它的反转)、左花括号左旋一个字符、右花括号右旋一个字符、左方括号删首字符、右方括号删尾字符。第二类是一个参数的:$ 末尾追加、^ 开头插入、@ 删除指定字符。第三类是两个参数的:s 把第一个换成第二个。

解析器是一个不抛异常的状态机,遇到问题就填错误并 break,返回值里一定同时带着 steps 与 errors:

var i = 0;
  while (i < text.length) {
    var ch = text.charAt(i);
    if (ch === '$' || ch === '^' || ch === '@') {
      var a1 = text.charAt(i + 1);
      if (!a1) {
        out.errors.push({ pos: i + 1, why: '「' + ch + '」后面缺一个字符' });
        break;
      }
      out.steps.push({ op: ch, arg: a1 });
      out.desc += (out.desc ? ' · ' : '') + opDesc(ch, a1);
      i += 2;
      continue;
    }

三种错位检测对应三类真实的手误。第一种是带参操作符后面忘了给参数,报「后面缺一个字符」,位置指向操作符之后那一格。第二种是 s 只给了一个字符,报「后面需要两个字符」,位置同样指向操作符之后。第三种是根本不认识这个字符,报「不认识的规则字符」。第三种有一个容易踩的地方:s 本身在 OP_DESC 里有条目,所以在最后那个兜底分支里,判断条件得额外把 s、$、^、@ 四个带参操作符再排除一遍,否则带参操作符走到兜底分支时会被当成合法单字符操作处理,参数被静默丢掉。

求值走一条 switch,每个操作符一个 case,落空返回原词。这里有个设计选择:所有字符串操作都手写循环,没有用正则。purge 与 replaceAll 是两个最典型的例子:

function replaceAll(s, from, to) {
  var out = '';
  for (var i = 0; i < s.length; i++) {
    out += (s.charAt(i) === from) ? to : s.charAt(i);
  }
  return out;
}

不用正则的理由很实际:参数是用户输入的单个字符,可能是正则元字符,直接拼进正则要先转义,转义漏了就是一个静默的行为偏差。手写循环慢一点,但行为确定,而且这类操作的输入长度上限只有 128 个字符。

14 个预设规则按顺序挂在界面上,从左到右就是从左到右的顺序:原样、首字母大写、全大写、末尾加 1、末尾加 123、末尾加年份、末尾加叹号、小写加 1、a 换 @、o 换 0、反转、重复两遍、反射、删尾字符。默认规则集只有 7 条::、c、l、$1、$1$2$3、$!、sa@。这个默认集是刻意选的——它刚好能覆盖「原样、首字母、小写、加数字、加三位数字、加符号、a 换 @」这七类最常见的拼接口令习惯,同时不引入爆炸式的候选增长。

3.2 字典与候选:29 词、203 条、158 条

这三个数字是从第一章那张截图里对出来的,也能从源码完整推出来,值得走一遍,因为它解释了界面上「约 203 条候选」和统计格「组合总数 632」为什么不相等。

内置字典 BUILTIN 一共 29 个词,按四行写在 hydra-wordlist.js 里:admin、administrator、root、guest、test、user、ftp、www、password、passwd、letmein、welcome、qwerty、abc123、iloveyou、dragon、monkey、master、shadow、sunshine、princess、football、baseball、superman、trustno1、hello、changeme、default、secret。builtinText 在它们前面加一行注释,所以是 30 行。界面上的字典统计写「有效 29 词 · 原始 30 行 · 注释 1」,正好对上。

默认 7 条规则全部合法,所以理论候选数是 29 乘 7 等于 203。这个数字来自一个只做乘法的函数,它连展开都不做:

/* 预估候选总量:词数 × 有效规则数 */
function count(words, specs) {
  var valid = 0;
  for (var i = 0; i < specs.length; i++) {
    if (parse(specs[i]).errors.length === 0) valid++;
  }
  return (words ? words.length : 0) * valid;
}

但真正跑任务时用的是另一条路:先按「词 × 规则」展开成 203 条原始候选,再整体去重,剩下的才是口令表:

var exp = Rules.expand(dict.words, specs, Rules.MAX_CANDIDATES);
  var passwords = dedupe(exp.candidates);
  var total = t.targets.length * users.length * passwords.length;

203 条里有 45 条是重复的,去重后剩 158 条。重复从哪来?「原样」与「l 转小写」对本来就没有大写字母的词会产出同一个结果,比如 admin 走冒号还是 l 都是 admin;「c 首字母大写」对这些词也产出同一个 admin(因为 c 的定义是首字母大写加其余小写,admin 本身已经满足)。29 个词里绝大多数是全小写,所以这几条规则的产出大面积重合。158 这个数字再乘 4 个目标、1 个用户名,正好是截图里那个 632。

这条链路上有一个必须记住的语义:候选口令的去重发生在口令维度,不是组合维度。也就是说 4 个目标共用同一份 158 条口令,不存在「FTP 字典」和「HTTP 字典」两套。这与真实环境一致——攻击面从来不是按协议分字典的。

字典解析本身很朴素,四件事:剥注释、去空行、去重、超长跳过。函数返回一个完整的统计对象而不只是词数组:

return {
    words: words,
    total: words.length,
    lines: src.length,
    comments: comments,
    blanks: blanks,
    duplicates: dupes,
    tooLong: tooLong,
    truncated: truncated,
    errors: []
  };

界面上「有效 29 词 · 原始 30 行 · 注释 1」这一行就是把 total、lines、comments 三个字段拼出来的,另外两个字段 duplicates 与 tooLong 只在非零时才显示。这个设计的好处是:用户把一整份字典粘进来,界面能立刻告诉他有多少行被当成注释吃掉了、有多少词因为重复被丢——这两个数字是排查「为什么结果比预期少」的第一现场。

3.3 回环准入:一种地址、四种写法

目标解析是这个应用里唯一带安全语义的函数,值得逐行看。支持的地址写法只有四种:字面量 localhost、字面量 ::1、字面量 0:0:0:0:0:0:0:1,以及 127 开头的四段点分十进制。

function isLoopback(host) {
  var h = String(host == null ? '' : host).trim().toLowerCase();
  if (!h) return false;
  if (h === 'localhost') return true;
  if (h === '::1') return true;
  if (h === '0:0:0:0:0:0:0:1') return true;
  if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) {
    var parts = h.split('.');
    for (var i = 1; i < 4; i++) {
      var n = parseInt(parts[i], 10);
      if (!isFinite(n) || n < 0 || n > 255) return false;
    }
    return true;
  }
  return false;
}

这个判定拒绝的写法比它接受的写法多得多,而且拒绝的每一条都有理由。127.1 这种省略写法被拒,因为它依赖系统解析器的宽松补全,不同平台行为可能不同。localhost. 末尾带点被拒,同理。0.0.0.0 被拒——它表示「监听所有网卡」,不是回环。0x7f.0.0.1 与 2130706433 这两种数值写法被拒,因为它们绕过字面检查指向同一个地址。IPv6 只认 ::1 与全零写法,压缩形式的其它等价表示一律不认。这些都不是疏漏,而是把判定写成了一张白名单:认不出来的就拒绝,不猜。

正则本身也有个细节:只校验了后三段在 0 到 255 之间,第一段由正则里的字面量 127 兜住,所以不需要再判断。这是一个可以省的判断,代码里也就真的省了。

单条目标的解析在回环判定之前还有三道检查。第一道是格式,必须能匹配 协议://主机端口/路径 这个形状。第二道是协议白名单,四个 id 之外的直接拒,错误信息里会列出可选项。第三道是拒绝带凭据的写法:

if (authority.indexOf('@') >= 0) {
    out.errors.push('目标里不要带用户名或口令(user:pass@host 这种写法会被拒)');
    return out;
  }

这一条很关键。上游工具普遍支持 ftp://user:pass@host 这种内联凭据写法,而这个应用明确拒绝,理由是凭据应该从用户名框与候选口令表来,而不是混在目标清单里。目标清单会被存进偏好文件,凭据写进去就等于明文落盘。

解析完成后还会做两件事:对不需要路径的协议(FTP 与 SSH 风格)把 path 强制清空,对需要路径的协议在路径为空时补一个斜杠。所以四个协议在数据模型上是统一的六字段结构:protocol、protocolName、host、port、path、label,其中 label 是界面上显示的那一行,形如 FTP · 127.0.0.1:33629。

3.4 一个模块两用:四套状态机

hydra-protocol.js 是整个工程里最特殊的一个文件。它同时提供给两边用:主进程起靶场服务时用 serverXxx 那一套按行应答,主进程发认证尝试时用 clientXxx 那一套按行推进。文件头把理由写得很好:

* 同一个模块同时给两边用:
 *   - 主进程起靶场服务时,用 serverXxx 那套按行应答;
 *   - 主进程发认证尝试时,用 clientXxx 那套按行推进。
 * 两边共用一份判定逻辑,就不会出现「客户端以为成功、服务端其实拒了」这种假命中。

这句话不是自我表扬,它解决了一个真实问题。如果客户端与服务端各写一套判定,两边对「什么算成功」的理解一旦有偏差,测试就会跑出假结果——客户端认为这一条命中了,其实只是它的解析逻辑把某个响应误判成了通过。共用模块之后,两边用同一份字符串比较,偏差不可能出现。

四套协议里两套是行协议,两套是 HTTP。FTP 的客户端状态机是标准的四拍:

clientFeed: function (st, line) {
    var code = /^(\d{3})/.exec(String(line || ''));
    var n = code ? parseInt(code[1], 10) : 0;
    if (st.stage === 0) {
      if (n !== 220) return { done: true, ok: false, note: '问候不是 220:' + line };
      st.stage = 1;
      st.sent++;
      return { send: 'USER ' + st.user + CRLF, note: 'USER ' + st.user };
    }

四拍依次是:等 220 问候、发 USER、等 331、发 PASS、等 230 或 530。每一拍都只做一件事,判断失败立刻返回 done 并给出中文说明,说明里带上实际收到的状态码。这个「把状态码写进 note」的做法很实用——事后看日志时,用户能直接看出是对端返回了 530 还是根本没回 331,不用去猜。

SSH 风格那一套更短,因为它是自造的简化协议,不是 RFC 4252:

var SSHLAB = {
  id: 'ssh-lab',
  name: 'SSH 风格',
  greeting: function () { return 'SSH-2.0-HydraLab_1.0' + CRLF; },

问候串是 SSH-2.0-HydraLab_1.0,形似真实的版本串,但后面接的不是密钥交换,而是一行 AUTH 用户名 口令。服务端拿正则 ^AUTH\s+(\S+)\s+(.*)$ 拆开,用户名不能含空格,口令可以。这个约束是故意留下的:真实 SSH 的口令认证也是一行一个字段,含空格的用户名在真实环境里同样需要引号处理,简化版直接不支持反而更接近实际。

两种 HTTP 的判定方式完全不同,这也是刻意保留两种协议的原因。HTTP Basic 判定请求头里的 Authorization,解密后按冒号切开,第一段是用户名、剩下的全是口令:

decide: function (req, accounts) {
    var head = headerValue(req.headers, 'authorization');
    var m = /^Basic\s+(.+)$/i.exec(head);
    if (!m) return { status: 401, body: '需要 Basic 认证' };
    var pair = b64decode(m[1]).split(':');
    var user = pair.shift();
    var pass = pair.join(':');

这里用 split 加 shift 加 join 而不是解构前两段,是因为口令里允许出现冒号。写成 pair[1] 的话,口令是 a:b 就会被截成 a。这三行大概是整个文件里最容易写错也最容易被忽略的一处。

HTTP 表单判定的是请求体,用 username 与 password 两个字段名。它在缺少字段时返回 400 而不是 401,这是一个语义上的讲究:400 表示请求本身不合法,401 表示凭据不对,两者对使用者意味着完全不同的排查方向。

base64 是手写的,不用 Buffer,理由写在注释里——「保持引擎纯函数」。这段实现用 charCodeAt 逐字符处理,每三个字节出四个字符,末尾不足三个字节补等号:

var e1 = c1 >> 2;
    var e2 = ((c1 & 3) << 4) | (isNaN(c2) ? 0 : c2 >> 4);
    var e3 = isNaN(c2) ? 64 : (((c2 & 15) << 2) | (isNaN(c3) ? 0 : c3 >> 6));
    var e4 = isNaN(c3) ? 64 : (c3 & 63);

用 64 当作「本格应填等号」的哨兵值,是因为 base64 字母表只有 64 个字符,下标 64 必然越界,拿来当哨兵正好不冲突。这个技巧在解码侧反过来了:B64.indexOf 找不到时返回 -1,所以解码判断用的是小于零。

脱敏函数 mask 挂在同一个文件末尾,策略是保留首尾各一个字符、中间全换成星号,长度不超过两个字符时全换:

function mask(pass) {
  var s = String(pass == null ? '' : pass);
  if (s.length <= 2) return '*'.repeat(s.length || 1);
  return s.charAt(0) + '*'.repeat(s.length - 2) + s.charAt(s.length - 1);
}

保留首尾是有意为之:规则是按首尾特征拼接的,日志里留着头尾两个字符,用户能一眼看出这条候选是哪条规则产出的,又看不到完整明文。

3.5 调度器:并发、节拍与暂停语义

调度器把「一次尝试」定义成一个目标乘一个用户名乘一个候选口令。总数是所有维度相乘,取值用一次整除加两次取模完成,没有嵌套循环:

Task.prototype._take = function () {
  var total = this.total();
  if (this._idx >= total) return null;
  var i = this._idx++;
  var pCount = this.passwords.length || 1;
  var uCount = this.users.length || 1;
  var tIdx = Math.floor(i / (pCount * uCount));
  var rest = i % (pCount * uCount);
  var uIdx = Math.floor(rest / pCount);
  var pIdx = rest % pCount;

这个写法把三层循环压成一个自增下标加四次算术,好处是并发工作线程可以无锁地抢任务——每个 worker 拿到的 i 是唯一的,因为自增本身是单线程语义。坏处是顺序被固定成「先按目标、再按用户名、最后按口令」,想让口令在最外层轮转就得改公式。对这个应用来说这个顺序是对的:先跑完一个目标,用户能更快看到某个协议的完整结果。

限速用的是「下一条最早可发时间」的排队,不是令牌桶:

/* 限速:按「下一条最早可发时间」排队,多并发之间共享同一个节拍 */
Task.prototype._pace = function () {
  if (!this.rate) return Promise.resolve();
  var gap = 1000 / this.rate;
  var now = Date.now();
  var at = Math.max(now, this._nextAt);
  this._nextAt = at + gap;
  var wait = at - now;
  return wait > 0 ? this._sleep(wait) : Promise.resolve();
};

关键在于 _nextAt 是所有 worker 共享的一个字段,每个 worker 在发下一条之前先「预定」一个时间片,然后睡到那个时间点。这样无论并发开多少,整体发起速率都被压在 rate 上,而不是「每个 worker 各压 rate、总量变成 rate 乘并发」。后者是很多手写限速器的经典错误,写出来会在并发 16 时限速 200 变成实际 3200。

工作线程的结构值得单独说,因为它把暂停、停止、超时三件事压在一个递归函数里:

function step() {
    if (self._stopped) return Promise.resolve();
    if (self._paused) return self._sleep(60).then(step);
    var job = self._take();
    if (!job) return Promise.resolve();

三行判断的顺序就是语义:先看停不停,再看暂停不暂停,最后才取任务。暂停不是中断,是 60 毫秒轮询一次重新判断——这意味着按下暂停之后,已经在途的那几条尝试会跑完才停。界面上那句提示「已暂停(当前在途的尝试会跑完)」就是这个意思,写得比大部分应用的「暂停中」诚实。

停止同理。stop 只做三件事:置 _stopped、清 _paused、改状态为 stopped,然后立刻返回。真正结束要等 Promise.all 里所有在途的 attempt 结算,而每次 attempt 自带一个定时器兜底,超时默认 4000 毫秒。所以按了停止之后,最坏情况下界面还会停留在「运行中」一个超时周期——这一点在 Q4 里单独展开。

统计的记账集中在 _record 一个函数里,三条分支对应命中、出错、失败。其中失败分支记的 note 会被存进 _lastNote,命中分支则把完整的记录推进 found 数组:

this.found.push(rec);
    this._event('hit', key + ' → ' + job.user + ' / ' + job.pass + '(' + (r.note || '通过') + ')');
    return;

注意这一行是事件流里唯一一处直接写出明文的 job.pass。失败分支用的是 maskPass,改成保留首字符加三个星号加尾字符。两条分支的差异不是疏忽,是设计:命中记录本来就要落到命中表与报告里,那里显示的是明文;而事件流是滚动日志,脱敏才能防止截图或贴日志时把口令带出去。这条边界在 Q6 里单独展开。

3.6 报告:三个出口、中文宽度与 BOM

报告模块的第一句话就点出了它的设计约束:三种出口必须来自同一份对象。

* 三种都由同一份 report 对象渲染,不会出现「文本里说命中 2 条、CSV 里只有 1 行」
 * 这种自相矛盾。

build 函数负责把快照、配置与应用信息合成一个扁平对象,命中项在合成时补三个字段:strength、score、reasons,都来自靶场模块的 evaluate。这个位置选得对——强度评估只做一次,界面与报告都读它,所以界面上标「弱」的那条记录,在报告里一定也是「弱」。

文本报告最难的部分是中文表格对齐。终端的等宽字体里一个汉字占两格、一个 ASCII 字符占一格,直接用可打印字符数补空格,含中文的列就会歪。解决办法是先把每个字符换算成显示宽度:

function charWidth(ch) {
  var c = ch.charCodeAt(0);
  if (c < 32) return 0;
  if (c >= 0x1100 && (c <= 0x115f || c === 0x2329 || c === 0x232a ||
      (c >= 0x2e80 && c <= 0xa4cf) || (c >= 0xac00 && c <= 0xd7a3) ||
      (c >= 0xf900 && c <= 0xfaff) || (c >= 0xfe30 && c <= 0xfe6f) ||
      (c >= 0xff00 && c <= 0xff60) || (c >= 0xffe0 && c <= 0xffe6))) return 2;
  return 1;
}

这个区间表是从 wcwidth 那一套搬过来的简化版:控制字符 0 宽,韩文字母块与日文假名块、CJK 统一汉字、兼容汉字、CJK 标点、全角字符全部算 2。它并不完备——比如 emoji 与部分组合字符算得不对——但报告里出现的字符集合是可控的:主机、端口、用户名、口令、强度标签、判定说明,全部落在这张表覆盖的范围内。

有了宽度之后,截断与补齐都能按显示宽度算,不会出现「补齐了但对不齐」。列宽还有一层封顶,六个上限依次是 24、16、18、8、40、30,超过就截断并补省略号:

/* 内容特别长的列收窄,避免一列把终端撑到没法读;说明列留宽一点,
   * 否则「230 登录成功」这种判定词会被截成「230 登录…」 */
  var caps = [24, 16, 18, 8, 40, 30];

说明列给到 40 是一处具体的经验:判定说明这一列的内容都是「230 登录成功」「200 可以访问受保护路径」这种短句,给 24 会截成半个词,读起来很难受。这个数字不是算出来的,是看着实际输出调出来的。

CSV 导出除了带 BOM,还做了一件容易被忽略的事:单元格转义只针对三种情况——含双引号、含逗号、含换行。转义时把内部双引号成对加倍:

function csvCell(v) {
  var s = String(v == null ? '' : v);
  if (/[",\r\n]/.test(s)) return '"' + s.replace(/"/g, '""') + '"';
  return s;
}

判定条件里没有分号,因为分隔符就是逗号,分号不需要转义。行尾统一用 CRLF 而不是 LF,这是为 Excel 那一侧准备的。

三种出口的文件名都由一个函数生成,格式是 hydra-report-年月日-时分秒 加扩展名:

function fileName(kind, at) {
  var ext = kind === 'csv' ? 'csv' : (kind === 'json' ? 'json' : 'txt');
  return 'hydra-report-' + fileStamp(at) + '.' + ext;
}

时间戳里的冒号被去掉、空格换成短横,因为冒号在不少文件系统里是非法字符。这个处理看着理所当然,但正是这类地方最容易在跨平台时出事。

四、鸿蒙稳定性适配

4.1 窗口创建:一条只有 console.warn 的失败路径

窗口创建的写法与前面几篇里见到的壳应用基本一致,都是按屏幕工作区比例算尺寸、给一个最小尺寸兜底、指定背景色防止首帧闪白:

function createWindow() {
  try {
    var area = screen.getPrimaryDisplay().workAreaSize;
    var width = Math.max(1120, Math.floor(area.width * 0.92));
    var height = Math.max(720, Math.floor(area.height * 0.9));
    mainWindow = new BrowserWindow({
      width: Math.min(width, area.width),
      height: Math.min(height, area.height),
      minWidth: 1024,
      minHeight: 660,
      frame: true,
      transparent: false,
      resizable: true,
      backgroundColor: '#0f1419',
      title: WINDOW_TITLE,
      webPreferences: {
        nodeIntegration: true,
        contextIsolation: false
      }
    });
    mainWindow.loadFile('index.html');
    mainWindow.on('closed', function () { mainWindow = null; });
  } catch (e) {
    console.warn('[Hydra] 创建窗口失败:' + String((e && e.message) || e));
  }
}

尺寸是两段夹逼:先按 0.92 与 0.9 算,再用 Math.max 抬到 1120 与 720 的下限,最后用 Math.min 压回工作区尺寸。这个顺序是对的——如果先夹再抬,小屏幕上算出的宽可能被抬到比屏幕还宽,窗口一开就超出可视区域。

title 用的是 WINDOW_TITLE 常量「Hydra 登录审计工作台」,但要注意这只影响 Window 对象的 title 字段,鸿蒙侧任务栏显示的是 entry 模块里 EntryAbility 的 label,那个值是字符串资源 EntryAbility_label,当前内容是 Electron。这两者不一致,在 4.3 里作为 D1 记下。

背景色写的是 #0f1419,而样式表里的 --bg 是 #0b0f14。两者不一致,但这不是缺陷:首帧背景色只需要不留白,具体色值差几级肉眼看不出来,而且一旦 CSS 加载完成,body 的背景就覆盖了它。

真正的问题在 catch 分支。窗口创建失败时只打一条 console.warn,既不重试也不退出,mainWindow 保持 null。后续所有依赖它的地方都会带着 null 继续走——最典型的是导出报告那一处:

var r = await dialog.showSaveDialog(mainWindow, {

showSaveDialog 的第一个参数是父窗口,传 null 在部分平台上会变成无父窗口的孤立对话框,在另一些平台上直接抛异常。这条异常会被 handle 的 catch 兜住转成中文,但用户看到的是「导出失败」,而不是「窗口没起来」。这是这类壳应用最常见的失败模式:功能全都绑上了,但窗口没起来,点什么都只是静默或者报一个不相干的中文提示。

另外全文扫描 disableHardwareAcceleration 的结果是 0 处。这个应用的界面是纯 DOM,没有 canvas 视口,也没有 WebGL,所以对 GPU 合成路径的依赖比前几篇里那些三维应用轻得多。但「轻」不等于「不需要退路」:只要界面用了 CSS 变量、边框与大面积背景色,就仍然走合成层,在部分设备上仍然可能出现白屏。缺一条退路的代价是出问题时没有任何自救手段,这一点与前面几篇的结论一致。

4.2 权限与包名:26 项声明、11 个不存在的 FormAbility

权限表这件事在 2.3 里已经说过数量,这里要说结构上的问题。26 项里,凡是需要 reason 与 usedScene 的,用的都是同一段:

{
        "name": "ohos.permission.READ_PASTEBOARD",
        "reason": "$string:access_pasteboard",
        "usedScene": {
          "abilities": [
            "FormAbility"
          ],
          "when":"always"
        }
      },

这样的条目一共 11 个:READ_PASTEBOARD、READ_WRITE_DOWNLOAD_DIRECTORY、READ_WRITE_DOCUMENTS_DIRECTORY、READ_WRITE_DESKTOP_DIRECTORY、LOCATION、APPROXIMATELY_LOCATION、LOCATION_IN_BACKGROUND、MICROPHONE、CAMERA、ACCESS_BLUETOOTH、CUSTOM_SCREEN_CAPTURE。它们全部指向一个叫 FormAbility 的 Ability。

而这个工程里根本没有 FormAbility。electron 模块的 module.json5 里注册的三个 Ability 是 EntryAbility、BrowserAbility、StatelessAbility,两个 ExtensionAbility 是 StatusBarEntryAbility 与 BrowserEmbeddedAbility,没有任何一个叫 FormAbility。web_engine 是 HAR,不注册 Ability。所以这 11 条 usedScene 指向的是一个不存在的名字。

这件事的严重程度取决于审核口径。一种可能是它根本不影响安装——usedScene 只是给用户看的说明性字段,指向不存在的 Ability 不会让构建失败。另一种可能是审核会逐条核对 usedScene 与实际注册的 Ability,那这 11 条就是一个显眼的问题。无论哪种,改它都是零成本的:把 FormAbility 换成 EntryAbility,或者干脆把与业务无关的权限连同 usedScene 一起删掉。

包名这一侧的问题更直接。AppScope/app.json5 里写着:

{
  "app": {
    "bundleName": "com.huawei.ohos_electron",
    "vendor": "example",
    "versionCode": 1000000,
    "versionName": "1.0.0",
    "icon": "$media:app_icon",
    "label": "$string:app_name",

bundleName 是 com.huawei.ohos_electron,vendor 是 example,label 指向的 app_name 实际值是 Electron。这三个字段加上 EntryAbility_label 的 Electron,一共四处全是模板默认值。一个叫「Hydra 登录审计工作台」的应用装到设备上,桌面图标下面写的是 Electron,这不可能通过上架评审。

还有一个连带影响:versionCode 是 1000000,versionName 是 1.0.0。而 app 目录下 package.json 的 version 也是 1.0.0,界面上顶栏显示的是后者(app.getVersion() 读的是 package.json)。两个版本号来源不同步,如果只改了其中一个,界面显示的版本和包管理里记录的版本就会不一致。改动时两个都要动。

4.3 静态校验得到的十处缺陷

把主进程、渲染层、七个引擎与四份工程配置逐条核对下来,一共十处问题。没有一处会让应用启动不起来,但每一处都会在实际使用或上架时暴露出来。

编号位置问题影响
D1AppScope/app.json5 与 entry 的 string.jsonbundleName 为 com.huawei.ohos_electron,vendor 为 example,app_name 与 EntryAbility_label 都是 Electron桌面显示名与包名全是模板默认值,上架必然被拒
D2web_engine/src/main/module.json526 项权限中 11 项的 usedScene.abilities 指向不存在的 FormAbility权限声明与实际 Ability 对不上,审核时逐条核对会暴露
D3main.js 第 848 至 851 行nodeIntegration 为 true、contextIsolation 为 false渲染层拿到完整 Node 能力,index.html 里的 CSP 只能约束脚本来源,约束不住 require
D4main.js createWindow失败路径只有 console.warn,没有重试也没有退出窗口起不来时界面全空,后续所有对话框拿到 null 父窗口
D5main.js 全文没有 disableHardwareAcceleration出现 GPU 合成白屏时没有任何自救开关
D6app/package.json 第 9 行test 脚本指向 test-hydra-engine.js该文件在全仓库不存在,npm test 必然失败
D7四处许可证声明app/package.json 写 MIT,关于弹层写 Apache-2.0,oh-package.json5 的 license 为空,web_engine/oh-package.json5 写 Apache-2.0同一份仓库里三种说法,分发时无法确定义务
D8AppScope/app.json5multiAppMode 声明 multiInstance 而 maxCount 为 1声明为多实例却只容一个,配置自相矛盾,单实例应当直接用 singleton
D9web_engine 与 electron 的 module.json5各有一处多余的尾逗号(definePermissions 末项、abilities 首项的 metadata 之后)JSON5 容忍,不影响构建,属于手改残留
D10main.js reportKind 的注释注释里用「显示是 exe、内容其实是文本」举例这个应用根本没有 exe 出口,注释与实现不符,容易误导

D3 值得单独说一句。index.html 头部的 CSP 是 default-src ‘self’; script-src ‘self’; style-src ‘self’; img-src ‘self’ data:,看着挺严。但它管的是资源加载来源,管不了渲染层能不能 require(‘fs’)。在 nodeIntegration 打开、contextIsolation 关闭的配置下,渲染层只要拿到任意一段可执行脚本,就能直接读文件系统。而这个应用的界面代码全部来自本地资源、没有远程加载,所以现实中风险可控——但这条配置本身就是一条不该留在成品里的口子。

D7 的排序也是实际问题。四种说法里最严的是 Apache-2.0(要求保留声明与变更说明)与 MIT(最宽松)与空白。真要按某一个执行,正确的顺序是先定一份、在仓库根放上全文、再让四处同时指向它。只改一处会留下新的矛盾,比完全没写更麻烦,因为读的人无法判断哪一处才是真的。

D10 虽然只是注释,但它反映了一个真实的维护风险:注释写的是作者当时设想的通用情形,代码后来被裁成了三种固定出口,注释没跟着改。这类不同步在读代码时最费时间,因为读者会先怀疑自己理解错了。

4.4 轮询节拍、脱敏边界与内存队列

渲染层有三个定时器,各自的节拍不同,值得放在一起看。

第一个是靶场状态的轮询,2500 毫秒一次,无条件执行:

refreshLab();
      if (ui.labTimer) clearInterval(ui.labTimer);
      /* 顶栏的靶场状态要一直准,所以这里不按面板可见性偷懒 */
      ui.labTimer = setInterval(refreshLab, 2500);

注释说明了为什么不按可见性偷懒:顶栏那个「靶场 4 个端口在听」的指示器一直在显示,它必须准。代价是即使用户全程停在运行日志页,主进程每 2.5 秒也会被叫醒一次,去做一次快照组装与一次 DOM 重建。这个开销在这个应用的规模下可以接受——快照里只有端口表与最近 30 条日志。

第二个是任务进度的轮询,400 毫秒一次,只在任务运行期间存在,结束就停:

function startPoll() {
    stopPoll();
    ui.pollTimer = setInterval(function () {
      ipc('task:poll').then(function (r) {
        if (!r.success || !r.snapshot) return;
        ui.snapshot = r.snapshot;
        renderSnapshot(r.snapshot);
        if (r.snapshot.state === 'done' || r.snapshot.state === 'stopped') {
          stopPoll();

400 毫秒是「看起来连续」与「不要白跑 IPC」之间的折中。截图里那个任务只用了 1 秒就跑完 632 次尝试,也就是说整个任务周期里轮询只触发了两次左右——第一次看到的进度可能已经是 100%。这个现象会让「进度条」在看快任务时基本没有中间态,属于正常的观测限制,不是 bug。

第三个是渲染层的偏好保存防抖,900 毫秒。所有输入框的 oninput 都挂到 savePrefsSoon,也就是停止输入 900 毫秒后才写盘一次。这个节拍配合三处 350 毫秒的解析防抖(目标、规则、字典),形成了两层缓冲:350 毫秒内不解析,900 毫秒后才落盘。这样连续打字不会产生几十次 IPC。

脱敏的边界在 3.5 末尾提过一半,这里补全。全工程一共三处脱敏,策略各不相同:

位置处理对象策略目的
hydra-protocol.js mask客户端日志里发出的口令保留首尾各一字符日志里能看出规则效果又看不到明文
hydra-task.js maskPass失败尝试的口令首字符加三个星号加尾字符事件流滚动日志统一处理
main.js lineServer靶场收到的 PASS 与 AUTH 行整段替换成星号靶场侧日志不留明文

而命中记录走的是第四条路:不脱敏,明文落到命中表与报告。这条边界在报告里用三条边界声明兜住,其中第三条是:

'报告中的口令按原样保留以便核对规则效果,请勿把它当作真实环境的凭据使用。'

这三条 caveat 会出现在文本报告的第六章、CSV 的末尾与 JSON 的 caveat 数组里,三种出口一份不落。这个做法比在文档里写免责声明有效得多——报告是要被转发、被贴进工单、被存档的东西,声明跟着报告走,才不会脱节。

最后是内存队列这件事。整个任务的状态都在一个 Task 实例里,没有落盘、没有外部队列、没有断点续跑。app.on(‘before-quit’) 只做一件事:

app.on('before-quit', function () { stopLab(); });

它关靶场,但不会保存任务进度。所以进程一退,任务、命中、事件、靶场端口全部消失。界面上「重启靶场」那条路径因此要加一道检查,任务在跑的时候不允许重启:

if (ui.snapshot && (ui.snapshot.state === 'running' || ui.snapshot.state === 'paused')) {
      notice('任务还在跑,先停止再重启靶场(否则在途的尝试会连到已关闭的端口)', 'bad');
      return;
    }

这句提示里的因果关系写得很准确:不是「不允许」,而是「会连到已关闭的端口」。重启靶场会让端口号全部改变,在途尝试连的是旧端口,得到的会是 ECONNREFUSED,被记成「出错」而不是「失败」。这两类在统计里是分开的,出错指的是连接层面的问题,失败指的是对端明确拒绝认证。混起来会让结果读错。

五、构建与部署

图 1:任务跑完之后的命中结果面板。右栏顶部七个统计格依次是 632 组合总数、632 已尝试、2 命中、630 失败、0 出错、1 秒用时、897.7 次每秒,进度条停在 100%,状态标「已完成」,左上按钮已经变成「再跑一次」。这四个数字之间是闭环的:632 等于 4 个目标乘 1 个用户名乘 158 条候选口令,630 等于 632 减 2,出错为 0 说明这 632 次连接全部成功建立、没有任何一次落到连接层异常。命中表两行分别是 FTP · 127.0.0.1:33629 的 admin / admin123 与 HTTP Basic · 127.0.0.1:46231/admin 的 admin / admin123,强度都标「弱」,说明列分别是「230 登录成功」与「200 可以访问受保护路径」——这两句正是 FTP 客户端状态机与 HTTP Basic 判定函数在成功分支返回的 note 原文。这两个命中对应靶场公开账号里的两组:FTP 那一套有 admin/admin123,HTTP Basic 那一套也有 admin/admin123,两者是刻意复用同一组弱口令用来演示凭据复用风险的。左栏的目标框里四项端口各不相同,33629、46231、33155、37909,印证了四个协议各起一个服务、各占一个系统分配端口这件事。

图 2:首次启动、还没填靶场目标的状态。右上「靶场 4 个端口在听」已经亮起,说明靶场在 app.whenReady 里就自动启动了,不用等用户操作。但左栏目标框里还是 index.html 里的占位示例 ftp://127.0.0.1:2121 与 http-basic://127.0.0.1:8080/admin,下方提示「还没有目标:点『填入靶场目标』可直接拿到本机靶场端口。」,这句话在 renderer.js 的 parseTargets 里——当输入框内容为空白时才显示,而这里是占位符,实际值是空的,所以提示出现。用户名框同样空着,下面的校验说「至少填一个用户名」。变异规则框里是默认的七条规则,下面一行绿字「7 条规则可用,按当前字典展开约 203 条候选(去重前)」,再往下是三条规则作用在前三个词上的效果:冒号原样得到 admin 与 administrator 与 root,c 得到 Admin,l 得到原样,$1 得到 admin1,$1$2$3 得到 admin123。字典区显示「有效 29 词 · 原始 30 行 · 注释 1」,前几个是 admin · administrator · root · guest · test · user。七个统计格全部是 0,状态标「未开始」。

图 3:右下角「关于」打开的弹层,底下压着图 1 那个跑完的任务。三段文字依次是开源声明、免责声明、完全开源。开源声明里列了五件事:字典变异规则编译、FTP 与 HTTP Basic 与 HTTP 表单与 SSH 风格四类协议握手、并发与限速调度、命中结果展示、报告导出(文本与 CSV 与 JSON),并写明内置只监听 127.0.0.1 的本地靶场、交互设计参考 Hydra 等开源登录审计项目的通用使用习惯、全部代码用 JavaScript 独立编写、不包含其任何源代码。免责声明写「本应用只对内置回环靶场发起认证尝试,用于登录审计相关功能的学习与验证,结果仅供参考,禁止用于任何未经授权的真实系统」。完全开源这一段写的是 Apache-2.0,与 app 目录下 package.json 里写的 MIT 不一致,这就是 4.3 里记下的 D7。

需要说明的是,三张截图里能作为证据的只有界面结构、七个统计格里的数字、两组命中记录、四个随机端口与字典的 29 / 30 / 1 这三个计数。这些数字与源码的对应关系在 3.2 与 3.4 里逐条对过。本文其余全部结论都来自源码逐行阅读与目录级计数,没有在设备上运行过这个应用,也没有执行 HAP 构建。

5.1 构建流程

在 DevEco Studio 里打开仓库根目录,选择 electron 入口模块构建;命令行方式是在工程目录下执行 hvigorw assembleHap 并把 product 与 module 参数指到 electron。如果 PATH 里没有 hvigorw,用 DevEco Studio 自带的那一份,路径在安装目录的 tools/hvigor/bin 下。

构建前需要确认四件事:

  • signingConfigs 指向的证书、profile 与密钥库三个文件都真实存在,且 profile 里登记的包名与 AppScope/app.json5 的 bundleName 一致。这一条对不上会在签名阶段报错,而不是在安装阶段。
  • web_engine/src/main/resources/resfile/resources/app 这个目录完整。判据很硬:16 个文件、134,643 字节,engines 下必须正好是七个 js——hydra-rules.js 8,149 字节、hydra-wordlist.js 3,044 字节、hydra-target.js 5,670 字节、hydra-protocol.js 11,193 字节、hydra-lab.js 4,035 字节、hydra-task.js 8,511 字节、hydra-report.js 11,953 字节。这个目录属于纯资源,构建系统不做任何检查,缺文件只会在运行时报错。
  • resfile 根目录下的运行时文件齐全。缺了 icudtl.dat 或 resources.pak 这类文件不会让构建失败,但启动时 Electron 内核会直接退出,表现是应用闪一下就没了。
  • nativeLib 的 collectAllLibs 保持为 true,四个 so 都在 electron/libs/arm64-v8a 下。这一项关掉的话应用能构建成功,但启动时会因为找不到 Electron 运行时直接退出。

还有一条不在清单里但很重要:不要改 electron/build/default/intermediates 下的那一份副本。它是构建时从 resfile 拷过去的,实测两边都是 16 个文件、134,643 字节,改了不会生效,也不会被下一次构建保留。

5.2 产物结构

仓库里已经有一份此前构建的产物,放在 electron/build/default/outputs/default 下:electron-default-signed.hap 195,332,162 字节、electron-default-unsigned.hap 193,872,547 字节。签名前后相差约 1.46 MB,这是签名块与 profile 信息的体积。

拆开看包里的两部分。业务代码在 resources/resfile/resources/app 下,与源码目录一一对应:index.html、main.js、package.json、renderer.js、engines 下七个 js、styles 下一个 css、samples 下四个 txt,共 16 个文件、134,643 字节。构建中间产物里的同一目录也是 16 个文件、134,643 字节——这从侧面印证了构建系统对这份目录是原样拷贝,不做任何加工。

运行时文件在 resources/resfile 根下,几样加起来约 17.9 MB:icudtl.dat 10,464,144 字节最大,其次是 resources.pak 5,777,343 字节、两个 pak 共 369,093 字节、两个语言包共 990,437 字节,外加两份快照与一个启动脚本。

原生库在 libs/arm64-v8a 下四个 so:libelectron.so 167,471,912 字节、libadapter.so 2,621,200 字节、libffmpeg.so 2,181,528 字节、libc++_shared.so 1,825,624 字节,合计 174,100,264 字节。仓库根目录的 lib.unstripped 下另有两份未裁剪的库——libelectron.so 1,143,668,440 字节、libadapter.so 15,494,016 字节,那是调试用的带符号版本,不进包。

体积上,四个 so 合计约 174 MB,而全部业务代码只有 134,643 字节,两者相差三个数量级。这意味着任何针对包体积的优化只要不碰 so 就没有意义;反过来也意味着业务代码可以放心写得细一点,不必为了省几 KB 去牺牲可读性。七个引擎合计 52,555 字节,占业务代码的 39.0%,其余六成是界面与主进程。

5.3 安装与启动

安装用 hdc install 加 -r 参数覆盖安装,启动用 hdc shell aa start 指定 EntryAbility 与包名、模块名。启动之后第一屏应当与图 2 一致:顶栏「靶场 4 个端口在听」已经亮起,左栏目标框是空的,右侧七个统计格全部为 0。这一点可以从源码确认——index.html 里只有一个 tab 带 on 类、一个 panel 带 on 类,就是运行日志那一对。

启动链路是 app.whenReady 那一段,三件事的顺序是写死的:

app.whenReady().then(function () {
  registerIpc();
  createWindow();
  startLab().catch(function (e) {
    console.warn('[Hydra] 靶场启动失败:' + errText(e));
  });

先注册 18 条 IPC,再建窗口,最后起靶场。这个顺序有讲究:窗口一建好就会加载 index.html,而 renderer.js 的 boot 第一步就是发 app:info,所以 IPC 必须先就位,否则第一条消息会落空。靶场放在最后并且不 await,是因为它不影响界面首屏——界面顶栏那个指示器靠自己每 2.5 秒轮询一次拉状态,靶场晚一两百毫秒起来也能被感知到。

而 startLab 内部是四个服务并行监听、全部成功后才把 running 置真:

server.listen({ host: '127.0.0.1', port: 0, exclusive: true }, function () {
        labState.servers[id] = server;
        labState.ports[id] = server.address().port;
        settle();
      });

三个参数都不是随手写的。host 固定 127.0.0.1,等于只绑回环网卡,局域网里的机器连不上。port 传 0,表示让系统从临时端口里挑一个,这样每次启动端口都不同,也就不存在端口冲突。exclusive 为 true,表示独占,别的进程不能复用这个端口。三者合起来保证了一件事:靶场只在本机、只在本次进程的生命周期里存在。

settle 函数负责计数,四个里有一个失败就整批回滚:

server.on('error', function (e) {
        failed = true;
        labLog('lab', '启动 ' + id + ' 失败:' + errText(e));
        stopLab();
        resolve({ success: false, error: '靶场启动失败:' + errText(e), ports: {}, running: false });
      });

这个「要么四个都在,要么一个都不留」的处理比「能起几个起几个」更合适。四个端口缺一个,用户拿到的目标清单就是不完整的,任务会跑出一半失败一半成功的结果,看起来像是应用有问题,实际是靶场没起全。回滚之后顶栏指示器会显示「靶场未启动」,用户点一次「重启靶场」就能重试。

这条链路没有在设备上跑过,但代码路径是闭合的:registerIpc 注册 18 个 handle,每个都被 try/catch 包着,失败返回中文错误;createWindow 的失败只打日志不阻断;startLab 的失败同理。所以应用一定能起来,最坏的情况是窗口空白或者靶场不可用,两种都能通过日志定位。唯一的隐患是 createWindow 静默失败时界面完全空白,这一点已经记在 D4。

六、常见问题与解决方案

Q1 目标明明写的是 127.0.0.1,点开始还是报「目标 FTP · 127.0.0.1:2121 的端口不是本次靶场的端口,请点『填入靶场目标』重新生成」,可我确实点过了。

问题现象:目标框里是一份看起来完全正确的清单,地址是回环、端口是五位数,点开始却直接被拒,错误信息里带着那个端口号。再点一次「填入靶场目标」,端口变了,这次能跑。

根因分析:这是 task:start 里的第二道闸在起作用,它和回环判定是两件不同的事。回环判定管的是「地址属于本机」,这道闸管的是「端口属于本次进程起的那个靶场」:

/* 目标端口必须是靶场自己起的端口,防止把回环上的其它服务当成靶子 */
    var ports = labState.ports;
    for (var i = 0; i < prep.targets.length; i++) {
      var t = prep.targets[i];
      if (ports[t.protocol] && t.port !== ports[t.protocol]) {

为什么需要这一道?因为回环地址上不只有这个应用的靶场。一台开发机上同时跑着数据库、开发服务器、调试端口是很常见的事,光靠「是 127.0.0.1 就放行」挡不住误伤。加了这道闸之后,唯一能通过的目标就是本次进程自己起的四个端口。

触发这条错误的情形有三种。第一种最常见:重启过靶场。startLab 每次都传 port 0,端口由系统重新分配,所以重启之后四个端口全变,但目标框里的文本还是旧的。第二种:照着 samples/targets.txt 里那四行抄的 2121、2222、8080 ——那份样例的注释里已经写明「下面只是写法示例,直接拿去跑会被拒绝」。第三种:应用重启过,端口重新分配了,而偏好文件里存的目标文本还是上一次会话的。

解决方案:每次都点一次「填入靶场目标」,它会调 lab:targets 重新拿端口并生成清单,四行分别是 ftp://127.0.0.1:端口、http-basic://127.0.0.1:端口/admin、http-form://127.0.0.1:端口/login、ssh-lab://127.0.0.1:端口。如果改过端口之后仍然报同样的错,检查是不是两个 http 协议写了同一个端口——四个协议是四个独立服务,http-basic 与 http-form 各占一个端口,截图里就是 46231 与 33155,不可能相同。

教训:这类「地址合法但对象不对」的校验,错误信息里必须带上具体的值。这条信息带了目标 label、带了建议动作,用户能自己解决。反例是只说「目标不可用」,那样用户会去怀疑地址写法。

Q2 界面统计显示「命中 2」,但靶场日志里的请求数远远不止 2 条,命中数是不是算错了?

问题现象:跑完一次任务,命中表只有两行,可靶场面板的日志一直在滚,明显有几百条请求进过靶场。

根因分析:命中数是「通过认证的组合数」,不是「进入靶场的请求数」。632 次尝试里有 630 次被明确拒绝,它们的响应是 FTP 的 530 或者 HTTP 的 401,这些都不计入命中,只计入失败。所以统计格里的四个数是这个关系:已尝试等于命中加失败加出错,出错是连接层异常(连不上、超时),失败是连接成功但认证被拒。

另一个容易混的地方是每个协议两拍。FTP 一次尝试要发两条命令,USER 一条、PASS 一条;靶场的 hitCounter 是每收到一行就加一,所以日志里的编号会比尝试数大。SSH 风格是一次尝试两条(问候不算,AUTH 一条),HTTP 是一次一条。这就是为什么日志里有几百行而尝试只有 632 次——实际行数取决于协议分布。

解决方案:想看准确的尝试计数就看统计格与报告里的「已尝试」,这两个是同一个字段。想看逐条明细就导 CSV 或 JSON,CSV 里每一条命中占一行,末尾附统计段。靶场日志是给人看协议的,不是计数用的。

教训:一个界面上同时出现「请求数」与「尝试数」两个量级不同的数字时,必须让它们的口径写清楚。这个应用在这一点上做得可以——靶场日志用 # 编号,报告用 tried,措辞不同,不容易混。

Q3 界面上写着「口令一律脱敏」,可命中表里明明是 admin123 这样的明文,是不是漏了?

问题现象:跑出结果之后,命中表「口令」一列是完整的明文,报告里也是;而事件流里同一组凭据显示成保留首尾字符、中间换成三个星号的样子,靶场日志里显示成 PASS 加三个星号。

根因分析:这不是漏了,是分层的。全工程一共四套处理,各管一段。事件流用 hydra-task 的 maskPass,保留首字符加三个星号加尾字符;靶场日志用 main.js 里那两处正则替换,PASS 整段变星号、AUTH 保留用户名但把口令变星号;而命中记录在任何一处都不脱敏。

为什么命中记录要留明文?因为它的用途是核对规则效果。规则是按首尾特征拼接的,如果命中记录也脱敏,用户就没法判断是「$1$2$3 拼出来的 admin123」还是「sa@ 拼出来的」,规则调试就失去了反馈。这是刻意的取舍,报告里的边界声明第三条专门说这件事。

反过来也有一个真实的泄密路径要知道:命中记录会进偏好之外的所有出口,包括剪贴板。命中表是普通 DOM 表格,可以框选复制,复制出去就是明文。这一点链路上没有任何拦截。

解决方案:需要把结果贴出去时优先用报告,因为报告的三种格式都在末尾带三条边界声明,接收方能看到「这些是靶场凭据」这句话。要贴截图就用事件流那一栏,那里是脱敏的。最稳妥的是跑完之后先把命中记录用于自己的规则调试,然后清掉界面上的结果——重跑一次就是干净状态。

教训:脱敏不是一个全局开关,是分层的。这个应用把「哪些地方该脱敏」写成了三套策略,并且用报告里的三条 caveat 兜住了唯一一处故意不脱敏的位置。这个结构是对的;缺的是界面上的说明——「口令只在这里显示明文,日志中一律脱敏」这句话写在命中表头上,很到位,但它没说复制走之后会怎样。

Q4 按下「停止」之后,统计格还在往上跳,状态标也还显示「运行中」,要等一两秒才真正停下。

问题现象:点停止,按钮变灰了,但已尝试的数字继续涨几下,状态标停一两个心跳才变成「已停止」。

根因分析:三个原因叠在一起,都很具体。

第一,暂停与停止都不中断在途的尝试。调度器的 worker 是一个递归的 step 函数,每轮开头才检查 _stopped 与 _paused,检查完就去取任务、发起握手。已经发出去的那一次不会被打断——停在这里意味着少记一条结果,而记账的一致性比「立刻停」更重要。

第二,真正结束要等 Promise.all 结算。start 里起了一组 worker,最后用 Promise.all 等它们全部返回;而每个 worker 要等自己手里那次 attempt 返回。attempt 就是 handshake,它自带一个定时器兜底:

var timer = setTimeout(function () {
      finish({ ok: false, error: true, note: '超时:' + timeoutMs + ' 毫秒内没有完成握手' });
    }, timeoutMs);

超时默认 4000 毫秒、可调范围 500 到 15000。所以最坏情况下,按下停止之后界面要等一个完整超时周期才安定下来。

第三,界面是靠 400 毫秒轮询感知状态的。停止之后,worker 的 step 在某些路径上还会走一轮,_record 会继续累加。所以你会看到数字多跳几下。

解决方案:点停止之后等状态标变成「已停止」再看结果,别在中间读数。要缩短这个等待,把「单次超时」调小——界面上那一格允许 500 到 15000 毫秒,靶场在本机回环,正常握手在个位数毫秒内完成,设成 500 到 1000 完全够用,同时让停止的响应快很多。暂停的语义与停止类似,界面上那句「已暂停(当前在途的尝试会跑完)」就是这个意思。

教训:一个带超时兜底的并发任务,它的「停止」语义天然是「不再发起新的」,而不是「立刻停止」。这一点必须在界面上说清楚——这个应用在暂停的提示里说了,在停止的提示里只说了「已发出停止请求」,差一句「在途的会跑完」。这两句话的差别就是用户会不会去点第二次停止。

Q5 规则预览说「约 203 条候选」,统计格里组合总数却是 632,这两个数对不上,是不是哪一个算错了?

问题现象:左栏规则区的绿字写「7 条规则可用,按当前字典展开约 203 条候选(去重前)」,跑起来之后统计格写「组合总数 632」。4 个目标乘 1 个用户名乘 203 应该是 812,怎么也不等于 632。

根因分析:两个数字来自两个函数,口径不同,而界面上那句「去重前」三个字是唯一的分辨线索。

203 来自 Rules.count,它只做一次乘法:29 个词乘 7 条有效规则。这个函数连展开都不做,就是为了在用户打字时快速给一个规模感。

632 来自 prepare 里的另一条路:真正展开成 203 条原始候选,然后整体去重,剩 158 条,再乘目标数与用户名数。4 乘 1 乘 158 等于 632,与截图完全一致。

45 条重复从哪来?默认七条规则里,冒号与 l 转小写对本来就是小写的词产出同一个结果;c 首字母大写的定义是首字母大写加其余小写,对全小写词的产出也与冒号相同。内置字典 29 个词绝大多数是全小写,所以这三条规则大面积重合。ASCII 词的重复率就是这么来的。

解决方案:把「约 203 条候选」当成规则数量的指示器,不要当成任务规模的预估。要看真实规模,看界面上那个会随输入变化的组合总数——但那也得跑起来才有。最准的预判办法是自己算:词数乘有效规则数,减去肉眼可见的重复(冒号、l、c 三条对小写词通常收敛到同一个结果)。

教训:「去重前」这三个字救了这个功能。如果只是写「展开约 203 条候选」,用户会拿去乘目标数,得到一个偏大 28% 的预估。需要给数字的地方,要么给准确的,要么把口径写进同一行——这个应用选了后者,而且写在了括号里,位置也对。

Q6 从样例文件里载入规则,注释行和换行都没了,全挤成一行,是不是样例读坏了?

问题现象:点「样例文件」载入 rules.txt,那一行里原本分十几行的注释与说明全部消失,只剩最后一行的规则串,而且用空格连成一行。

根因分析:这是渲染层专门为规则框做的处理,写在 loadSample 里:

if (target === 'rules') {
        /* 规则框是单行输入:注释行与换行都要先在界面上吃掉 */
        text = text.split(/\r?\n/).filter(function (line) {
          return line.trim() && line.trim().charAt(0) !== '#';
        }).join(' ');
      }

原因很直白:规则输入框是 input type=text,单行控件,塞进去多行文本只会显示第一行,其余全被吞掉——而且是静默吞掉,用户以为样例里只有一行。所以渲染层在塞进去之前先把注释行与空行滤掉,剩下的用空格连起来。

samples/rules.txt 本身也是按这个预期写的:前十一行是注释,说明每个操作符的作用,最后一行才是真正要跑的规则串。这个设计的好处是样例文件同时充当了速查表,坏处是载入之后看不到那份说明。同样的处理没有用在目标、用户名、字典三处,因为那三处都是 textarea,多行没问题。

解决方案:想看操作符说明,直接打开 samples/rules.txt 看原文件,或者看规则区下面那三行「前 3 个词的效果」预览——那是真正按当前字典算出来的,比注释更可信。想在界面上保留注释,把规则串自己手动粘进输入框,单行控件只认一行,注释留不住。

教训:单行控件与多行文本之间要有显式转换,而且转换规则要写在注释里。这里做对了两件事:转换有注释,样例文件也按转换后的形态设计。差的是界面上的反馈——载入后弹的那句「已载入样例 rules.txt → 规则」没说「注释行已滤除」,用户会以为是文件本身只有一行。

Q7 应用里说遵循 Apache-2.0,package.json 里写 MIT,oh-package.json5 里的 license 是空的,到底按哪个?

问题现象:打开右下角关于弹层,「完全开源」那一段写的是 Apache-2.0;app 目录下的 package.json 第 17 行 license 字段写 MIT;ohos_hap 根目录的 oh-package.json5 里 license 是空字符串;web_engine 模块的 oh-package.json5 里写 Apache-2.0。仓库根目录只有 lib.unstripped、ohos_hap 与两份说明文档,没有 LICENSE 或 COPYING 之类的许可证全文。

根因分析:这不是理解差异,是这份仓库里真实存在的矛盾,已经作为 D7 列在 4.3 的缺陷清单里。四种说法分别由不同的环节读取——package.json 是机器可读的元数据,打包工具、依赖分析工具、开源合规扫描都读它;oh-package.json5 是鸿蒙侧的包描述;关于弹层里的文字是给人看的,读者是最终用户。

两种许可证的约束方向完全不同:Apache-2.0 要求保留声明与变更说明,允许闭源分发;MIT 更宽松,只要求保留版权与许可声明。把两者写在同一份仓库里,等于同时承诺了两种不同的义务,而空字符串则等于什么都没承诺。

解决方案:在冲突被修正之前,按更严的那一份理解——也就是按 Apache-2.0。理由很实际:如果实际义务是 Apache-2.0 而你按 MIT 行事,那是漏了变更说明这条义务;反过来最多是自己多给了权利,不会伤害到任何人。

真要修正,正确的顺序是先确定用哪一份,然后在仓库根放一份完整许可证全文,再让四处同时指向它。四处一致才算定下来,只改一处会留下新的矛盾——比完全没写更麻烦,因为读的人无法判断哪一处才是真的。

教训:许可证声明是最容易被当成填空题的一行元数据,而它恰恰是分发时唯一会被逐字核对的东西。这个仓库连许可证全文都没有,说明这一行从来没有被认真对待过。上架前的检查清单里应该有单独一条:许可证全文存在、app 的 package.json、ohos_hap 与各模块的 oh-package.json5、界面里的声明文字,四处必须一致。

七、总结

Hydra 是一个把「规则编译」「协议握手」「并发调度」「报告渲染」四件事都放在 JavaScript 里做完的桌面应用。它的界面背后没有一个功能是假的:靶场是真的 TCP 服务,命中是真的握手判定,报告是真的从同一份快照渲染出来的三种格式。下面的表把十六个文件的能力逐项落到位:

能力实现位置关键实现
规则编译hydra-rules.js16 个操作符、三类错位检测、不抛异常的解析器、步骤链求值
候选展开hydra-rules.js词乘规则顺序产出、20 万条上限、超限标 truncated、非法规则跳过并计数
字典解析hydra-wordlist.js剥注释、去空行、去重、128 字符单词上限、29 词内置字典
回环准入hydra-target.js四种写法白名单、四段 0 到 255 校验、拒绝内联凭据、按行号报错
协议状态机hydra-protocol.jsFTP 四拍、SSH 风格两拍、两种 HTTP 判定、手写 base64、口令脱敏
靶场服务main.js绑 127.0.0.1、端口由系统分配、独占监听、64 KB 缓冲上限、10 秒空闲超时
端口二次栅栏main.js目标端口必须等于本次靶场的端口,防止误伤回环上的其它服务
并发调度hydra-task.js自增下标抢任务、16 并发上限、共享节拍限速、暂停与停止不中断在途
进度轮询renderer.js400 毫秒拉快照、终态自动停表、命中非空自动跳命中页
靶场轮询renderer.js2500 毫秒无条件刷新,顶栏指示器始终准
口令强度hydra-lab.js四类字符计数、五条弱口令特征、评分扣减、三档标签
报告组装hydra-report.js同一份对象三个出口、三条边界声明、中文宽度表
文本报告hydra-report.js六章结构、按显示宽度补齐与截断、六个列宽上限
CSV 导出hydra-report.jsBOM 前缀、三条件转义、CRLF 行尾、末尾附统计段
窗口与 18 条 IPCmain.js0.92 与 0.9 屏比、最小 1024 乘 660、统一 handle 包装与中文错误码
偏好与样例main.js 与 renderer.js900 毫秒防抖落盘、四类样例按扩展名白名单读取、规则样例按单行控件预加工

回顾整条链路,有三条经验值得写下来。

第一,把安全边界写在解析阶段,而不是运行期的开关,是这一类工具唯一能被允许存在的前提。这个应用的准入判定不是一句文档里的免责声明,而是 hydra-target.js 里那张只认四种写法的白名单,加上 main.js 里那道「端口必须是本次靶场的端口」的第二道闸。两者合起来的含义很硬:想让它去碰别的机器,没有任何开关可以做到。这与前面几篇里那些纯计算类应用完全不同——那些应用的边界是功能边界,怎么写都不出事;这个应用的边界就是它的存在理由。代价也很明确:没有任何灵活性。用户如果想让它在容器里连一个映射到本机端口的靶场,做不到,因为容器里的 127.0.0.1 和宿主机的 127.0.0.1 不是同一个;如果需要这种能力,只能改代码,而改代码这件事本身就是一个明确的、可以被审查的动作。这个设计是对的:把「灵活」换成「不可被误用」,对一个带攻击语义的工具来说,这笔交换永远划算。

第二,同一份状态机给客户端与服务端两边用,是这个应用里最容易被忽略也最值得学的一处结构。hydra-protocol.js 里每套协议都有 clientXxx 与 serverXxx 两份,但它们共享同一份字符串比较逻辑——FTP 的 220、331、230、530,SSH 风格的 AUTH OK 与 AUTH FAIL,HTTP 的 200 与 401。如果两边各写一套,最典型的 bug 就出来了:服务端返回「230 登录成功」而客户端只认 230 这个数字前缀,看着能跑;某天有人把服务端文案改成「230 认证通过」,数字没变,还能跑;再某天有人把状态码改成 2xx 通配,客户端仍然只认 230,于是服务端认为成功、客户端认为失败,得到一条假失败。共用一份判定逻辑,这类偏差在结构上就不可能发生。代价是两个方向的需求会互相牵制——服务端想多返回一句提示,客户端就得跟着能处理它,改一处要想到两处。这个约束反而让协议定义更稳。

第三,脱敏必须分层,而且每一层都要说得出「为什么这一层不脱敏」。这个应用一共四套处理:事件流的 maskPass 保留首尾、靶场日志整段替换、协议模块的 mask 保留首尾、命中记录完全不脱敏。前三种的理由都是为了防截图与防日志外流,第四种的理由恰恰相反——命中记录是用来核对规则效果的,脱敏之后就失去了意义。这个分工如果反过来,比如事件流里放明文、命中表里脱敏,调试体验会立刻崩掉:用户看到一条命中,却不知道是哪条规则拼出来的。更值得学的是它用报告里的三条 caveat 兜住了第四种:报告是要被转发、贴进工单、存档的东西,声明跟着报告走,比在文档里写免责有效得多。这一点看着是文案功夫,实际是数据流向的设计——每一条脱敏边界,都应该有一个明确的下游消费者在替它背书。

最后把上架前的必做项收拢成四句:把 bundleName、vendor、app_name 与 EntryAbility_label 从模板默认值改成实际值,并且先改包名再改签名;把权限表从 26 项裁到真正用得上的那几项,顺手把 11 条指向 FormAbility 的 usedScene 全部修掉或删掉;把四处许可证说法统一成一份并在仓库根放上全文,同时清掉指向 test-hydra-engine.js 的那个 test 脚本;给窗口创建补一条关掉硬件加速的开关和一次可诊断的失败提示,并在停止的提示里补上「在途的尝试会跑完」。四件都不涉及业务逻辑,改完之后应用的功能与现在完全一样,但它从「一个能跑的壳」变成了「一个敢让人装到自己机器上的壳」。

Logo

作为“人工智能6S店”的官方数字引擎,为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐