JavaScript 中的影子域名（Shadow Realms）：实现代码执行环境的完全物理隔离与受限通信协议 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位听众，下午好！

在当今JavaScript日益复杂的生态系统中，我们面临着一个核心挑战：如何安全、可靠地执行来自不同来源、具有不同信任级别的代码？从用户上传的插件、第三方库，到多租户应用中的沙箱环境，代码隔离与安全性始终是开发者们关注的焦点。传统的JavaScript执行环境，尽管提供了某些隔离机制，但往往无法实现真正意义上的“物理”隔离，或者在通信协议上存在诸多限制和安全隐患。

今天，我们将深入探讨一个备受期待的TC39提案——JavaScript中的影子域名（Shadow Realms）。它旨在提供一个全新的、强大的机制，以实现代码执行环境的完全物理隔离，并辅以受限、安全的通信协议，从而彻底革新我们构建安全、健壮JavaScript应用的方式。

1. 隔离的迫切需求：为何我们需要更强的沙箱？

想象一下以下场景：

插件系统： 您的应用程序允许用户或第三方开发者编写和上传自定义插件。这些插件可能包含恶意代码、性能瓶颈或仅仅是意外的副作用。您需要确保这些插件在执行时不会影响到主应用程序的状态、数据或安全。
多租户应用： 在一个共享JavaScript运行时环境中，为不同的租户（用户或客户）提供个性化的脚本执行能力。每个租户的代码都必须严格隔离，防止数据泄露或相互干扰。
富文本编辑器/内容管理系统： 用户可以在其中插入自定义HTML和JavaScript。这些脚本必须在严格的沙箱中运行，以防止跨站脚本攻击（XSS）或其他安全漏洞。
代码评审工具/在线编程环境： 允许用户提交代码并在服务器端或客户端执行。这些代码的执行必须是高度隔离的，以防止系统崩溃或资源滥用。

在这些场景中，我们对隔离的需求不仅仅是“不共享全局变量”，而是要达到“仿佛在独立的虚拟机中运行”的程度。

2. 现有隔离机制的局限性

在Shadow Realms出现之前，JavaScript生态系统已经探索了多种隔离技术。然而，它们各自存在局限性：

2.1 `eval()` 和 `new Function()`

这是最直接的执行动态代码的方式。

// 主环境
const globalVar = 'Hello from main!';

function executeInSameRealm(code) {
    eval(code); // 或 new Function(code)()
}

executeInSameRealm(`
    console.log(globalVar); // 访问主环境的变量
    const realmVar = 'Hello from eval!';
    console.log(realmVar);
`);

console.log(typeof realmVar); // 'string' - realmVar 污染了主环境

局限性：

无隔离： eval() 和 new Function() 执行的代码与调用者处于同一个JavaScript Realm中，共享相同的全局对象（window 或 global）、相同的内置对象（Object, Array, Function 等）。这意味着被执行的代码可以访问和修改主环境的任何变量、函数和原型链，造成严重的安全漏洞和副作用。
无法沙箱： 无法限制其对全局对象的访问能力。
性能开销： 动态代码执行通常比预编译的代码慢。

2.2 `<iframe>` 元素

<iframe> 可以在浏览器环境中创建独立的文档和执行上下文。通过设置 sandbox 属性，可以进一步限制其功能。

<!-- index.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Main App</title>
</head>
<body>
    <h1>Main Application</h1>
    <iframe id="sandboxFrame" sandbox="allow-scripts allow-same-origin"></iframe>

    <script>
        const iframe = document.getElementById('sandboxFrame');
        iframe.srcdoc = `
            <!DOCTYPE html>
            <html>
            <body>
                <script>
                    // 在iframe内部的全局对象是独立的
                    console.log('Inside iframe:', window === parent.window); // false
                    // 尝试访问父级变量 (同源策略下，直接访问会报错或undefined)
                    try {
                        console.log('Inside iframe, trying to access parentVar:', parent.parentVar);
                    } catch (e) {
                        console.error('Accessing parentVar failed:', e.message);
                    }
                    // 通过 postMessage 通信
                    window.parent.postMessage('Hello from iframe!', '*');
                </script>
            </body>
            </html>
        `;

        window.addEventListener('message', (event) => {
            if (event.source === iframe.contentWindow) {
                console.log('Main app received message from iframe:', event.data);
            }
        });

        // setTimeout(() => {
        //     // 尝试通过iframe访问其内部的变量 (同源策略下，直接访问会报错)
        //     try {
        //         console.log('Main app trying to access iframeVar:', iframe.contentWindow.iframeVar);
        //     } catch (e) {
        //         console.error('Accessing iframeVar failed from main:', e.message);
        //     }
        // }, 1000);
    </script>
