Realms API 提案：安全地加载和执行第三方代码的沙箱机制

Realms API 提案：安全地加载和执行第三方代码的沙箱机制

各位同仁，下午好。

今天，我们将深入探讨一个在现代软件开发中日益凸显的挑战——如何在保障系统安全的前提下，灵活地加载和执行来自不可信源的第三方代码。从浏览器插件到服务器less函数，从富文本编辑器中的自定义脚本到应用程序内的市场化扩展，对这种能力的需求无处不在。然而，伴随便捷而来的，是巨大的安全隐患：恶意代码可能窃取数据、破坏系统、滥用资源，或者仅仅是意外的缺陷也可能导致整个应用崩溃。

长期以来，我们尝试了多种沙箱技术来应对这些挑战，例如浏览器中的iframe，Web Worker，以及Node.js环境下的vm模块。它们在各自的领域内发挥了作用，但也或多或少存在局限性：iframe过于笨重且面向UI，Web Worker缺乏对JS运行时全局环境的精细控制，而Node.js的vm模块则需要极高的安全配置专业性才能避免逃逸。

正是在这样的背景下，TC39（ECMAScript 标准化委员会）提出了Realms API。Realms API旨在提供一个在JavaScript语言层面原生、健壮、可配置的沙箱机制，允许我们在同一个JavaScript运行时中，创建并管理多个相互隔离的全局环境。它不仅仅是一个新的工具，更是一种范式转变，为我们构建更安全、更弹性的应用开辟了新的道路。

今天的讲座，我将带领大家：

1. 理解Realms的核心概念及其解决的问题。
2. 深入探索Realms API的设计与用法，包括如何创建、执行和通信。
3. 探讨如何利用Realms构建一个真正安全的沙箱环境，并提供实用的代码示例。
4. 分析Realms在安全方面的深层考量与挑战。
5. 将Realms与现有沙箱技术进行对比，突出其独特优势。
6. 展望Realms的未来及其对软件生态的影响。

一、Realms：核心概念与必要性

1.1 隔离的必要性：为何我们需要沙箱？

想象一下，你正在开发一个笔记应用，用户希望能够通过插件来扩展其功能，比如一个自定义的Markdown渲染器或者一个代码高亮插件。这些插件由不同的开发者编写，你无法完全信任它们。如果没有沙箱，一个恶意或有缺陷的插件可能会：

• 数据窃取： 访问并上传用户的笔记内容。
• 破坏UI/UX： 修改DOM结构，劫持用户输入事件。
• 拒绝服务 (DoS)： 执行无限循环，耗尽CPU资源；或者分配大量内存，导致应用崩溃。
• 权限滥用： 访问网络、本地存储等敏感资源。
• 原型污染： 修改内置对象的原型，从而影响整个应用的行为，甚至导致安全漏洞。

传统的JavaScript运行时，所有代码都共享一个全局对象（window或globalThis）和一套内在对象（Object、Array、Function等构造函数及其原型）。这种共享环境使得任何一段代码都有能力影响到整个应用，这正是安全挑战的根源。

1.2 Realms是什么？

Realms API 的核心思想是创建一个隔离的JavaScript全局环境。你可以将一个Realm想象成一个“微型JavaScript世界”，它拥有自己独立的全局对象、一套独立的内置对象（称为“内在对象”或“primordials”），以及自己独立的模块加载器。

关键在于：

• 独立的全局对象： 每个Realm都有自己的globalThis。在一个Realm中声明的全局变量，在另一个Realm中是不可见的。
• 独立的内在对象： 每个Realm都有自己版本的Object、Array、Function等构造函数。这意味着在一个Realm中修改Array.prototype不会影响到另一个Realm的Array.prototype。这对于防止原型污染至关重要。
• 隔离的代码执行： 在一个Realm中执行的代码，默认情况下无法直接访问或修改其宿主（创建它的Realm）或兄弟Realm的环境。

Realms提供了一种语言层面的隔离，而不仅仅是进程级别或线程级别的隔离。它允许我们在同一个内存空间和事件循环中运行多个相互隔离的JavaScript环境，这比iframe或Web Worker更轻量，且具有更细粒度的控制。

1.3 Realms与现有沙箱机制的对比（简述）

特性/机制	iframe	Web Worker	Node.js vm	Realms
隔离级别	进程/事件循环，独立UI	线程/事件循环，无UI	同进程，可配置上下文	同进程/事件循环，语言层面
全局对象	独立 window	独立 self	可配置 global	独立 globalThis
内在对象	独立（不同JS引擎实例）	共享（相同JS引擎实例）	共享（相同JS引擎实例）	独立（通过膜机制和隔离）
DOM访问	有	无	无	无（除非显式暴露）
通信方式	postMessage (基于结构化克隆)	postMessage (基于结构化克隆)	共享对象/事件 (高风险)	通过膜代理对象/函数，或结构化克隆
开销	重量级，加载HTML/CSS，独立渲染进程	中等，独立线程	轻量级，但配置不当易逃逸	轻量级，JS原生
主要用途	UI隔离，跨域内容	后台计算，避免阻塞主线程	服务器端沙箱，代码执行	语言层面的安全隔离，插件/扩展系统

Realms 的核心优势在于它在“轻量级”和“强隔离”之间找到了一个更好的平衡点，特别是在内在对象隔离方面，它提供了比Web Worker和Node.js vm更强的保障，而无需承担iframe的额外开销。

二、Realms API 深入解析

Realms API 目前（截止到我所了解的最新进展）处于TC39的Stage 3阶段，这意味着其设计相对稳定，但仍可能存在细微调整。我们将基于当前提案来学习其核心用法。

2.1 创建一个Realm

创建一个Realm非常简单，通过Realm构造函数即可：

// 宿主环境 (Host Realm)

// 1. 创建一个最简单的 Realm
const guestRealm = new Realm();
console.log('Guest Realm created successfully.');

// 2. 验证隔离性：在宿主环境的全局对象上定义一个变量
globalThis.hostVariable = 'Hello from Host!';

