Dataset / curation /v3 /scripts /verify.py
dsfasdfaserwer's picture
Add verified Python TACO v3 pilot part 1/5 (2 rows)
22c9027 verified
Raw History Blame Contribute Delete
6.62 kB
"""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))