</body>
</html>

局限性：

DOM 依赖： <iframe> 仅适用于浏览器环境，且会创建完整的DOM和CSSOM，开销较大。
重量级： 实例化一个 <iframe> 涉及创建新的文档环境、加载资源等，这使其成为一个“重量级”的沙箱。
异步通信： 跨 <iframe> 通信主要依赖 postMessage，这是一种异步机制，且只能传递可序列化的数据。复杂对象（如函数、Promise）无法直接传递。
全局对象共享风险： 尽管 window 对象是独立的，但如果未正确配置 sandbox 属性，或者存在同源策略漏洞，仍然可能导致一些全局对象（如某些内置构造函数）被共享或污染。

2.3 Web Workers

Web Workers 在浏览器环境中提供了一个独立的JavaScript线程。

// main.js
const worker = new Worker('worker.js');

worker.postMessage('Hello from main thread!');

worker.onmessage = (event) => {
    console.log('Main thread received message:', event.data);
};

// worker.js
self.onmessage = (event) => {
    console.log('Worker received message:', event.data);
    // Worker 环境没有 DOM 访问能力
    // console.log(document); // ReferenceError: document is not defined
    self.postMessage('Hello from worker!');
};

局限性：

无 DOM 访问： Web Workers 无法直接访问DOM，这限制了它们在某些需要UI交互的沙箱场景中的应用。
异步通信： 与 <iframe> 类似，Web Workers 之间以及与主线程之间的通信也完全依赖 postMessage，是异步的，且只能传递可序列化或可转移的数据。
仍有部分共享： 尽管拥有独立的全局对象 (self)，但在某些底层实现上，Web Workers 可能仍然共享一些引擎级的资源，并且不能完全阻止共享某些高级对象（如 SharedArrayBuffer 在特定条件下）。

2.4 Node.js `vm` 模块

在Node.js环境中，vm 模块允许创建和管理独立的JavaScript上下文（Context）。

// Node.js 环境
const vm = require('vm');

const sandbox = {
    x: 1,
    console: console, // 显式暴露 console
    setTimeout: setTimeout // 显式暴露 setTimeout
};

// 创建一个新的上下文
const context = vm.createContext(sandbox);

const code = `
    x += 10;
    console.log('Inside vm context, x:', x);
    setTimeout(() => {
        console.log('Timeout inside vm context');
    }, 100);
    // 尝试访问未暴露的全局变量
    try {
        console.log('Inside vm context, trying to access process:', process);
    } catch (e) {
        console.error('Accessing process failed:', e.message);
    }
`;

vm.runInContext(code, context);

console.log('Outside vm context, x:', sandbox.x); // x: 11
console.log('Outside vm context, context.x:', context.x); // context.x: 11

局限性：

平台特定： vm 模块是Node.js特有的，无法在浏览器环境中使用。
手动沙箱： 开发者需要手动选择性地将宿主环境的全局对象和API注入到沙箱中。如果遗漏或错误注入，可能导致安全漏洞或功能缺失。
“物理”隔离不足： 尽管 vm 提供了独立的全局对象，但沙箱内的代码仍然可能通过原型链污染或某些内置对象的引用，间接影响到宿主环境。例如，如果 Object.prototype 在沙箱中被修改，可能会影响到宿主环境。它并没有创建一套全新的内置对象（Intrinsics）。

3. Shadow Realms 的核心理念：物理隔离与受限通信

Shadow Realms 旨在解决上述机制的根本性问题，提供一个真正的物理隔离的JavaScript执行环境。它的核心理念可以概括为：