// 3. 在 guestRealm 中尝试访问 hostVariable
try {
    const result = guestRealm.evaluate('typeof hostVariable');
    console.log(`In Guest Realm, typeof hostVariable: ${result}`); // 应该输出 'undefined'
} catch (error) {
    console.error('Error evaluating in guestRealm:', error);
}

// 4. 在 guestRealm 中定义一个变量
guestRealm.evaluate('globalThis.guestVariable = "Hello from Guest!";');

// 5. 在宿主环境尝试访问 guestVariable
console.log(`In Host Realm, typeof guestVariable: ${typeof globalThis.guestVariable}`); // 应该输出 'undefined'
console.log(`In Host Realm, globalThis.guestVariable: ${globalThis.guestVariable}`); // 应该输出 undefined

// 6. 验证内在对象的隔离性
const hostArrayPrototype = Array.prototype;
const guestArrayPrototype = guestRealm.evaluate('Array.prototype');

console.log('Host Array.prototype === Guest Array.prototype:', hostArrayPrototype === guestArrayPrototype); // 应该输出 false

// 7. 在 guestRealm 中修改 Array.prototype
guestRealm.evaluate(`
    Array.prototype.customMethod = function() {
        return "Custom from Guest";
    };
`);

// 8. 在宿主环境中检查 Array.prototype
console.log('Host Array.prototype has customMethod:', 'customMethod' in hostArrayPrototype); // 应该输出 false

// 9. 在 guestRealm 中使用 customMethod
const guestResult = guestRealm.evaluate(`
    const arr = [1, 2, 3];
    arr.customMethod();
`);
console.log('Guest Array customMethod result:', guestResult); // 应该输出 'Custom from Guest'

// 10. 在宿主环境中尝试使用 customMethod
try {
    const hostArr = [4, 5, 6];
    // hostArr.customMethod(); // 这会导致 TypeError: hostArr.customMethod is not a function
    console.log('Host Array customMethod result (should fail):', 'customMethod' in hostArr);
} catch (error) {
    console.warn('Expected error when calling customMethod on host Array:', error.message);
}

这段代码清晰地展示了Realms如何提供全局对象和内在对象的隔离。hostVariable和guestVariable无法相互访问，Array.prototype在两个Realm中是完全独立的实例，一个Realm中对其的修改不会影响另一个Realm。

2.2 在Realm中执行代码

Realms提供了两种主要的代码执行方式：

2.2.1 realm.evaluate(codeString)

这是最直接的方式，将一个JavaScript代码字符串在Realm的上下文中执行。

const guestRealm = new Realm();

// 执行一个简单的表达式
const result1 = guestRealm.evaluate('1 + 2');
console.log('Result of 1 + 2:', result1); // 3 (注意：原始类型值会直接返回)

// 执行一个复杂一点的代码块
const result2 = guestRealm.evaluate(`
    let x = 10;
    const y = 20;
    function add(a, b) {
        return a + b;
    }
    add(x, y);
`);
console.log('Result of add(x, y):', result2); // 30

// 在Realm中定义一个全局函数
guestRealm.evaluate(`
    globalThis.greet = function(name) {
        return "Hello, " + name + " from Guest Realm!";
    };
`);

// 尝试在宿主中调用 greet - 会失败
try {
    // greet('World'); // ReferenceError: greet is not defined
} catch (e) {
    console.warn('Expected error trying to call guestRealm.greet from host:', e.message);
}

// 通过 importValue 调用 guestRealm 中的 greet 函数 (将在通信章节详细介绍)
// const guestGreet = guestRealm.importValue('globalThis', 'greet'); // 假设 importValue 可以这样用
// console.log(guestGreet('Alice'));

realm.evaluate是同步的，这意味着它会阻塞宿主Realm直到代码执行完毕。对于长时间运行或可能抛出错误的不可信代码，需要谨慎使用。

2.2.2 realm.importValue(specifier, name) 和 realm.exportValue(value, name) (提案中的高级通信机制)

realm.importValue和realm.exportValue是更安全、更模块化的通信机制，它们允许从一个Realm导入/导出特定的值（变量、函数、对象等）。这个机制通常会涉及到“膜”（Membrane）的概念，以确保跨Realm传递的值是受控的代理而不是直接引用。

目前，Realms API的提案细节在这一点上有所演变。早期提案可能直接通过importValue暴露全局变量，但更健壮的设计倾向于通过明确的API接口或模块导出。

更一般的通信模式：提供宿主API给子Realm

在实际应用中，我们不会直接让子Realm访问宿主的globalThis。相反，我们会创建一个明确的接口对象，并将其安全地暴露给子Realm。

// 宿主环境
const guestRealm = new Realm();

// 1. 定义宿主提供的 API
const hostApi = {
    log: (message) => {
        console.log(`[Host Log]: ${message}`);
    },
    getData: (key) => {
        console.log(`[Host] Guest requested data for key: ${key}`);
        if (key === 'config') {
            return { version: '1.0.0', owner: 'HostApp' };
        }
        return null;
    },
    // 一个异步操作的例子
    fetchRemoteData: async (url) => {
        console.log(`[Host] Guest wants to fetch: ${url}`);
        // 在实际应用中，这里会进行真正的网络请求
        return new Promise(resolve => setTimeout(() => {
            resolve(`Simulated data from ${url}`);
        }, 50));
    }
};

// 2. 将宿主 API 注入到 Guest Realm
// Realms API 提供了 `createHostObject` 和 `createHostCallable` 来创建跨 Realm 的代理。
// 这些代理是特殊的，它们在 Guest Realm 中看起来是普通的JS对象/函数，但其操作会被宿主Realm拦截和处理。
const guestHostApiProxy = guestRealm.createHostObject(hostApi);
const guestHostLogProxy = guestRealm.createHostCallable(hostApi.log);
const guestHostGetDataProxy = guestRealm.createHostCallable(hostApi.getData);
const guestHostFetchRemoteDataProxy = guestRealm.createHostCallable(hostApi.fetchRemoteData);

