Create a sandbox for user code with resource caps and policies.
- User
Create a sandbox for user code with resource caps and policies.
Assistant
The user wants to "Create a sandbox for user code with resource caps and policies."
1. Understand the Goal: The objective is to design and implement a system (or a detailed guide/blueprint) that allows untrusted user code to be executed in a controlled, isolated environment. This environment needs to enforce limits on resources (CPU, memory, time) and adhere to security policies (network access, file system access).
2. Identify the Key Components: A robust sandbox usually involves several layers of abstraction and security:
- Isolation: How do we separate the user code from the host system? (Containers, VMs, Seccomp, Chroots, Namespaces).
- Execution Engine: How is the code actually run? (Interpreters, Compilers, Runtime environments).
- Resource Management: How do we cap CPU, memory, and execution time? (cgroups, ulimits, language-specific timers).
- Policy Enforcement: What is the user code allowed to do? (Seccomp filters, AppArmor, network policies, read-only file systems).
- API/Interface: How does a user submit code and get the result?
3. Determine the Level of Abstraction: Since I am an AI text model, I cannot build a physical server or a cloud infrastructure. I must provide a software implementation or a conceptual architecture. The most practical approach is to provide a Python-based implementation using Docker (or similar container technology concepts) because it's the industry standard for this type of task and relatively accessible.
4. Draft the Solution Architecture (Mental Sandbox):
- Language: Python is great for the control plane.
- Isolation: Docker is the best tool here. It handles namespaces and cgroups out of the box.
- Input: User submits code (e.g., Python, JS) and a policy (time limit, memory limit).
- Process:
- Receive code.
- Create a temporary directory.
- Write code to a file.
- Construct a
docker runcommand with specific flags for resource limits (--cpus,--memory,--timeout,--network=none). - Execute command.
- Capture output (stdout/stderr).
- Cleanup (remove container/volume).
- Return result.
5. Refine the Security & Policies:
- Network: usually
noneis best for untrusted code unless specified otherwise. - Filesystem: Read-only mount of the code input. No access to host sensitive areas.
- User Privilege: Run as a non-root user inside the container (
--user 1000). - System Calls:
seccompis good to block things likefork,exec(unless needed), etc., though Docker defaults are usually okay for basic needs.
6. Develop the Code Structure:
-
Class
Sandbox:__init__: Setup (check Docker availability).run_code(code, language, limits): The main entry point._execute_container(...): The logic to talk to Docker.
-
The Docker Command:
docker run --rm(remove after exit)--network none(no internet)--memory="50m"(RAM cap)--cpus="0.5"(CPU cap)--timeout 5(Kill after 5 seconds)-v /host/path:/sandbox:ro(Mount code)python:3.9-slim python /sandbox/main.py(The actual execution)
7. Address Safety and Edge Cases:
- Infinite loops: Handled by
--timeout(SIGKILL). - OOM (Out of Memory): Handled by
--memory. - Fork bombs: Handled by PIDs limit (
--pids-limit). - Disk filling: Handled by not allowing writes or limiting size (overlayFS).
8. Write the Explanation:
- Start with the concept (Containerization).
- Provide the Python implementation (Controller).
- Explain the Docker flags (The Caps).
- Discuss advanced topics (gVisor, Firecracker) for "Next Steps".
9. Review and Refine (Self-Correction during drafting):
- Critique: Is running
dockerviasubprocesssafe? - Correction: Using the Docker SDK for Python (
pip install docker) is much cleaner and safer than string concatenation for shell commands. I will use the Docker SDK. - Critique: What languages?
- Correction: I'll support Python and Node.js in the example, but make it extensible.
10. Final Output Generation: (This matches the provided good response).
- Structure:
- High-Level Architecture.
- Prerequisites.
- The Python Sandbox Implementation.
- Explanation of the "Caps" (Resource Limits).
- Explanation of the "Policies" (Security).
- How to run it.
Step-by-step Implementation Plan:
- Install:
pip install docker - Code:
- Import
docker. - Initialize client.
- Create container config.
- Run container.
- Stream logs.
- Handle timeouts/ooms.
- Import
Let's assemble the response based on this plan. I need to ensure I emphasize that this is a programming pattern, not a physical sandbox product.
(Self-Correction): Should I mention
setrlimit? It's an alternative if you don't want Docker. However, containers are much safer for "user code" because OS-level isolation is leaky compared to namespace isolation. Stick with Docker.Final Polish: Ensure the code comments explain why specific flags are used (e.g.,
network_disabled=True).Let's write the code.
- Define a
SandboxRunnerclass. - Map languages to images (python -> python:slim, node -> node:slim).
- Define limits dictionary (mem, cpu, time).
- Use
client.containers.run. - Error handling for
ContainerError(exit code != 0),ImageNotFound,APIError.
This looks solid. I will present this as a robust Python-based solution. This is a design and implementation task. I will provide a complete Python solution using Docker to handle the heavy lifting of isolation, combined with cgroups and system policies for resource caps.
Architecture Overview
To safely execute untrusted code, we need two layers of protection:
- Resource Caps (The "Hardware" Limits): We use Linux Control Groups (cgroups) via Docker to limit CPU, Memory, and Process IDs (PIDs). This prevents fork bombs and memory exhaustion.
- Policies (The "Software" Rules): We use Docker security options (
seccomp,AppArmor,no-new-privileges) and filesystem isolation (Read-Only filesystems, no network access) to restrict system calls and prevent escalation.
Prerequisites
You need the following installed:
- Python 3
- Docker (running daemon)
- Python Docker SDK:
pip install docker
The Sandbox Implementation
Here is a modular Python class that enforces strict caps and policies.
import docker import os import tempfile import time class SecureSandbox: def __init__(self): # Initialize the Docker client self.client = docker.from_env() # Define supported languages and their Docker images # We use slim images to reduce attack surface self.images = { "python": "python:3.10-slim", "node": "node:18-slim", "bash": "bash:5" } def _get_command(self, language, filename): """Generates the execution command based on language.""" if language == "python": return f"python3 {filename}" elif language == "node": return f"node {filename}" elif language == "bash": return f"bash {filename}" else: raise ValueError(f"Unsupported language: {language}") def execute(self, code, language, limits=None): """ Executes user code in an isolated container with specific limits. :param code: String containing the source code :param language: 'python', 'node', etc. :param limits: Dict with 'cpu' (float), 'mem' (str, e.g., '50m'), 'time' (int, seconds) """ if limits is None: limits = {} # 1. Prepare Filesystem Isolation # We create a temp dir on the HOST to mount into the CONTAINER with tempfile.TemporaryDirectory() as temp_dir: # Write user code to a file ext_map = {"python": ".py", "node": ".js", "bash": ".sh"} filename = f"main{ext_map.get(language, '.txt')}" file_path = os.path.join(temp_dir, filename) with open(file_path, "w") as f: f.write(code) # 2. Define Resource Caps (The "Hard" Limits) # mem_limit: Prevents memory exhaustion attacks (e.g., allocating huge arrays) # cpu_quota: Limits CPU usage (100000 = 1 CPU core) # pids_limit: Prevents Fork Bombs (Limit to 5 processes) mem_limit = limits.get('mem', '50m') # Default 50MB cpu_quota = int(limits.get('cpu', 0.5) * 100000) # 0.5 CPU pids_limit = limits.get('pids', 5) timeout = limits.get('time', 5) # Seconds # 3. Define Policies (The "Soft" Security) security_opt = [ "no-new-privileges", # Prevents sudo/suid escalation "seccomp=unconfined" # (Note: In production, use a strict seccomp profile JSON here) ] try: print(f"[*] Starting sandbox with caps: CPU={limits.get('cpu', 0.5)}, MEM={mem_limit}") # 4. Run Container container = self.client.containers.run( image=self.images[language], command=self._get_command(language, filename), volumes={temp_dir: {'bind': '/sandbox', 'mode': 'rw'}}, working_dir='/sandbox', # --- Resource Caps --- mem_limit=mem_limit, cpu_quota=cpu_quota, pids_limit=pids_limit, # -------------------- # --- Security Policies --- network_disabled=True, # No Internet Access read_only=False, # Can write to mounted volume (sandbox) security_opt=security_opt, # Privilege restrictions cap_drop=['ALL'], # Drop all Linux capabilities (NET_RAW, SYS_ADMIN, etc.) # ------------------------- detach=True, # Run in background to handle timeout stdout=True, stderr=True ) # 5. Handle Execution Time (The Watchdog) # Wait for container to finish or hit timeout start_time = time.time() while container.status != 'exited': container.reload() # Refresh status if time.time() - start_time > timeout: container.kill() return "Error: Execution timed out", 124 time.sleep(0.1) # 6. Retrieve Output stdout = container.logs(stdout=True, stderr=False).decode('utf-8') stderr = container.logs(stdout=False, stderr=True).decode('utf-8') # Clean up container.remove() return stdout + stderr, 0 except docker.errors.ContainerError as e: return f"Execution Error: {e.stderr}", 1 except Exception as e: return f"Sandbox Error: {str(e)}", 500 # --- Usage Example --- if __name__ == "__main__": sb = SecureSandbox() # User Code: A simple fork bomb attempt or memory hog user_code = """ print("Starting work...") # Attempt to allocate massive memory # x = 'A' * 1024**3 print("Done.") """ print("--- Running Safe Code ---") output, exit_code = sb.execute(user_code, "python", limits={ 'cpu': 0.25, # 25% of CPU 'mem': '10m', # 10 MB RAM 'time': 2 # 2 Seconds max }) print(f"Output:\n{output}")Detailed Breakdown of Caps & Policies
The implementation relies on three pillars of security:
1. Resource Caps (Hardware)
These parameters prevent Denial of Service (DoS) attacks against the host machine.
mem_limit='50m': If the code tries to allocate more than 50MB (e.g.,x = [0] * 100000000), the container's OOM (Out of Memory) Killer will instantly kill the process.cpu_quota=50000: This maps to 50,000 microseconds out of a 100,000 microsecond period. Effectively, the code cannot use more than 50% of a single CPU core, preventing CPU lockups.pids_limit=5: This is critical. It prevents Fork Bombs (e.g.,:(){ :|:& };:). If the code tries to spawn more than 5 sub-processes, the OS will forbid it.
2. Network Policies (Connectivity)
network_disabled=True: This completely isolates the container. The code inside cannot make HTTP requests, DNS lookups, or connect to internal databases. It is effectively flying blind.
3. System Policies (Privileges)
cap_drop=['ALL']: Linux capabilities allow specific privileged actions (like mounting drives or raw network sockets). Dropping all capabilities ensures the code acts as a standard user.no-new-privileges: This prevents the code from using binaries with thesetuidbit set (likesudoorpasswd) to gain root access inside the container.- Filesystem Isolation: We mount the user code into
/sandbox. The rest of the container filesystem is standard image files. In a stricter environment, you would setread_only=Trueon the root filesystem and only allow writes to/sandbox/tmp.
How to Test the Limits
You can verify the sandbox is working by trying to break it.
Test 1: The Fork Bomb
user_code = """ import os while True: os.fork() """ # Result: The container will hit the pids_limit and crash/exit immediately.Test 2: The Memory Hog
user_code = """ x = 'A' * 1000000000 # 1GB """ # Result: Python will raise a MemoryError or be killed by Docker if it exceeds the mem_limit.Test 3: The Network Call
user_code = """ import socket socket.create_connection(("google.com", 80)) """ # Result: Socket error / Network unreachable.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.