独立的全局对象和内置对象（Intrinsics）： 每个Shadow Realm都拥有自己完全独立的全局对象（类似于 window 或 self），以及一套全新的、不与宿主Realm共享的内置对象实例（如 Object, Array, Function, Promise 等构造函数及其原型）。这意味着在一个Shadow Realm中修改 Object.prototype 不会影响到宿主Realm。这是“物理隔离”的关键所在。
受限的通信协议： 两个Realm之间不能直接共享对象引用。所有跨Realm的数据交换都必须通过明确定义的机制进行，例如：
- 原始值（Primitives）： string, number, boolean, null, undefined, symbol, bigint 可以直接复制传递。
- 可序列化对象（Structured Clone）： 某些复杂对象（如普通对象、数组、Map、Set、Date、RegExp、ArrayBuffer、TypedArray 等）可以通过“结构化克隆（Structured Clone）”算法进行深拷贝，即传递的是副本而不是引用。
- 可调用边界（Callable Boundary）： 这是最重要、最独特的部分。函数是唯一可以在Realm之间传递的“活”对象。当一个函数从一个Realm传递到另一个Realm时，它会变成一个“可调用边界”对象。这个边界对象在被调用时，会在其 原始创建的Realm 中执行。这允许Realm之间进行双向的功能调用，而不会暴露内部对象引用。

4. Shadow Realms API 概览

Shadow Realms 提案引入了一个新的全局构造函数 Realm。其核心API包括：

方法/属性	描述
`Realm.create()`	创建一个新的Shadow Realm实例。
`realm.evaluate(code)`	在指定的Shadow Realm中执行JavaScript代码，并返回结果。
`realm.importValue(specifier, name)`	从宿主Realm导入一个值到Shadow Realm中。这个值可以是原始值、可克隆对象或可调用边界。
`realm.call(callable, ...args)`	在Shadow Realm中调用一个从宿主Realm传递过去的可调用边界函数。
`realm.global`	（待定或内部实现）指向Shadow Realm的全局对象。通常不直接暴露给开发者，而是通过 `evaluate` 或 `importValue` 间接交互。

注意： 提案仍在演进中，具体的API名称和行为可能会有微调。这里我们基于当前阶段的提案进行讲解。

5. 深入代码实践

让我们通过一系列代码示例来理解Shadow Realms的工作原理。

5.1 创建并执行基本代码

// Host Realm (主环境)
async function demonstrateBasicRealm() {
    console.log("--- 5.1 创建并执行基本代码 ---");

    // 1. 创建一个新的 Shadow Realm
    const realm = await Realm.create();
    console.log("Shadow Realm created.");

    // 2. 在 Shadow Realm 中执行一些简单的代码
    const result = await realm.evaluate(`
        const message = 'Hello from Shadow Realm!';
        console.log(message); // 这会调用宿主环境的 console.log，如果它被传递进去
        message
    `);

    console.log("Result from Shadow Realm evaluation:", result); // "Hello from Shadow Realm!"

    // 3. 尝试访问 Shadow Realm 内部的变量 - 失败，因为是隔离的
    try {
        console.log(realm.message); // 这将是 undefined 或抛出错误
    } catch (e) {
        console.error("Attempt to access realm.message failed (as expected):", e.message);
    }

    // 4. 证明全局对象是独立的
    const hostGlobal = typeof window !== 'undefined' ? window : global;
    const realmGlobalCheck = await realm.evaluate(`
        typeof window !== 'undefined' ? window : global
    `);
    console.log("Host global object reference:", hostGlobal);
    console.log("Realm global object reference (from within realm):", realmGlobalCheck);
    console.log("Is Host global === Realm global?", hostGlobal === realmGlobalCheck); // 预期为 false
}

demonstrateBasicRealm();

解释：

Realm.create() 返回一个 Promise，因为创建新的Realm可能涉及一些异步的初始化工作。
realm.evaluate(code) 在新创建的Realm中执行字符串形式的JavaScript代码。它返回代码执行的最终结果（如果代码是表达式，则返回表达式的值；如果是语句，则返回 undefined）。
console.log 在Realm内部执行时，如果宿主环境的 console 对象没有被显式地导入到Realm中，那么Realm内部的 console.log 会是一个独立的实例，其输出行为取决于Realm的宿主环境如何配置。在浏览器或Node环境中，通常会捕获并转发到宿主的控制台。
我们无法直接从宿主Realm访问Shadow Realm内部定义的变量，这证明了变量隔离。

5.2 验证内置对象的物理隔离

这是Shadow Realms与 vm 模块等方案的核心区别。