// 3. 在 Guest Realm 中注册这些代理
guestRealm.evaluate(`
    globalThis.Host = {};
    globalThis.Host.log = Host_log_proxy; // 将宿主函数代理赋值给 Guest Realm 的全局对象
    globalThis.Host.getData = Host_getData_proxy;
    globalThis.Host.fetchRemoteData = Host_fetchRemoteData_proxy;

    // 或者直接通过一个对象代理
    globalThis.HostAPI = Host_API_proxy;
`, {
    // 注入全局变量，以便 Guest Realm 中的代码可以访问
    Host_log_proxy: guestHostLogProxy,
    Host_getData_proxy: guestHostGetDataProxy,
    Host_fetchRemoteData_proxy: guestHostFetchRemoteDataProxy,
    Host_API_proxy: guestHostApiProxy // 注入整个对象代理
});

// 4. 在 Guest Realm 中执行代码，使用注入的 API
guestRealm.evaluate(`
    // 使用宿主提供的 log 函数
    Host.log('Hello from Guest Realm!');
    HostAPI.log('Another log from Guest Realm using object proxy!');

    // 使用宿主提供的数据获取函数
    const config = Host.getData('config');
    Host.log('Guest received config: ' + JSON.stringify(config));

    // 使用宿主提供的异步函数
    Host.fetchRemoteData('https://example.com/api/data')
        .then(data => Host.log('Guest received remote data: ' + data))
        .catch(error => Host.log('Guest error fetching data: ' + error.message));

    // 尝试访问宿主未暴露的函数 - 会失败
    // console.log(Host.secretFunction); // undefined
`);

// 5. 从 Guest Realm 导出值给宿主 (假设提案支持此模式)
// 这是一个模拟，因为 `exportValue` 机制仍在细化
guestRealm.evaluate(`
    globalThis.guestPlugin = {
        name: 'My Awesome Plugin',
        version: '0.1.0',
        run: function(input) {
            Host.log('Plugin run with input: ' + input);
            return 'Processed: ' + input;
        },
        async fetchDataFromHost() {
            const data = await Host.fetchRemoteData('https://guest-internal-api.com');
            return data.toUpperCase();
        }
    };
`);

// 宿主获取 Guest Realm 中导出的 plugin 对象
// 这是一个模拟，实际实现会使用 createHostObject 或 importValue
// 假设有一个机制可以获取 guestPlugin 的代理
const guestPluginProxy = guestRealm.evaluate('globalThis.guestPlugin'); // 实际上这里会返回一个代理
if (guestPluginProxy && typeof guestPluginProxy === 'object') {
    console.log('[Host] Guest plugin name:', guestPluginProxy.name);
    console.log('[Host] Guest plugin version:', guestPluginProxy.version);

    // 调用 guestPlugin 的方法
    const processedResult = guestPluginProxy.run('Test Input');
    console.log('[Host] Guest plugin processed result:', processedResult);

    guestPluginProxy.fetchDataFromHost().then(data => {
        console.log('[Host] Guest plugin fetched data from host:', data);
    });
}

这段代码演示了通过realm.createHostObject和realm.createHostCallable将宿主的能力安全地暴露给子Realm。子Realm只能访问这些明确提供的API，而无法直接穿透“膜”访问宿主的内部。evaluate的第二个参数允许我们将宿主创建的代理对象作为全局变量注入到子Realm中。

2.3 Realms中的“膜”（Membrane）机制

“膜”是Realms安全模型的核心。当一个对象或函数从一个Realm（例如宿主Realm）传递到另一个Realm（例如子Realm）时，Realms API不会直接传递其引用。相反，它会创建一个代理（Proxy）。这个代理是特殊的：

• 在子Realm中： 代理看起来就像一个普通的JavaScript对象或函数，可以像对待子Realm本地对象一样调用其方法或访问其属性。
• 在宿主Realm中： 当子Realm与代理交互时（例如调用一个函数），这个操作会被“膜”拦截，并在宿主Realm的上下文中执行。宿主Realm可以控制这些操作，例如对参数进行验证，或限制可以访问的属性。

这种机制确保了：

1. 类型隔离： 子Realm的代码无法通过instanceof操作符来判断一个宿主对象是否是其自己Realm中的Object、Array等实例。例如，guestRealm.evaluate('HostAPI instanceof Array')会返回false，即使HostAPI在宿主Realm中是一个数组（尽管通常我们不会这样暴露）。
2. 原型链隔离： 子Realm无法通过修改代理的原型链来影响宿主对象。
3. 行为控制： 宿主可以完全控制代理的行为，例如，可以只暴露对象的一部分属性或方法。

示例：通过膜传递函数和对象

// 宿主环境
const hostRealm = new Realm();
const guestRealm = new Realm();

// 宿主中的一个对象
const hostData = {
    value: 10,
    increment: function() {
        this.value++;
        return 'Incremented on host, new value: ' + this.value;
    }
};

// 宿主中的一个函数
function hostLogger(message) {
    console.log(`[Host Logger]: ${message}`);
}

// 将宿主对象和函数创建为Guest Realm中的代理
const guestHostDataProxy = guestRealm.createHostObject(hostData);
const guestHostLoggerProxy = guestRealm.createHostCallable(hostLogger);

// 在Guest Realm中注册这些代理
guestRealm.evaluate(`
    globalThis.hostDataItem = host_data_proxy;
    globalThis.hostLogFunc = host_logger_proxy;
`, {
    host_data_proxy: guestHostDataProxy,
    host_logger_proxy: guestHostLoggerProxy
});

// 在Guest Realm中与代理交互
const guestResult = guestRealm.evaluate(`
    hostLogFunc('Accessing hostDataItem from Guest.');
    console.log('hostDataItem.value in Guest:', hostDataItem.value); // 访问属性
    const incResult = hostDataItem.increment(); // 调用方法
    hostLogFunc(incResult);
    console.log('hostDataItem.value after increment in Guest:', hostDataItem.value);

    // 尝试在Guest Realm中修改 hostDataItem 的原型链
    // hostDataItem.__proto__.newMethod = () => "Bad idea!"; // 这应该不会影响到宿主
    return hostDataItem.value;
`);

console.log('[Host] Final hostData.value:', hostData.value); // 宿主中的原始对象值已被修改
console.log('[Host] Guest result:', guestResult); // 应该与 hostData.value 相同

