Obscura 可靠性机制——V8 Watchdog、panic 安全与 SSRF 防护

// obscura-js/src/runtime.rs
// 在独立线程中运行 watchDog
fn arm_watchdog(isolate: &v8::Isolate, timeout_ms: u64) {
    let isolate_handle = isolate.thread_safe_handle();
    std::thread::spawn(move || {
        std::thread::sleep(Duration::from_millis(timeout_ms));
        isolate_handle.terminate_execution();
    });
}
 
fn run_event_loop_bounded(isolate: &v8::Isolate, budget_ms: u64) {
    arm_watchdog(isolate, budget_ms);
    // 运行 V8 事件循环
    // 如果超时，watchdog 线程调用 terminate_execution
}
```bash
 
`terminate_execution()` 从独立线程终止 V8 的执行。这会抛出一个不可捕获的异常，终止当前运行的 JavaScript 代码。
 
Watchdog 拦截的场景：
 
- `--eval` 执行时间过长
- 页面加载后的 JS 微任务风暴
- 导航事件循环泵取超时
 
CDP 层还有一层独立的 watchdog：
 
```rust
// obscura-js/src/cdp_watchdog.rs
// 每个 CDP 命令都受此 watchdog 保护
// OBSCURA_CDP_COMMAND_TIMEOUT_MS（默认 60s）
```bash
 
如果一个页面通过 CDP 发起的 `Runtime.evaluate` 卡住了 V8，CDP watchdog 会终止它并释放锁，让其他 session 可以继续工作。
 
## 问题 2：DOM 操作崩溃 → panic 安全层
 
Rust 中的 panic 默认会栈展开（stack unwind）。如果 panic 发生在 V8 的 FFI（Foreign Function Interface）帧中，展开会穿越 C++ 边界，导致**进程 abort**。
 
Obscura 的解决方案：每个 DOM op 用 `catch_unwind` 包裹。
 
```rust
// obscura-js/src/ops.rs
fn op_dom(...) -> Result<Value, Error> {
    let result = std::panic::catch_unwind(|| {
        // 执行 DOM 操作
        dom_tree.insert_before(parent_id, ref_id, new_id)
    });
 
    match result {
        Ok(Ok(value)) => Ok(value),
        Ok(Err(e)) => Err(e),
        Err(panic_payload) => {
            // panic 不会展开进入 V8
            // 返回 null 并记录错误
            tracing::error!("DOM op panicked: {:?}", panic_payload);
            Ok(Value::Null)
        }
    }
}
```bash
 
`catch_unwind` 捕获 panic 后返回 `null` 而不是展开到 V8 帧中。为了这个机制正常工作，release profile 必须使用 `panic = "unwind"`（而不是 `panic = "abort"`）：
 
```toml
# Cargo.toml — 已在 workspace 中固定
[profile.release]
panic = "unwind"
```bash
 
## 问题 3：循环 DOM 树 → 树操作守卫
 
一个真实发生过的 bug：`append_child` 允许将一个祖先节点插入为子节点。这导致 `descendants()` 方法无限递归，永久卡死引擎，且没有任何超时能中断（因为这是 Rust 同步代码，V8 watchdog 不会触发）。
 
修复：`tree.rs` 中的 `append_child` 和 `insert_before` 拒绝任何会导致循环的操作。
 
```rust
// obscura-dom/src/tree.rs
fn append_child(&mut self, parent: NodeId, child: NodeId) {
    // 拒绝：child 是 parent 的祖先
    if self.is_ancestor_of(child, parent) {
        return; // 静默拒绝
    }
    // 执行插入
}
 