// Host Realm (主环境)
async function demonstrateIntrinsicIsolation() {
    console.log("n--- 5.2 验证内置对象的物理隔离 ---");

    const realm = await Realm.create();

    // 1. 在宿主环境修改 Object.prototype
    Object.prototype.hostProperty = 'I am from host!';
    console.log("Host Realm: Object.prototype.hostProperty =", {}.hostProperty); // I am from host!

    // 2. 在 Shadow Realm 中检查 Object.prototype
    const realmCheck = await realm.evaluate(`
        // 在 Shadow Realm 中修改 Object.prototype
        Object.prototype.realmProperty = 'I am from realm!';

        // 检查宿主修改是否可见
        const hostPropVisible = {}.hostProperty;

        // 检查 Realm 自己的修改是否可见
        const realmPropVisible = {}.realmProperty;

        ({ hostPropVisible, realmPropVisible })
    `);

    console.log("Shadow Realm: Object.prototype.hostProperty =", realmCheck.hostPropVisible); // 预期为 undefined
    console.log("Shadow Realm: Object.prototype.realmProperty =", realmCheck.realmPropVisible); // 预期为 I am from realm!

    // 3. 在宿主环境再次检查 Object.prototype，确保未受 Realm 影响
    console.log("Host Realm (after realm execution): Object.prototype.realmProperty =", {}.realmProperty); // 预期为 undefined

    // 4. 验证构造函数实例的独立性
    const hostObjectConstructor = Object;
    const realmObjectConstructorCheck = await realm.evaluate(`Object`);

    console.log("Host Object constructor:", hostObjectConstructor);
    console.log("Realm Object constructor (from within realm):", realmObjectConstructorCheck);
    console.log("Is Host Object === Realm Object?", hostObjectConstructor === realmObjectConstructorCheck); // 预期为 false

    // 清理宿主环境的修改
    delete Object.prototype.hostProperty;
}

demonstrateIntrinsicIsolation();

解释：

我们修改了宿主Realm的 Object.prototype，并在Shadow Realm中尝试访问。结果显示，Shadow Realm无法看到宿主Realm对 Object.prototype 的修改。
反之，Shadow Realm对 Object.prototype 的修改也不会影响到宿主Realm。
hostObjectConstructor === realmObjectConstructorCheck 为 false 明确表明，Object 构造函数本身在两个Realm中是不同的实例。这对于 Array, Function, Promise 等所有内置对象都成立。这是“物理隔离”最直观的体现，有效防止了原型链污染攻击。

5.3 跨Realm通信：原始值与可克隆对象

原始值和可克隆对象在跨Realm传递时，会被深拷贝。

// Host Realm (主环境)
async function demonstrateValueTransfer() {
    console.log("n--- 5.3 跨Realm通信：原始值与可克隆对象 ---");

    const realm = await Realm.create();

    // 1. 传递原始值
    const hostString = "Hello Realm!";
    const realmString = await realm.evaluate(`'${hostString}'`); // 直接在 evaluate 字符串中嵌入
    console.log("Host String:", hostString, "| Realm String:", realmString);
    console.log("Are strings equal?", hostString === realmString); // true (值相等)

    // 2. 传递可克隆对象 (深拷贝)
    const hostObject = {
        name: "Host Object",
        data: [1, 2, { deep: true }]
    };
    console.log("Host Object (before transfer):", JSON.stringify(hostObject));

    // 使用 importValue 将对象导入到 Realm
    // 注意：importValue 并非直接执行代码，而是将值注册到 Realm 的全局作用域中
    // 实际使用时，通常会通过 evaluate 或 callable boundary 传递
    // 这里我们模拟通过 evaluate 传递和返回
    const realmObject = await realm.evaluate(`
        const receivedObject = ${JSON.stringify(hostObject)}; // 模拟接收一个深拷贝的对象
        receivedObject.name = 'Realm Modified Object';
        receivedObject.data[0] = 99;
        receivedObject.data[2].deep = false;
        receivedObject
    `);

    console.log("Host Object (after transfer/modification in realm):", JSON.stringify(hostObject)); // 宿主对象未被修改
    console.log("Realm Object (received back):", JSON.stringify(realmObject));

    console.log("Are objects strictly equal?", hostObject === realmObject); // false (因为是深拷贝，不是同一个引用)
    console.log("Was hostObject modified?", hostObject.name === "Host Object" && hostObject.data[0] === 1); // true (未修改)

    // 3. 传递 ArrayBuffer (可转移对象)
    const hostBuffer = new ArrayBuffer(8);
    const hostView = new DataView(hostBuffer);
    hostView.setFloat64(0, 3.14159, false);
    console.log("Host Buffer (before transfer):", hostView.getFloat64(0, false));

    // ArrayBuffer 类似 Web Workers，可以通过 transfer 机制移动所有权
    // 但在 Shadow Realms 中，通过 evaluate 返回的 ArrayBuffer 默认也是深拷贝
    // 如果要实现所有权转移，需要更高级的 API (如 Realm.transferrable) 或显式处理
    const realmBufferResult = await realm.evaluate(`
        const receivedBuffer = new ArrayBuffer(8); // 假设接收了一个新的 ArrayBuffer
        const receivedView = new DataView(receivedBuffer);
        receivedView.setFloat64(0, 2.71828, false);
        receivedBuffer;
    `);

    // 验证 hostBuffer 未被修改
    console.log("Host Buffer (after realm operation):", hostView.getFloat64(0, false)); // 仍然是 3.14159
    const realmViewResult = new DataView(realmBufferResult);
    console.log("Realm Buffer (received back):", realmViewResult.getFloat64(0, false)); // 2.71828
}