// 验证原型链隔离
guestRealm.evaluate(`
    Object.defineProperty(hostDataItem, 'someProp', { value: 'test', configurable: true });
    console.log('Added someProp to hostDataItem in Guest:', hostDataItem.someProp);
    // 尝试修改 hostDataItem 的原型
    const originalProto = Object.getPrototypeOf(hostDataItem);
    Object.setPrototypeOf(hostDataItem, { newProtoMethod: () => 'Guest modified proto' });
    console.log('Modified hostDataItem prototype in Guest.');
`);

console.log('[Host] Host data item has someProp:', 'someProp' in hostData); // false，因为是代理
console.log('[Host] Host data item has newProtoMethod:', 'newProtoMethod' in hostData); // false
// 宿主中的 hostData 对象不受 Guest Realm 的原型链修改影响
console.log('[Host] hostData original prototype is still:', Object.getPrototypeOf(hostData) === Object.prototype);

这个例子进一步强调了膜机制如何允许跨Realm交互，同时维持了严格的隔离。子Realm对代理的操作会被宿主捕获并转发到原始对象，但子Realm无法直接修改宿主对象的原型链或类型。

2.4 异常处理与资源管理

在沙箱环境中，对异常的处理和资源的管理至关重要。

• 异常传播： 当子Realm中的代码抛出异常时，这个异常会传播到宿主Realm。Realms API会确保异常对象经过“膜”的转换，使得宿主Realm能够捕获并处理它，同时不泄露子Realm的内部结构。
• 栈追踪： 栈追踪信息会被调整，以避免泄露子Realm以外的宿主代码路径，但仍能提供足够的信息来调试子Realm内部的问题。

// 宿主环境
const guestRealm = new Realm();

// 1. 捕获 Guest Realm 中的同步异常
try {
    guestRealm.evaluate(`
        throw new Error('Something went wrong in Guest Realm!');
    `);
} catch (error) {
    console.error('[Host] Caught synchronous error from Guest Realm:', error.message);
    // 检查错误类型，注意，Realms可能会将Guest Realm的错误包装成Host Realm的错误类型
    console.log('[Host] Error instanceof Error:', error instanceof Error); // true
    console.log('[Host] Error stack:', error.stack); // 包含 Guest Realm 的栈信息，但可能被处理以保护宿主路径
}

// 2. 捕获 Guest Realm 中的异步异常 (需要宿主提供 Promise 或 Event Loop 机制)
guestRealm.evaluate(`
    globalThis.doAsyncError = function() {
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                reject(new Error('Async error from Guest Realm!'));
            }, 10);
        });
    };
`);

const guestDoAsyncError = guestRealm.createHostCallable(guestRealm.evaluate('globalThis.doAsyncError'));

guestDoAsyncError()
    .catch(error => {
        console.error('[Host] Caught asynchronous error from Guest Realm:', error.message);
        console.log('[Host] Async error stack:', error.stack);
    });

// 3. 资源管理：长时间运行的代码
// Realms API本身不提供CPU或内存限制，这需要宿主环境的配合。
// 例如，如果在浏览器环境，可以结合 Web Workers 的能力。
// 在Node.js中，可能需要结合 `worker_threads` 或外部监控。

// 模拟 Guest Realm 中的无限循环
// try {
//     guestRealm.evaluate(`while(true) {}`); // 这会阻塞宿主Realm，需要外部机制来终止
// } catch (e) {
//     console.error("Should not be reachable if infinite loop occurs without external termination.");
// }

// 理想情况下，宿主会设置一个计时器来中断 Guest Realm 的执行
const timeoutMs = 100;
let guestExecutionTimeoutId;

try {
    const guestCodeToRun = `
        let i = 0;
        const start = Date.now();
        while (Date.now() - start < 500) { // 模拟一个耗时操作，比宿主设定的超时时间长
            i++;
            // 宿主可以通过某种机制在这里注入检查点，或者依赖外部进程监控
            // Realistically, this loop would block the entire event loop.
        }
        i; // Return the final value
    `;

    // 理论上，我们可以用 Promise.race 或 Web Worker 来处理超时
    // 由于 Realm.evaluate 是同步的，直接在宿主 Realm 中设置 setTimeout 无法中断它。
    // 这强调了 Realms 通常需要与 Web Workers 或 Node.js Worker Threads 结合使用，以实现真正的异步和可中断的沙箱。

    // 假设我们有一个机制可以在 Guest Realm 执行超时后抛出错误
    // 这是一个抽象的示意，实际实现复杂
    // const executeWithTimeout = (realm, code, timeout) => {
    //     return new Promise((resolve, reject) => {
    //         const worker = new Worker('worker-realm-executor.js'); // 假设有一个执行 Realm 的 Worker
    //         worker.postMessage({ realmId: realm.id, code: code });
    //         const timer = setTimeout(() => {
    //             worker.terminate();
    //             reject(new Error('Realm execution timed out after ' + timeout + 'ms'));
    //         }, timeout);
    //         worker.onmessage = (e) => {
    //             clearTimeout(timer);
    //             resolve(e.data.result);
    //         };
    //         worker.onerror = (e) => {
    //             clearTimeout(timer);
    //             reject(e.error);
    //         };
    //     });
    // };

    // console.log('[Host] Attempting to run potentially long-running guest code...');
    // executeWithTimeout(guestRealm, guestCodeToRun, timeoutMs)
    //     .then(result => console.log('[Host] Guest code finished, result:', result))
    //     .catch(error => console.error('[Host] Guest code execution error:', error.message));

} catch (error) {
    console.error('[Host] Error during Realm setup for timeout test:', error.message);
}

// 内存限制也是类似，需要宿主环境的配合。例如，在Node.js中可以通过worker_threads的 `resourceLimits`。
// 在浏览器中，一个Realm内的内存分配会影响整个Tab的内存，难以单独限制。

Realms本身专注于JavaScript语言层面的隔离，而CPU和内存限制则需要宿主环境（如浏览器或Node.js Worker Threads）提供更底层的机制来配合实现。这是 Realmas API 的一个重要设计边界。

三、使用Realms构建安全沙箱的实践

现在，让我们通过几个具体的场景，来演示如何利用Realms构建一个功能完善且安全的沙箱。