fn is_ancestor_of(&self, ancestor: NodeId, node: NodeId) -> bool {
    // 从 node 向上遍历到 root
    // 如果遇到 ancestor，返回 true
}
```bash
 
`descendants()` 还有一个硬编码的长度上限，作为终极兜底。
 
## 问题 4：SSRF 防护
 
Obscura 默认阻止以下地址的访问：
 
- **Loopback**：`127.0.0.0/8`、`::1`
- **RFC1918**：`10.0.0.0/8`、`172.16.0.0/12`、`192.168.0.0/16`
- **Link-local**：`169.254.0.0/16`（含云元数据端点 `169.254.169.254`）
- **IPv6 唯一本地地址**：`fc00::/7`
- **未指定地址**：`0.0.0.0`、`::`
- **所有 IPv4-mapped 形式的上述地址**
 
校验执行两次：
 
1. **URL 解析时**：检查主机名是否为禁止地址
2. **DNS 解析后**：DNS 重新绑定防护——即使域名解析到内网 IP，也会在连接时被阻止
 
```rust
fn validate_fetch_url(url: &Url) -> Result<(), SsrfError> {
    // 检查 URL 中的主机
    if is_private_host(url.host_str().unwrap_or("")) {
        return Err(SsrfError::Blocked);
    }
    Ok(())
}
```bash
 
绕过方式：`--allow-private-network` 全局参数（或 `OBSCURA_ALLOW_PRIVATE_NETWORK=1` 环境变量）。
 
## 问题 5：脚本 fetch/XHR 超时
 
`op_fetch_url` 处理来自 JS 侧 `fetch()` 和 `XMLHttpRequest` 的请求。如果没有超时，一个发送请求后永不响应的服务器会导致 XHR 永久挂起——没有完成事件、没有错误、无法超时。
 
```rust
// OBSCURA_FETCH_TIMEOUT_MS（默认 30s）
let fetch_timeout = Duration::from_millis(fetch_timeout_ms);
 
let result = tokio::time::timeout(fetch_timeout, client.fetch(&url)).await;
match result {
    Ok(Ok(response)) => // 正常响应
    Ok(Err(e)) => // 请求错误
    Err(_) => // 超时
}
```bash
 
同时影响：JS 的 `fetch()`、`XMLHttpRequest` 和 ES module 加载。
 
## 超时体系全景
 
Obscura 有四层超时机制，从最内层到最外层：
 
| 层级 | 配置变量 | 默认值 | 作用域 | 说明 |
|------|---------|--------|--------|------|
| 导航超时 | `OBSCURA_NAV_TIMEOUT_MS` | 30s | `Page.navigate` + CLI `fetch` | 单次导航硬限 |
| CDP 命令超时 | `OBSCURA_CDP_COMMAND_TIMEOUT_MS` | 60s | 所有 CDP 命令 | 防止一个 session 锁住 V8，可关闭（设为 0） |
| Fetch 超时 | `OBSCURA_FETCH_TIMEOUT_MS` | 30s | JS fetch/XHR/module | 防止无响应服务永久挂起 XHR |
| 进程硬截止（fetch 命令） | 编程设置 | timeout + wait + 10s | `fetch` 子命令 | 独立线程 `std::process::exit(124)`，终极兜底 |
 
`fetch` 命令的进程级硬截止实现：
 
```rust
// crates/obscura-cli/src/main.rs
let hard = Duration::from_secs(timeout_secs + wait_secs + 10);
std::thread::spawn(move || {
    std::thread::sleep(hard);
    std::process::exit(124);
});
```bash
 
如果所有超时都失效，这个线程会在 `timeout + wait + 10` 秒后强制退出进程。这对于 `fetch` 命令是合理的——单次抓取失败总比永远不返回好。
 
## 总结
 
Obscura 的可靠性设计可以概括为"每层都有兜底"：
 
1. **JS 层**：V8 terminate_execution watchdog 终止死循环
2. **Rust 层**：catch_unwind 阻止 panic 展开到 V8 FFI
3. **DOM 层**：循环引用守卫 + descendants 长度上限
4. **网络层**：SSRF 双重校验 + fetch 超时 + DNS 重新绑定防护
5. **协议层**：CDP 命令 watchdog 防止 session 锁住 V8
6. **进程层**：fetch 命令的硬截止线程
 
这套体系确保了在大多数异常情况下，Obscura 不会崩溃或永久挂死。