demonstrateValueTransfer();

解释：

原始值（字符串）在传递时是按值复制的，因此两个Realm中的字符串值相等。
复杂对象（如 hostObject）在跨Realm传递时会进行“结构化克隆”，即创建一个深拷贝。这意味着Shadow Realm对克隆对象的修改不会影响到宿主Realm中的原始对象。当对象从Shadow Realm返回到宿主Realm时，也会发生同样的事情。
ArrayBuffer 也是结构化克隆的一部分，默认情况下会深拷贝。如果需要所有权转移（像Web Workers中的那样），可能需要更特定的API或语义。

5.4 跨Realm通信：可调用边界（Callable Boundary）

这是Shadow Realms最强大和最独特之处。函数是唯一可以在Realm之间作为引用传递的“活”对象。当函数跨越Realm边界时，它会被封装成一个特殊的“可调用边界”对象。调用这个边界对象时，函数会在其原始创建的Realm中执行。

5.4.1 宿主调用Realm中的函数

// Host Realm (主环境)
async function demonstrateHostCallsRealmFunction() {
    console.log("n--- 5.4.1 宿主调用Realm中的函数 ---");

    const realm = await Realm.create();

    // 1. 在 Shadow Realm 中定义一个函数，并将其返回给宿主
    const realmFunction = await realm.evaluate(`
        (name) => {
            const greeting = `Hello, ${name} from Shadow Realm!`;
            console.log(greeting);
            return greeting.toUpperCase();
        }
    `);

    console.log("Type of realmFunction in Host Realm:", typeof realmFunction); // function

    // 2. 宿主调用从 Shadow Realm 返回的函数
    const result = await realmFunction("Alice"); // 调用时会在 Shadow Realm 中执行
    console.log("Result from calling realmFunction:", result); // HELLO, ALICE FROM SHADOW REALM!

    // 3. 再次调用，并传递一个对象
    const objResult = await realmFunction({ user: "Bob" }); // 对象会被深拷贝
    console.log("Result from calling realmFunction with object:", objResult); // HELLO, [OBJECT OBJECT] FROM SHADOW REALM!
}

demonstrateHostCallsRealmFunction();

解释：

realm.evaluate() 返回的函数，在宿主Realm中仍然是一个可调用的函数对象。
当宿主Realm调用 realmFunction("Alice") 时，"Alice" 这个原始值被复制到Shadow Realm。
函数体 ((name) => { ... }) 在Shadow Realm中执行。
console.log 调用的是Shadow Realm内部的 console.log（如果未配置，会转发到宿主）。
函数的返回值（greeting.toUpperCase()）又被复制回宿主Realm。

5.4.2 Realm调用宿主中的函数

// Host Realm (主环境)
async function demonstrateRealmCallsHostFunction() {
    console.log("n--- 5.4.2 Realm调用宿主中的函数 ---");

    const realm = await Realm.create();

    // 1. 在宿主环境定义一个函数
    const hostCallback = (message) => {
        console.log("Host Realm received callback:", message);
        return `Host processed: ${message.toUpperCase()}`;
    };

    // 2. 将宿主函数传递给 Shadow Realm
    // 提案中的 importValue 允许将宿主的值导入到 Shadow Realm 的全局 scope
    // 模拟通过 evaluate 传递
    const realmResult = await realm.evaluate(`
        // 模拟 hostCallback 已经被 importValue 导入，或者作为参数传递进来
        // 在实际的 Shadow Realms API 中，这会通过 Realm.importValue 实现
        // 假设我们通过 evaluate 的上下文传递
        (async (hostCb) => {
            console.log("Shadow Realm calling host callback...");
            const result = await hostCb('Data from Realm'); // 在 Host Realm 中执行
            console.log("Shadow Realm received result from host:", result);
            return result;
        })(/* hostCallback 从外部传入 */);
    `, { arguments: [hostCallback] }); // 假设 evaluate 有一种方式可以传递参数

    // 实际的 importValue 用法 (概念性)
    // await realm.importValue("hostCallback", hostCallback);
    // const realmResult = await realm.evaluate(`
    //     (async () => {
    //         console.log("Shadow Realm calling host callback...");
    //         const result = await hostCallback('Data from Realm'); // 在 Host Realm 中执行
    //         console.log("Shadow Realm received result from host:", result);
    //         return result;
    //     })();
    // `);

    console.log("Final result from Shadow Realm execution:", realmResult);
}