3.1 场景一：加载并执行一个简单的第三方插件

假设我们有一个应用，需要加载用户提供的JavaScript插件来执行一些文本处理逻辑，同时要确保插件无法访问DOM或网络。

// host.js - 宿主应用代码

// 1. 创建一个 Realm 实例用于加载插件
const pluginRealm = new Realm();

// 2. 定义宿主提供的 API 接口，只包含插件所需的功能
const hostApiForPlugin = {
    // 允许插件安全地记录信息，避免直接访问 console
    log: (message) => {
        console.log(`[Plugin Log]: ${message}`);
    },
    // 允许插件访问一些配置数据，但不能修改
    getConfig: () => {
        return Object.freeze({
            appName: 'SecureApp',
            version: '1.0.0',
            maxTextLength: 1000
        });
    },
    // 暴露一个用于处理文本的工具函数
    processText: (text) => {
        if (typeof text !== 'string') {
            pluginRealm.evaluate(`Host.log("Error: processText expects a string.")`);
            return "";
        }
        return `[HOST_PROCESSED] ${text.toUpperCase()}`;
    }
};

// 3. 将宿主 API 注入到插件 Realm
pluginRealm.evaluate(`
    globalThis.Host = {};
    globalThis.Host.log = Host_log_proxy;
    globalThis.Host.getConfig = Host_getConfig_proxy;
    globalThis.Host.processText = Host_processText_proxy;
`, {
    Host_log_proxy: pluginRealm.createHostCallable(hostApiForPlugin.log),
    Host_getConfig_proxy: pluginRealm.createHostCallable(hostApiForPlugin.getConfig),
    Host_processText_proxy: pluginRealm.createHostCallable(hostApiForPlugin.processText)
});

// 4. 加载并执行第三方插件代码
const pluginCode = `
    // plugin.js - 假设这是来自第三方，我们不完全信任的代码

    // 尝试访问宿主环境的敏感信息 - 应该失败
    // console.log("Host window:", window); // ReferenceError: window is not defined
    // console.log("Host document:", document); // ReferenceError: document is not defined
    // Host.log("Accessing localStorage:", typeof localStorage); // ReferenceError: localStorage is not defined

    // 确保插件可以安全地记录
    Host.log('Plugin initialized! Version: 1.0');

    // 获取配置信息
    const config = Host.getConfig();
    Host.log('Plugin received config: ' + JSON.stringify(config));

    // 定义插件的主要逻辑
    globalThis.textTransformerPlugin = {
        name: 'Simple Text Transformer',
        transform: function(text) {
            Host.log('Plugin transforming text: ' + text);
            if (text.length > config.maxTextLength) {
                Host.log('Warning: Text too long, truncating.');
                text = text.substring(0, config.maxTextLength);
            }
            // 使用宿主提供的处理函数
            const processedByHost = Host.processText(text);
            return `[Plugin] ${processedByHost.split('').reverse().join('')}`;
        },
        // 尝试执行恶意操作
        maliciousAttempt: function() {
            // 尝试覆盖宿主函数
            // Host.log = () => console.error("Plugin hijacked log!"); // 这会修改 guestRealm 内部的 Host.log，但不会影响宿主原始的 hostApiForPlugin.log
            // Realistically, the membrane would prevent this from affecting the original host function.
            Host.log('Malicious attempt to hijack log function initiated (should only affect Guest Realm scope).');
            return 'Malicious attempt executed.';
        }
    };

    Host.log('Plugin loaded and ready.');
`;

pluginRealm.evaluate(pluginCode);

// 5. 从插件 Realm 获取插件对象并使用
const pluginProxy = pluginRealm.evaluate('globalThis.textTransformerPlugin'); // 获取代理

if (pluginProxy) {
    console.log(`[Host] Plugin name: ${pluginProxy.name}`);

    const inputText = "Hello World from the main application! This is some text to be transformed by the plugin.";
    const transformedText = pluginProxy.transform(inputText);
    console.log(`[Host] Transformed Text: ${transformedText}`);

    // 尝试调用插件中的恶意方法
    const maliciousResult = pluginProxy.maliciousAttempt();
    console.log(`[Host] Malicious attempt result: ${maliciousResult}`);
    // 宿主的 log 函数仍然正常工作
    hostApiForPlugin.log('Host log after plugin malicious attempt, still working fine.');
} else {
    console.error('[Host] Failed to load plugin.');
}

// 再次验证宿主环境的独立性
console.log('--- Host Environment Check ---');
console.log('Host globalThis.textTransformerPlugin:', typeof globalThis.textTransformerPlugin); // undefined
console.log('Host console.log is still original:', console.log === console.log); // true

这个例子展示了：

• 最小权限原则： 插件Realm默认没有任何特权，宿主需要显式地通过代理暴露所需的功能。
• 宿主控制： hostApiForPlugin.log在插件内部被调用时，其执行上下文仍是宿主Realm，确保了日志输出格式和安全性。
• 隔离： 插件无法访问window、document、localStorage等宿主环境的敏感对象，即使在插件内部尝试修改Host.log，也只会影响插件Realm内部的代理对象，而不会污染宿主原始的hostApiForPlugin.log。

3.2 场景二：构建一个插件市场，每个插件运行在独立的Realm中

对于一个拥有多个插件的应用，每个插件都应该在自己的Realm中运行，以实现更强的隔离和故障容错。

// host-marketplace.js - 宿主应用代码，管理多个插件

class PluginManager {
    constructor() {
        this.plugins = new Map();
        this.nextPluginId = 0;
    }

    // 定义宿主提供的通用 API 接口
    createHostApiForPlugin(pluginId) {
        return {
            log: (message) => {
                console.log(`[Plugin ${pluginId} Log]: ${message}`);
            },
            getSharedData: (key) => {
                console.log(`[Plugin ${pluginId}] Requesting shared data for: ${key}`);
                // 模拟共享数据，实际可能从数据库或服务获取
                const sharedData = {
                    commonConfig: { theme: 'dark', lang: 'en' },
                    currentUser: { id: 'user123', name: 'Alice' }
                };
                // 返回数据的深拷贝或不可变代理，防止插件修改
                return JSON.parse(JSON.stringify(sharedData[key]));
            },
            // 暴露一个用于与其他插件通信的机制（例如，发布/订阅）
            publishEvent: (eventName, data) => {
                console.log(`[Plugin ${pluginId}] Published event '${eventName}' with data:`, data);
                // 实际中这里会触发宿主事件系统，通知其他订阅者
                this.emitPluginEvent(eventName, data, pluginId);
            }
        };
    }

