Rust安全沙箱库gaol的使用：轻量级进程隔离与资源控制框架

介绍

gaol是一个Rust实现的安全沙箱库，提供了轻量级的进程隔离和资源控制功能。它允许你在受控环境中运行不可信代码，同时限制其对系统资源的访问。gaol特别适合需要执行第三方或不可信代码的场景，如插件系统、在线代码评测平台等。

gaol的主要特点包括：

• 轻量级进程隔离
• 细粒度的资源控制(CPU、内存、网络等)
• 简单的API设计
• 基于Linux命名空间和cgroups实现

安装方法

在Cargo.toml中添加依赖：

[dependencies]
gaol = "0.3"

基本使用方法

1. 创建简单的沙箱

use gaol::sandbox::{Sandbox, ChildSandbox, Profile};
use gaol::sandbox::profile::Operation;

fn main() {
    // 定义沙箱规则
    let profile = Profile::new(vec![
        Operation::SystemReadWhitelist(vec!["/etc/resolv.conf".into()]),
        Operation::SystemWriteWhitelist(vec![]),
    ]);

    // 创建沙箱
    let sandbox = Sandbox::new(profile).unwrap();

    // 在沙箱中运行代码
    sandbox.run(|| {
        println!("Hello from inside the sandbox!");
        // 这里运行的代码受到沙箱限制
    }).unwrap();
}

2. 限制资源使用

use gaol::sandbox::{Sandbox, Profile};
use gaol::sandbox::profile::{Operation, ResourceLimits};

fn main() {
    let profile = Profile::new(vec![
        Operation::ResourceLimits(ResourceLimits {
            max_cpu_time: Some(std::time::Duration::from_secs(1)),
            max_memory_bytes: Some(100 * 1024 * 1024), // 100MB
            ..Default::default()
        }),
    ]);

    let sandbox = Sandbox::new(profile).unwrap();

    match sandbox.run(|| {
        // 尝试分配大量内存会被阻止
        let _big_vec = vec![0u8; 200 * 1024 * 1024];
    }) {
        Ok(_) => println!("Execution completed"),
        Err(e) => eprintln!("Sandbox error: {}", e),
    }
}

3. 网络访问控制

use gaol::sandbox::{Sandbox, Profile};
use gaol::sandbox::profile::Operation;

fn main() {
    let profile = Profile::new(vec![
        // 禁止所有网络访问
        Operation::NetworkAccess(false),
    ]);

    let sandbox = Sandbox::new(profile).unwrap();

    sandbox.run(|| {
        // 尝试网络访问会失败
        if let Err(e) = std::net::TcpStream::connect("example.com:80") {
            println!("Network access blocked as expected: {}", e);
        }
    }).unwrap();
}

高级用法

1. 自定义错误处理

use gaol::sandbox::{Sandbox, Profile};
use gaol::sandbox::profile::Operation;

fn main() {
    let profile = Profile::new(vec![
        Operation::SystemReadWhitelist(vec!["/allowed/path".into()]),
    ]);

    let sandbox = Sandbox::new(profile).unwrap();

    let result = sandbox.run(|| {
        // 尝试读取不允许的文件
        std::fs::read_to_string("/etc/passwd")
    });

    match result {
        Ok(content) => println!("Got content: {}", content),
        Err(e) => eprintln!("Sandbox prevented file access: {}", e),
    }
}

2. 结合异步运行时

use gaol::sandbox::{Sandbox, Profile};
use gaol::sandbox::profile::Operation;
use tokio::runtime::Runtime;

fn main() {
    let profile = Profile::new(vec![
        Operation::SystemReadWhitelist(vec!["/allowed/path".into()]),
    ]);

    let sandbox = Sandbox::new(profile).unwrap();
    let rt = Runtime::new().unwrap();

    sandbox.run(|| {
        rt.block_on(async {
            // 在沙箱内执行异步代码
            tokio::time::sleep(std::time::Duration::from_secs(1).await;
            println!("Async code executed in sandbox");
        })
    }).unwrap();
}

完整示例demo

下面是一个综合使用gaol各种功能的完整示例：

use gaol::sandbox::{Sandbox, Profile};
use gaol::sandbox::profile::{Operation, ResourceLimits};
use std::time::Duration;

fn main() {
    // 定义沙箱规则
    let profile = Profile::new(vec![
        // 文件系统访问控制
        Operation::SystemReadWhitelist(vec![
            "/usr/lib".into(),
            "/lib".into(),
            "/lib64".into()
        ]),
        Operation::SystemWriteWhitelist(vec![]),
        
        // 资源限制
        Operation::ResourceLimits(ResourceLimits {
            max_cpu_time: Some(Duration::from_secs(2)),
            max_memory_bytes: Some(50 * 1024 * 1024), // 50MB
            max_stack_bytes: Some(1 * 1024 * 1024),   // 1MB
            ..Default::default()
        }),
        
        // 网络控制
        Operation::NetworkAccess(false),
        
        // 进程控制
        Operation::ProcessLimit(1),
    ]);

    // 创建沙箱
    let sandbox = Sandbox::new(profile).expect("Failed to create sandbox");

    // 在沙箱中运行代码
    match sandbox.run(|| {
        println!("Running in sandbox environment");
        
        // 尝试分配内存
        let vec = vec![0u8; 10 * 1024 * 1024]; // 10MB
        
        // 尝试网络访问
        if let Err(e) = std::net::TcpStream::connect("8.8.8.8:80") {
            println!("Network access blocked as expected: {}", e);
        }
        
        // 模拟CPU密集型任务
        let start = std::time::Instant::now();
        while start.elapsed() < Duration::from_secs(3) {
            // 长时间运行可能会被CPU时间限制中断
        }
        
        println!("Sandbox execution completed");
    }) {
        Ok(_) => println!("Sandbox exited normally"),
        Err(e) => eprintln!("Sandbox error: {}", e),
    }
}

注意事项

1. gaol目前主要支持Linux平台
2. 需要适当的系统权限(通常需要root或相应的capabilities)
3. 沙箱不能提供完全的安全隔离，不适合运行恶意代码
4. 资源限制可能有少量误差

gaol提供了一种在Rust中实现轻量级进程隔离的便捷方式，通过合理配置规则，可以在许多场景下增强应用程序的安全性。