// 修正 demonstrateRealmCallsHostFunction，使其更符合当前的 Shadow Realms 提案精神
// 使用 realm.importValue 导入宿主函数，并在 realm.evaluate 中使用
async function demonstrateRealmCallsHostFunctionCorrected() {
    console.log("n--- 5.4.2 Realm调用宿主中的函数 (使用 importValue) ---");

    const realm = await Realm.create();

    // 1. 在宿主环境定义一个函数
    const hostCallback = (message) => {
        console.log("Host Realm received callback:", message);
        return `Host processed: ${message.toUpperCase()}`;
    };

    // 2. 将宿主函数通过 importValue 导入到 Shadow Realm
    // importValue 接受一个 "specifier" 和 "value"
    // specifier 是 Realm 内部用于引用这个值的名称
    await realm.importValue('hostCallback', hostCallback);
    console.log("Host callback imported to Shadow Realm as 'hostCallback'.");

    // 3. 在 Shadow Realm 中调用导入的宿主函数
    const realmResult = await realm.evaluate(`
        (async () => {
            console.log("Shadow Realm calling host callback 'hostCallback'...");
            const result = await hostCallback('Data from Realm'); // 调用 hostCallback，它会在 Host Realm 中执行
            console.log("Shadow Realm received result from host:", result);
            return result;
        })();
    `);

    console.log("Final result from Shadow Realm execution:", realmResult);
}

demonstrateRealmCallsHostFunctionCorrected();

解释：

realm.importValue('hostCallback', hostCallback) 将宿主Realm中的 hostCallback 函数导入到Shadow Realm中，并使其在Shadow Realm中可以通过 hostCallback 这个名称访问。
当Shadow Realm中的代码调用 hostCallback('Data from Realm') 时，这个调用会“穿透”Realm边界，在宿主Realm中执行 hostCallback 函数。
'Data from Realm' 字符串被复制到宿主Realm。
hostCallback 的返回值（"Host processed: DATA FROM REALM"）又被复制回Shadow Realm。

这种“可调用边界”机制是Shadow Realms实现安全双向通信的关键，它允许功能调用，同时严格控制数据流，防止直接的对象引用泄露。

5.5 错误处理

Shadow Realms 中的错误默认情况下会封装在自己的Realm中，不会直接影响到宿主Realm的执行流，除非错误被显式地传播出来。

// Host Realm (主环境)
async function demonstrateErrorHandling() {
    console.log("n--- 5.5 错误处理 ---");

    const realm = await Realm.create();

    // 1. 在 Shadow Realm 中发生一个未捕获的错误
    try {
        await realm.evaluate(`
            console.log("About to throw an error in Shadow Realm...");
            throw new Error('Something went wrong in the realm!');
            console.log("This line will not be reached.");
        `);
    } catch (e) {
        console.error("Host Realm caught an error from Shadow Realm:", e.message);
        console.error("Error type:", e.constructor.name);
        console.error("Error stack (if available):", e.stack);
    }

    // 2. 宿主 Realm 的执行不受影响，继续
    console.log("Host Realm continues execution after realm error.");

    // 3. 在 Shadow Realm 中捕获错误并返回结果
    const safeResult = await realm.evaluate(`
        try {
            console.log("Trying to do something risky...");
            throw new TypeError('Invalid operation!');
        } catch (e) {
            console.log("Shadow Realm caught its own error:", e.message);
            return { error: e.message, type: e.constructor.name };
        }
    `);

    console.log("Host Realm received safe result from realm:", safeResult);
}

demonstrateErrorHandling();

解释：

当Shadow Realm中发生未捕获的错误时，realm.evaluate() 方法会返回一个 rejected Promise，宿主Realm可以通过 try...catch 捕获这个错误。
捕获到的错误对象是一个新的错误对象，其 message 和 stack 属性通常会包含原始错误的详细信息，但它并不是原始错误的引用。它是一个经过序列化和反序列化过程的错误副本。
Shadow Realm内部捕获的错误，不会传播到宿主Realm，而是可以返回一个包含错误信息的普通对象。