    // 模拟宿主事件系统
    emitPluginEvent(eventName, data, sourcePluginId) {
        this.plugins.forEach((pluginEntry, id) => {
            if (id !== sourcePluginId && pluginEntry.realm) {
                // 尝试在其他 Realm 中触发订阅回调
                pluginEntry.realm.evaluate(`
                    if (globalThis.PluginEvents && globalThis.PluginEvents['${eventName}']) {
                        globalThis.PluginEvents['${eventName}'].forEach(callback => {
                            try {
                                callback(${JSON.stringify(data)}); // 传递序列化数据
                            } catch (e) {
                                Host.log('Error in event listener for ${eventName}: ' + e.message);
                            }
                        });
                    }
                `, { Host: pluginEntry.hostApiProxy }); // 注入每个插件自己的 Host API 代理
            }
        });
    }

    async loadPlugin(pluginCode) {
        const pluginId = `plugin-${this.nextPluginId++}`;
        console.log(`[Host] Loading plugin: ${pluginId}`);

        const pluginRealm = new Realm();
        const hostApi = this.createHostApiForPlugin(pluginId);

        // 创建宿主 API 代理
        const hostApiProxy = pluginRealm.createHostObject(hostApi);
        const hostLogProxy = pluginRealm.createHostCallable(hostApi.log);
        const hostGetSharedDataProxy = pluginRealm.createHostCallable(hostApi.getSharedData);
        const hostPublishEventProxy = pluginRealm.createHostCallable(hostApi.publishEvent);

        // 注入宿主 API
        pluginRealm.evaluate(`
            globalThis.Host = {};
            globalThis.Host.log = Host_log_proxy;
            globalThis.Host.getSharedData = Host_getSharedData_proxy;
            globalThis.Host.publishEvent = Host_publishEvent_proxy;

            globalThis.PluginEvents = {};
            globalThis.subscribeToEvent = function(eventName, callback) {
                if (!globalThis.PluginEvents[eventName]) {
                    globalThis.PluginEvents[eventName] = [];
                }
                globalThis.PluginEvents[eventName].push(callback);
                Host.log('Subscribed to event: ' + eventName);
            };

        `, {
            Host_log_proxy: hostLogProxy,
            Host_getSharedData_proxy: hostGetSharedDataProxy,
            Host_publishEvent_proxy: hostPublishEventProxy
        });

        try {
            // 执行插件代码
            pluginRealm.evaluate(pluginCode);

            // 获取插件导出的接口
            const pluginInterface = pluginRealm.evaluate('globalThis.pluginInterface');
            if (!pluginInterface || typeof pluginInterface.init !== 'function') {
                throw new Error('Plugin must export a "pluginInterface" object with an "init" method.');
            }

            this.plugins.set(pluginId, {
                id: pluginId,
                realm: pluginRealm,
                hostApiProxy: hostApiProxy, // 存储代理以便事件系统使用
                interface: pluginRealm.createHostObject(pluginInterface) // 获取插件接口的代理
            });

            // 初始化插件
            await this.plugins.get(pluginId).interface.init();

            console.log(`[Host] Plugin ${pluginId} loaded and initialized.`);
            return pluginId;

        } catch (error) {
            console.error(`[Host] Failed to load plugin ${pluginId}:`, error.message);
            // 即使失败，Realm 也可能仍然存在，但我们可以选择清理它
            return null;
        }
    }

    async runPluginAction(pluginId, actionName, ...args) {
        const pluginEntry = this.plugins.get(pluginId);
        if (!pluginEntry) {
            console.error(`[Host] Plugin ${pluginId} not found.`);
            return null;
        }
        const pluginInterface = pluginEntry.interface;
        if (typeof pluginInterface[actionName] === 'function') {
            console.log(`[Host] Running action '${actionName}' on plugin ${pluginId}.`);
            // 调用插件方法，Realms 会处理参数的跨 Realm 传递
            return await pluginInterface[actionName](...args);
        } else {
            console.error(`[Host] Action '${actionName}' not found on plugin ${pluginId}.`);
            return null;
        }
    }
}

const pluginManager = new PluginManager();

// 插件A代码
const pluginACode = `
    Host.log('Plugin A: Starting up.');
    const config = Host.getSharedData('commonConfig');
    Host.log('Plugin A config:', JSON.stringify(config));

    globalThis.pluginInterface = {
        init: function() {
            Host.log('Plugin A: Initialized successfully.');
            subscribeToEvent('data-update', (data) => {
                Host.log('Plugin A received data-update event: ' + JSON.stringify(data));
            });
            // 模拟一些异步操作
            return new Promise(resolve => setTimeout(() => {
                Host.log('Plugin A: Async init complete.');
                resolve();
            }, 50));
        },
        processItem: function(item) {
            Host.log('Plugin A: Processing item: ' + item);
            Host.publishEvent('item-processed', { item: item, processedBy: 'Plugin A' });
            return `A: ${item.toUpperCase()}`;
        }
    };
`;

// 插件B代码
const pluginBCode = `
    Host.log('Plugin B: Starting up.');
    const user = Host.getSharedData('currentUser');
    Host.log('Plugin B user:', JSON.stringify(user));

    globalThis.pluginInterface = {
        init: function() {
            Host.log('Plugin B: Initialized successfully.');
            subscribeToEvent('item-processed', (data) => {
                Host.log('Plugin B received item-processed event: ' + JSON.stringify(data));
                Host.publishEvent('item-acked', { originalItem: data.item, ackedBy: 'Plugin B' });
            });
            Host.publishEvent('plugin-b-ready', { status: 'ready' });
        },
        formatOutput: function(text) {
            Host.log('Plugin B: Formatting output: ' + text);
            return `B: <${text}>`;
        }
    };
`;

