"""Bounded, fail-closed execution and comparison. Never imports candidate code.""" from pathlib import Path import ast import concurrent.futures import hashlib import json import os import subprocess import sys import tempfile import time ROOT = Path(__file__).resolve().parents[1] JAIL = Path('/home/user/.cache/python_curation/empty_jail') WORKER = ROOT / 'scripts/sandbox_worker.py' ALLOWED_IMPORTS = { 'sys', 'math', 'bisect', 'heapq', 'collections', 'functools', 'itertools', 'operator', 're', 'string', 'statistics', 'random', 'typing', 'fractions', 'decimal' } BANNED_CALLS = {'eval', 'exec', 'compile', 'open', '__import__', 'breakpoint', 'globals', 'locals', 'getattr', 'setattr', 'delattr', 'vars', 'input_file'} def sha(text): return hashlib.sha256(text.encode()).hexdigest() def static_check(code): tree = ast.parse(code) for node in ast.walk(tree): if isinstance(node, (ast.Import, ast.ImportFrom)): names = [a.name.split('.')[0] for a in node.names] if isinstance(node, ast.Import) else [(node.module or '').split('.')[0]] if any(n not in ALLOWED_IMPORTS for n in names): raise ValueError('unsupported import: ' + ','.join(names)) if isinstance(node, ast.Name) and node.id in BANNED_CALLS: raise ValueError('disallowed capability: ' + node.id) if isinstance(node, ast.Attribute) and (node.attr.startswith('__') or node.attr in {'modules', 'environ', 'path', 'stdout', 'stderr', '__stdin__'}): # Normal stdout use is unnecessary in this restricted pilot; do not # allow code to replace or introspect the result-capture mechanism. raise ValueError('disallowed attribute: ' + node.attr) return True def execute(payload, timeout=6): JAIL.mkdir(parents=True, exist_ok=True) JAIL.chmod(0o755) if any(JAIL.iterdir()): raise RuntimeError('Jail must remain empty') before = time.monotonic() with tempfile.TemporaryFile() as output, tempfile.TemporaryFile() as error: proc = subprocess.Popen( [sys.executable, '-I', str(WORKER), str(JAIL)], stdin=subprocess.PIPE, stdout=output, stderr=error, cwd=str(JAIL), close_fds=True, start_new_session=True, env={'PATH': '/usr/bin:/bin', 'LANG': 'C.UTF-8', 'PYTHONHASHSEED': '0'}, ) status = 'completed' try: proc.communicate(json.dumps(payload, ensure_ascii=False).encode(), timeout=timeout) except subprocess.TimeoutExpired: os.killpg(proc.pid, 9) proc.communicate() status = 'timeout' output.seek(0); error.seek(0) stdout = output.read(4 * 1024**2 + 1).decode('utf-8', 'replace') stderr = error.read(16000).decode('utf-8', 'replace') return {'status': status, 'exit_code': proc.returncode, 'stdout': stdout, 'stderr': stderr, 'wall_seconds': round(time.monotonic() - before, 5)} def compare(actual, expected, mode): if mode == 'call': try: got = json.loads(actual) except (ValueError, TypeError): return False # Keep boolean vs integer and string vs numeric distinctions. return type(got) is type(expected) and got == expected # TACO judge whitespace is not semantically meaningful for these integer / # YES-NO tasks. No approximate numeric comparison or answer rewriting. return actual.split() == str(expected).split() def run_case(code, entry_point, case): payload = {'code': code, 'mode': case['mode']} if case['mode'] == 'stdin': payload['input'] = case['input'] else: payload['entry_point'] = entry_point payload['args'] = case['args'] got = execute(payload) passed = (got['status'] == 'completed' and got['exit_code'] == 0 and compare(got['stdout'], case['expected'], case['mode'])) result = {'id': case['id'], 'kind': case['kind'], 'passed': passed, 'exit_code': got['exit_code'], 'status': got['status'], 'wall_seconds': got['wall_seconds'], 'actual_sha256': sha(got['stdout'])} if not passed: result.update(actual_preview=got['stdout'][:600], expected_preview=str(case['expected'])[:600], stderr=got['stderr'][:1800]) return result def verify_suite(code, entry_point, cases, workers=4): static_check(code) with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool: results = list(pool.map(lambda c: run_case(code, entry_point, c), cases)) return {'total': len(results), 'passed': sum(r['passed'] for r in results), 'failed': sum(not r['passed'] for r in results), 'cases': results} def self_test(): probes = { 'identity': ("import os\nprint(os.getuid(), os.getgid())", '65534 65534'), 'host_read': ("try:\n open('/home/user/hf_dataset_access.txt').read()\nexcept FileNotFoundError:\n print('HOST_INACCESSIBLE')", 'HOST_INACCESSIBLE'), 'network': ("import socket\ntry:\n socket.socket()\nexcept PermissionError:\n print('NETWORK_DENIED')", 'NETWORK_DENIED'), 'fork': ("import os\ntry:\n os.fork()\nexcept (PermissionError, BlockingIOError):\n print('FORK_DENIED')", 'FORK_DENIED'), 'write': ("try:\n open('/escape', 'w')\nexcept PermissionError:\n print('WRITE_DENIED')", 'WRITE_DENIED'), 'environment': ("import os\nprint(len(os.environ))", '0'), 'normal_python': ("from bisect import bisect_left\nfrom heapq import heappop\nprint(bisect_left([1,3,5], 3), heappop([2,4]))", '1 2'), } # socket and os are intentionally imported by self-test BEFORE untrusted # evaluation; production payloads are AST-screened and cannot import them. result = {} for name, (code, expected) in probes.items(): got = execute({'code': code, 'mode': 'stdin'}) result[name] = {'passed': got['exit_code'] == 0 and got['stdout'].strip() == expected, 'stdout': got['stdout'].strip(), 'stderr': got['stderr'][-800:]} timeout = execute({'code': 'while True:\n pass', 'mode': 'stdin'}, timeout=5) result['loop_bounded'] = {'passed': timeout['exit_code'] != 0, 'exit_code': timeout['exit_code'], 'seconds': timeout['wall_seconds']} if not all(x['passed'] for x in result.values()): raise RuntimeError(json.dumps(result, indent=2)) return result if __name__ == '__main__': report = self_test() (ROOT / 'sandbox_self_test.json').write_text(json.dumps(report, indent=2)) print(json.dumps(report, indent=2))