5.6 模拟插件系统

通过结合可调用边界和值传递，我们可以构建一个简单的插件系统。

// Host Realm (主环境)
async function simulatePluginSystem() {
    console.log("n--- 5.6 模拟插件系统 ---");

    const realm = await Realm.create();

    // 1. 宿主环境提供一些核心API给插件
    const hostApi = {
        log: (message) => console.log(`[Host API Log]: ${message}`),
        getData: async (key) => {
            hostApi.log(`Fetching data for key: ${key}`);
            await new Promise(resolve => setTimeout(resolve, 50)); // Simulate async op
            return `Data for ${key} from Host`;
        },
        sendEvent: (eventName, payload) => {
            hostApi.log(`Event '${eventName}' sent with payload: ${JSON.stringify(payload)}`);
        }
    };

    // 2. 将宿主API导入到 Shadow Realm
    await realm.importValue('hostApi', hostApi);

    // 3. 插件代码 (在 Shadow Realm 中执行)
    const pluginCode = `
        (async () => {
            hostApi.log('Plugin initialized!');

            // 插件调用宿主API
            const someData = await hostApi.getData('plugin_config');
            hostApi.log('Plugin received data: ' + someData);

            // 插件计算一个结果并返回
            const result = `Processed: ${someData.toUpperCase()} by Plugin.`;

            // 插件发送一个事件
            hostApi.sendEvent('plugin_ready', { status: 'success', resultLength: result.length });

            // 插件也可以定义自己的函数，供宿主调用
            const pluginProcessor = (input) => {
                hostApi.log(`Plugin processing: ${input}`);
                return `[Plugin Output]: ${input.split('').reverse().join('')}`;
            };

            return {
                status: 'active',
                processor: pluginProcessor // 将插件内部的函数返回给宿主
            };
        })();
    `;

    // 4. 宿主执行插件代码
    const pluginModule = await realm.evaluate(pluginCode);
    console.log("Host received plugin module:", pluginModule);

    // 5. 宿主调用插件返回的函数
    if (pluginModule && pluginModule.processor) {
        const processedResult = await pluginModule.processor("Hello World"); // 在 Shadow Realm 中执行
        console.log("Host received processed result from plugin:", processedResult);
    }
}

simulatePluginSystem();

解释：

宿主通过 realm.importValue() 机制，将一个包含多个方法的 hostApi 对象导入到Shadow Realm中。这个 hostApi 对象在跨越Realm边界时，其方法会自动成为可调用边界。
插件代码在Shadow Realm中执行，可以直接通过 hostApi.log、hostApi.getData 等调用宿主提供的功能。这些调用会“穿透”边界，在宿主Realm中执行。
插件也可以定义自己的函数（如 pluginProcessor），并将其作为返回值的一部分传递回宿主Realm。宿主Realm在接收到这个函数后，可以像调用本地函数一样调用它，而这个函数的实际执行仍会在Shadow Realm中进行。
所有数据的传递（'plugin_config', someData, { status: ..., resultLength: ... } 等）都是通过值复制（深拷贝）进行的，确保了数据隔离。

6. Shadow Realms 的优势与高级考量

6.1 核心优势

强隔离性： 真正的物理隔离，包括独立的全局对象和一套全新的内置对象，有效防止原型链污染和全局对象篡改。
宿主控制权： 宿主环境对Shadow Realm拥有绝对的控制权。Realm内部无法自动访问宿主环境的API（如 fetch, localStorage, document 等），所有必要的API都必须由宿主显式地导入。
安全通信： 受限的通信协议（原始值、结构化克隆、可调用边界）保证了Realm之间的数据流和功能调用的安全性，避免了直接的对象引用共享。
同步与异步： evaluate 和 importValue 本身是异步操作（返回Promise），但一旦建立了可调用边界，函数调用可以模拟同步或异步行为，具体取决于函数本身的实现。
跨平台潜力： 作为TC39提案，Shadow Realms有望成为JavaScript语言层面的标准隔离机制，可以在浏览器、Node.js、Deno等所有支持JavaScript的环境中实现一致的行为。

6.2 性能考量