// 插件C代码 (包含错误)
const pluginCCode = `
    Host.log('Plugin C: Starting up.');
    globalThis.pluginInterface = {
        init: function() {
            Host.log('Plugin C: Initialized.');
            throw new Error('Plugin C failed during initialization!'); // 模拟初始化失败
        },
        doSomething: function() {
            return 'C: Doing something.';
        }
    };
`;

(async () => {
    const pluginAId = await pluginManager.loadPlugin(pluginACode);
    const pluginBId = await pluginManager.loadPlugin(pluginBCode);
    const pluginCId = await pluginManager.loadPlugin(pluginCCode); // 会失败

    if (pluginAId) {
        const resultA = await pluginManager.runPluginAction(pluginAId, 'processItem', 'some data');
        console.log(`[Host] Plugin A result: ${resultA}`);
    }

    if (pluginBId) {
        const resultB = await pluginManager.runPluginAction(pluginBId, 'formatOutput', 'formatted text');
        console.log(`[Host] Plugin B result: ${resultB}`);
    }

    // 触发一个宿主事件，看插件是否响应
    console.log('[Host] Publishing global data-update event...');
    pluginManager.emitPluginEvent('data-update', { source: 'Host', change: 'major' }, 'HostApp');

    // 尝试运行失败的插件
    if (pluginCId) { // 不会执行，因为 pluginCId 为 null
        await pluginManager.runPluginAction(pluginCId, 'doSomething');
    }
})();

这个复杂的例子展示了：

• 多Realm管理： PluginManager负责创建和管理多个Realms，每个插件都有自己的隔离环境。
• 通用API注入： 宿主为每个插件提供一套定制的API，包括日志、共享数据访问和事件通信。
• 插件间通信： 通过宿主中介的发布/订阅系统，插件可以在不知道彼此存在的情况下进行安全通信。宿主负责将事件和数据从一个Realm安全地传递到另一个Realm，通常通过结构化克隆或代理。
• 错误隔离： 插件C的初始化失败不会影响插件A和插件B的正常运行，宿主可以捕获并处理错误。
• 异步操作： 插件的init方法和宿主API都可以是异步的，Realms能够很好地处理Promise的跨Realm传递。

3.3 资源限制与终止

Realms API 本身不提供直接的CPU或内存限制，但它为宿主提供了更清晰的边界，使得宿主可以结合其他技术来实现这些限制：

• CPU限制/超时：
  • 结合 Web Workers： 在浏览器环境中，最有效的方法是将每个Realm封装在一个Web Worker中。如果Worker中的Realm执行时间过长，宿主可以通过worker.terminate()来强制终止整个Worker进程。
  • 结合 Node.js Worker Threads： 在Node.js中，可以使用worker_threads模块。每个Realm运行在一个独立的Worker Thread中，宿主可以监控其CPU使用情况，并在必要时调用worker.terminate()。worker_threads还提供了resourceLimits选项来设置内存限制。
• 内存限制：
  • 与CPU限制类似，通过将Realm放入独立的Worker (Web Worker / Node.js Worker Thread) 中，可以利用底层平台提供的内存限制机制。
  • 在Node.js中，worker_threads的resourceLimits.maxOldGenerationSizeMb等选项可以直接限制Worker的内存。
  • 在浏览器中，单个Tab的内存是共享的，很难对单个Realm进行精确的内存限制，但Web Worker的终止也能释放其占用的内存。

// host-with-resource-limits.js (概念性代码，结合 Web Worker 或 Node.js Worker Threads)

// 这是一个概念性的示例，假设有一个 Worker 封装了 Realm 的执行
// worker-realm-executor.js (Web Worker 或 Node.js Worker Thread 内容)
// self.onmessage = async (e) => {
//     const { code, timeout, memoryLimit } = e.data;
//     try {
//         const realm = new Realm();
//         // ... 注入宿主 API ...
//         const result = realm.evaluate(code);
//         self.postMessage({ status: 'success', result });
//     } catch (error) {
//         self.postMessage({ status: 'error', message: error.message, stack: error.stack });
//     }
// };

// Host application
function executeRealmCodeInWorker(code, timeoutMs = 500, memoryLimitMb = 100) {
    return new Promise((resolve, reject) => {
        // 在浏览器中创建 Web Worker
        // const worker = new Worker('worker-realm-executor.js');

        // 在 Node.js 中创建 Worker Thread
        const { Worker } = require('worker_threads');
        const worker = new Worker('./worker-realm-executor.js', {
            workerData: { code, timeout: timeoutMs },
            resourceLimits: {
                maxOldGenerationSizeMb: memoryLimitMb,
                maxYoungGenerationSizeMb: 10 // 示例
            }
        });

        const timer = setTimeout(() => {
            worker.terminate(); // 强制终止 Worker
            reject(new Error(`Execution timed out after ${timeoutMs}ms`));
        }, timeoutMs);

        worker.on('message', (msg) => {
            clearTimeout(timer);
            if (msg.status === 'success') {
                resolve(msg.result);
            } else {
                reject(new Error(`Worker error: ${msg.message}nStack: ${msg.stack}`));
            }
        });

        worker.on('error', (err) => {
            clearTimeout(timer);
            reject(err);
        });

        worker.on('exit', (code) => {
            clearTimeout(timer);
            if (code !== 0 && code !== 1) { // 1 是 worker.terminate() 的退出码
                reject(new Error(`Worker stopped with exit code ${code}`));
            }
        });

        // 将代码发送给 Worker 执行
        // worker.postMessage({ code, timeout: timeoutMs, memoryLimit: memoryLimitMb });
        // 在 Node.js worker_threads 中，workerData 在构造时传递
    });
}

