Пісочниці та ізоляція інструментів: Docker, gVisor та WASM для MCP

[Агент генерирует Tool Call: execute_code / read_data]
                           │
                           ▼
          ┌──────────────────────────────────┐
          │    MCP Security Gateway Proxy    │ ──(Schema & Capability Check)
          └──────────────────────────────────┘
                           │
       [Выбор рантайма по профилю изоляции]
       ┌───────────────────┴───────────────────┐
       ▼                                       ▼
┌───────────────────────────────┐   ┌───────────────────────────────┐
│     WASM / WASI Sandbox       │   │    gVisor (runsc) MicroVM     │
│ - Чистые вычисления / парсинг │   │ - Shell, Python, Node.js      │
│ - Холодный старт: < 5 мс      │   │ - User-space перехват syscalls│
│ - Нулевой доступ к FS и сети  │   │ - Защита от Container Escape  │
└───────────────────────────────┘   └───────────────────────────────┘
               │                                       │
               └───────────────────┬───────────────────┘
                                   │
                                   ▼
          ┌──────────────────────────────────┐
          │   Egress Network Filter (eBPF)   │
          │  - Блокировка 169.254.169.254    │ ──(Drop Unauthorized Packets)
          │  - Блокировка RFC 1918 подсетей  │
          └──────────────────────────────────┘
                                   │
                                   ▼
                      [Безопасный JSON-ответ агенту]

# Базовый образ для изолированного выполнения скриптов агента
FROM node:22-alpine

# Создание непривилегированного пользователя (Rootless)
RUN addgroup -S sandboxgroup && adduser -S sandboxuser -G sandboxgroup

# Подготовка временной директории с монтированием в tmpfs
WORKDIR /app
RUN chown -R sandboxuser:sandboxgroup /app

USER sandboxuser

# Входная точка исполнения изолированного кода
ENTRYPOINT ["node", "--disallow-code-generation-from-strings"]

services:
  mcp-code-sandbox:
    image: mcp-node-sandbox:latest
    # Использование gVisor рантайма вместо стандартного runc
    runtime: runsc
    read_only: true
    user: "10001:10001"
    # Монтирование доступной для записи области только в оперативную память (tmpfs)
    tmpfs:
      - /tmp:rw,noexec,nosuid,size=64m
      - /app/scratch:rw,noexec,nosuid,size=32m
    # Полное отключение привилегий ядра Linux
    cap_drop:
      - ALL
    security_opt:
      - no-new-privileges:true
    # Строгие лимиты ресурсов для защиты от Fork Bomb и исчерпания памяти
    pids_limit: 30
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
    # Сетевая изоляция: контейнер не имеет внешнего доступа
    network_mode: none

import { z } from 'zod';

// Контракт входных параметров для MCP-инструмента
export const ExecuteWasmPayloadSchema = z.object({
  wasmBinaryBase64: z.string(),
  functionName: z.string().regex(/^[a-zA-Z0-9_]+$/),
  inputNumber: z.number().int(),
  timeoutMs: z.number().max(5000).default(2000),
});

export type ExecuteWasmPayload = z.infer<typeof ExecuteWasmPayloadSchema>;

export class McpWasmSandboxGateway {
  /**
   * Безопасное выполнение байт-кода WebAssembly в изолированном контексте V8
   */
  public async executeInWasmSandbox(payload: ExecuteWasmPayload): Promise<{ result: number; executionTimeMs: number }> {
    const { wasmBinaryBase64, functionName, inputNumber, timeoutMs } = ExecuteWasmPayloadSchema.parse(payload);

    const wasmBuffer = Buffer.from(wasmBinaryBase64, 'base64');

    // Ограничение размера WASM-бинарника (максимум 5 МБ)
    if (wasmBuffer.length > 5 * 1024 * 1024) {
      throw new Error('Payload limit exceeded: WASM binary size is capped at 5MB.');
    }

    const startTime = performance.now();

    // Создание изолированного WebAssembly модуля
    const wasmModule = await WebAssembly.compile(wasmBuffer);

    // Окружение с нулевым импортом системных вызовов хоста (No Host System Imports)
    const importObject = {
      env: {
        abort: () => {
          throw new Error('WASM Execution Aborted by Runtime.');
        },
      },
    };

    const instance = await WebAssembly.instantiate(wasmModule, importObject);
    const targetFn = instance.exports[functionName];

    if (typeof targetFn !== 'function') {
      throw new Error(`Target function '${functionName}' is not exported by WASM module.`);
    }

    // Выполнение с контролем тайм-аута (AbortController / Promise.race)
    const executionPromise = Promise.resolve().then(() => (targetFn as (val: number) => number)(inputNumber));

    const timeoutPromise = new Promise<never>((_, reject) =>
      setTimeout(() => reject(new Error(`WASM execution timed out after ${timeoutMs}ms`)), timeoutMs)
    );

    const result = await Promise.race([executionPromise, timeoutPromise]);
    const executionTimeMs = performance.now() - startTime;

    return { result, executionTimeMs };
  }

  /**
   * Валидация исходящего сетевого адреса для MCP-инструментов с поддержкой HTTP
   */
  public static validateEgressUrl(rawUrl: string): URL {
    const parsed = new URL(rawUrl);

    // Запрет нестандартных протоколов
    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
      throw new Error(`Forbidden protocol: ${parsed.protocol}`);
    }

    const hostname = parsed.hostname;

    // Защита от обращения к Cloud Metadata Service (SSRF)
    if (hostname === '169.254.169.254' || hostname === 'metadata.google.internal') {
      throw new Error('Access Denied: Cloud Metadata Service access prohibited.');
    }

    // Блокировка приватных IP диапазонов (RFC 1918) и Localhost
    const isPrivate = /^(localhost|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+)$/i.test(
      hostname
    );

    if (isPrivate) {
      throw new Error(`SSRF Block: Access to internal IP/host '${hostname}' is prohibited.`);
    }

    return parsed;
  }
}