启动开销： 创建一个新的Shadow Realm会涉及引擎初始化一个新的执行环境，这会有一定的启动开销，可能比 eval() 或 Web Worker 更高。
通信开销： 跨Realm通信涉及数据序列化/反序列化（对于可克隆对象）以及上下文切换（对于可调用边界），这会带来一定的性能开销。因此，应尽量减少不必要的跨Realm通信，尤其是在性能敏感的循环中。
内存使用： 每个Shadow Realm都会维护一套独立的内置对象，这意味着它会消耗额外的内存。

6.3 安全性不是银弹

尽管Shadow Realms提供了强大的隔离能力，但它并非解决所有安全问题的银弹：

资源限制： Shadow Realms本身不提供CPU、内存、网络等系统资源的限制。宿主环境仍需结合平台特有的机制（如Node.js的 worker_threads 或操作系统级别的沙箱）来限制资源。
侧信道攻击： 即使是物理隔离，理论上仍然可能存在侧信道攻击的风险（例如，通过测量代码执行时间来推断私密信息）。
恶意宿主： Shadow Realm 的安全性依赖于宿主环境的正确实现。如果宿主环境本身是恶意的，它仍然可以注入恶意代码或以不安全的方式使用Shadow Realms。
API 滥用： 如果宿主环境将过于强大的API（例如，文件系统写入、网络请求）无限制地导入到Shadow Realm中，那么Shadow Realm中的恶意代码仍然可以滥用这些API。安全性取决于宿主如何选择性地暴露API。

7. 对比现有技术

特性	`eval()` / `new Function()`	`<iframe>`	Web Workers	Node.js `vm` module	Shadow Realms
隔离级别	无	文档/全局对象	全局对象	全局对象（可配置）	物理隔离 (全新内置对象)
内置对象	共享宿主	独立的（但可能受宿主影响）	独立的	共享宿主（可配置）	完全独立
DOM 访问	是	是	否	否	否（默认），宿主可导入
通信机制	直接访问	`postMessage` (异步)	`postMessage` (异步)	共享对象（引用）/ `vm.runInContext`	可调用边界 (同步/异步), 原始值/结构化克隆 (深拷贝)
平台支持	浏览器/Node.js	浏览器	浏览器	Node.js	TC39 标准 (浏览器/Node.js)
性能开销	低	高（完整文档）	中等	低-中等	中等（启动，通信）
主要用途	动态代码执行	UI沙箱，嵌入内容	后台计算，非阻塞任务	服务器端沙箱，代码执行	强隔离沙箱，插件系统，跨平台安全执行

8. 展望与未来

Shadow Realms 提案目前处于TC39的Stage 3阶段，这意味着它已接近完成，并被浏览器和JavaScript运行时实现者广泛审查。我们有望在不久的将来看到它在主流JavaScript引擎中的广泛应用。

Shadow Realms 的引入，将为JavaScript开发者提供一个前所未有的强大工具，用于构建更安全、更可靠、更模块化的应用程序。它将彻底改变我们处理 untrusted code、插件系统和多租户环境的方式，使JavaScript能够更好地应对日益复杂的安全挑战。它不仅是技术上的进步，更是JavaScript生态系统在迈向更成熟、更安全方向上的一个重要里程碑。

通过今天对Shadow Realms的深入探讨，我们理解了其核心理念——完全的物理隔离与受限通信协议，以及它如何通过新的API和机制，弥补现有隔离方案的不足。这是一个激动人心的提案，预示着JavaScript沙箱技术的新纪元。

1. 隔离的迫切需求：为何我们需要更强的沙箱？

2. 现有隔离机制的局限性

2.1 eval() 和 new Function()

2.2 <iframe> 元素

2.3 Web Workers

2.4 Node.js vm 模块

3. Shadow Realms 的核心理念：物理隔离与受限通信

4. Shadow Realms API 概览

5. 深入代码实践

5.1 创建并执行基本代码

5.2 验证内置对象的物理隔离

5.3 跨Realm通信：原始值与可克隆对象

5.4 跨Realm通信：可调用边界（Callable Boundary）

5.4.1 宿主调用Realm中的函数

5.4.2 Realm调用宿主中的函数

5.5 错误处理

5.6 模拟插件系统

6. Shadow Realms 的优势与高级考量

6.1 核心优势

6.2 性能考量

6.3 安全性不是银弹

7. 对比现有技术

8. 展望与未来

发表回复 取消回复

2.1 `eval()` 和 `new Function()`

2.2 `<iframe>` 元素

2.4 Node.js `vm` 模块

发表回复取消回复