// 示例：运行正常代码
(async () => {
    try {
        console.log('[Host] Running normal guest code...');
        const normalCode = `
            let sum = 0;
            for (let i = 0; i < 100000; i++) {
                sum += i;
            }
            sum;
        `;
        const result = await executeRealmCodeInWorker(normalCode, 2000);
        console.log('[Host] Normal code result:', result);
    } catch (e) {
        console.error('[Host] Error running normal code:', e.message);
    }

    // 示例：运行超时代码
    try {
        console.log('n[Host] Running guest code with infinite loop (should timeout)...');
        const infiniteLoopCode = `
            let i = 0;
            while(true) { i++; }
        `;
        await executeRealmCodeInWorker(infiniteLoopCode, 100); // 100ms 超时
    } catch (e) {
        console.error('[Host] Caught expected timeout error:', e.message);
    }

    // 示例：运行内存耗尽代码 (需要大量内存分配才能触发)
    try {
        console.log('n[Host] Running guest code with high memory usage (should be limited)...');
        const highMemoryCode = `
            let arr = [];
            for (let i = 0; i < 5000000; i++) { // 尝试分配大量字符串
                arr.push('a'.repeat(100));
            }
            arr.length;
        `;
        await executeRealmCodeInWorker(highMemoryCode, 5000, 50); // 5秒超时，50MB 内存限制
    } catch (e) {
        console.error('[Host] Caught expected memory error:', e.message);
    }
})();

这个概念性代码强调了Realms API如何与现有的Worker机制结合，实现更全面的沙箱控制。Realms提供了语言层面的隔离，而Workers提供了进程/线程层面的隔离以及资源限制能力，两者相辅相成。

四、高级安全考量与挑战

尽管Realms API大大提升了JavaScript沙箱的安全性，但在实际部署中，我们仍需考虑一些高级安全问题。

4.1 侧信道攻击（Side-Channel Attacks）

侧信道攻击不依赖于代码逻辑漏洞，而是通过观察系统行为（如执行时间、内存访问模式、缓存命中率）来推断敏感信息。

• 计时攻击： 恶意代码可以通过测量不同操作的执行时间来推断秘密信息。例如，某些加密操作在输入特定值时可能需要略微不同的时间。
• 缓存攻击： 通过观察CPU缓存的命中/未命中模式，可以推断出代码访问了哪些内存区域，从而可能泄露信息。

Realms的应对： Realms本身不直接解决侧信道攻击。这类攻击通常需要更底层的硬件或操作系统级别的防护。然而，通过将不可信代码隔离到单独的Worker中，可以降低其对主应用的侧信道攻击影响，因为它们共享的资源更少。

4.2 拒绝服务 (DoS)

恶意或有缺陷的第三方代码可能通过耗尽CPU、内存、网络带宽或存储空间来发起DoS攻击。

• CPU耗尽： 无限循环或计算密集型任务（如前面的例子）。
• 内存耗尽： 持续分配大量内存，导致系统崩溃或性能下降。
• 资源泄漏： 即使代码正常结束，也可能未能释放所有资源（例如，注册了未移除的事件监听器）。

Realms的应对：

• CPU/内存： 如前所述，Realms需要与Worker结合使用，通过worker.terminate()或resourceLimits进行限制。
• 事件监听器： 宿主在销毁Realm时，应确保所有与该Realm相关的宿主资源（如事件监听器、网络连接）都被清理。Realms的隔离性有助于限制这些泄漏的影响范围，但宿主仍需负责管理。

4.3 原型污染与原型链攻击

传统的JavaScript沙箱，如Node.js的vm模块，如果未精心配置，容易受到原型链攻击。例如，通过context.Object.prototype.__defineGetter__('foo', ...)来污染宿主环境的Object.prototype。

Realms的应对： 这是Realms的关键优势之一。 每个Realm都拥有自己独立的内在对象（Object、Array、Function等构造函数及其原型）。这意味着在子Realm中修改Array.prototype不会影响宿主Realm的Array.prototype，从而从根本上消除了这类攻击的威胁。

// Guest Realm
guestRealm.evaluate(`
    // 在 Guest Realm 中修改其自身的 Array.prototype
    Array.prototype.maliciousMethod = function() { return "I am malicious!"; };
`);

// Host Realm
const hostArray = [];
// hostArray.maliciousMethod(); // ReferenceError: maliciousMethod is not defined
console.log('Host Array has maliciousMethod:', 'maliciousMethod' in hostArray); // false

这种内在对象的隔离是Realms提供的最强大的安全保障之一。

4.4 反射访问和宿主内部信息泄露

恶意代码可能尝试通过反射机制（如Object.getPrototypeOf、Object.getOwnPropertyDescriptors）来探查其宿主Realm的对象结构，寻找潜在的漏洞或敏感信息。

Realms的应对：

• 膜机制： 当宿主对象通过createHostObject或createHostCallable传递给子Realm时，子Realm收到的是一个代理。对这个代理执行反射操作，如Object.getPrototypeOf(proxy)，只会返回子Realm自己的Object.prototype（或者一个经过处理的代理原型），而不是宿主原始对象的原型链。这有效地隐藏了宿主的内部结构。
• 最小权限： 宿主应该只暴露子Realm真正需要的最小接口，避免暴露过于宽泛的对象，即使是代理。

4.5 宿主-子Realm通信通道的安全

通信是沙箱的必要组成部分，但也是潜在的攻击面。

• 数据验证： 宿主在接收子Realm发送的数据时，必须严格验证其类型、结构和内容。反之亦然。不要盲目信任来自子Realm的数据。
• 序列化/反序列化： 如果通信通过结构化克隆（例如在Worker中使用postMessage），某些对象（如函数、Promise、DOM节点）无法直接传递。Realms的膜机制处理了复杂对象的代理传递，但仍然需要注意哪些对象类型是安全且有效可传递的。
• 防止注入： 避免将原始的eval或Function构造函数暴露给子Realm，因为它们可能被滥用。Realms默认不暴露这些，宿主也应避免通过API注入。

五、Realms与现有沙箱技术的比较（详细）

| 特性/机制 | iframe | Web Worker | Node.js vm | Realms |
| 类型 | 浏览器环境对象 | 线程/Worker 环境 | Node.js 模块 | ECMAScript 语言层面的特性 |
| 全局对象隔离 | 是 (完全独立) | 否 (共用宿主JS引擎实例，但有独立的self/globalThis) | 否 (共用宿主JS引擎实例，但可配置上下文) | 是 (完全独立，拥有自己的globalThis)