File size: 5,958 Bytes
caf8059
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import json
import unittest
from pathlib import Path
from pydantic import ValidationError
from src.adapters.sandbox.docker import DockerSandbox
from src.modules.execution.contracts import SandboxConfig
from src.modules.skill.domain.models import SkillError, digest
from src.tests.runtime.fixtures import workspace, SOURCE

RUN_ID = 'run-' + 'a' * 32


def config():
    return SandboxConfig(image='approved/jdk17-python@sha256:' + 'a' * 64,
                         skill_ids=['erp-java-development'], api_contract='GET /health returns status ok; test fixture only.',
                         tests=[{'path': '/health', 'status': 200, 'expected_json': {'status': 'ok'}}],
                         health={'path': '/health', 'status': 200, 'expected_json': {'status': 'ok'}})


class DockerCommandFixture:
    def __init__(self):
        self.calls = []
        self.failure = None
        self.hash = 'b' * 64

    def __call__(self, args, **kwargs):
        self.calls.append(args)
        if 'info' in args:
            return 0, json.dumps({'OSType': 'linux', 'SecurityOptions': ['name=seccomp,profile=builtin']})
        if args[-1] in {'build', 'test', 'preview'}:
            if self.failure == 'timeout':
                raise SkillError('SANDBOX_TIMEOUT', 'fixture timeout')
            return 0, json.dumps({'passed': self.failure != args[-1], 'classes_digest': self.hash, 'cases': 1, 'passed_cases': 1})
        return 0, '{}'


class SandboxTests(unittest.TestCase):
    def setUp(self):
        self.root = self.enterContext(workspace())
        self.command = DockerCommandFixture()
        self.sandbox = DockerSandbox(self.root, config(), command=self.command, executable='docker-fixture')
        self.source = {'files': SOURCE, 'source_digest': digest(SOURCE)}

    def test_restricted_container_and_separate_uids(self):
        candidate = self.sandbox.build(RUN_ID, self.source, lambda: False)
        evidence = self.sandbox.probe(RUN_ID, candidate, 'test', lambda: False)
        preview = self.sandbox.probe(RUN_ID, candidate, 'preview', lambda: False)
        create = next(c for c in self.command.calls if 'run' in c)
        for flag in ['--network=none', '--read-only', '--cap-drop=ALL', '--security-opt=no-new-privileges',
                     '--memory=512m', '--cpus=1', '--pids-limit=128', '--pull=never', '--user=65533:65533']:
            self.assertIn(flag, create)
        self.assertNotIn('--privileged', create)
        self.assertFalse(any('docker.sock' in a for a in create))
        self.assertTrue(any('--user=65532:65532' in c for c in self.command.calls))
        self.assertTrue(any('--user=65534:65534' in c for c in self.command.calls))
        self.assertEqual(evidence['classes_digest'], preview['classes_digest'])

    def test_missing_docker_rejected_without_host_java(self):
        self.sandbox.executable = None
        with self.assertRaises(SkillError) as err:
            self.sandbox.build(RUN_ID, self.source, lambda: False)
        self.assertEqual(err.exception.code, 'ISOLATION_UNAVAILABLE')
        self.assertEqual(self.command.calls, [])

    def test_mutable_image_and_redirect_probe_paths_denied(self):
        for value in ['jdk:latest', 'jdk:17', 'jdk@sha256:short']:
            with self.assertRaises(ValidationError):
                SandboxConfig.model_validate(dict(config().model_dump(), image=value))
        for path in ['//evil.example', '/../secret', '/%2e%2e']:
            with self.assertRaises(ValidationError):
                SandboxConfig.model_validate(dict(config().model_dump(), health={'path': path, 'status': 200, 'expected_json': {}}))

    def test_timeout_and_build_failure_cleanup_exact_container(self):
        for failure in ['timeout', 'build']:
            self.command.failure = failure
            with self.assertRaises(SkillError):
                self.sandbox.build(RUN_ID, self.source, lambda: False)
            self.assertEqual(self.command.calls[-1], ['docker-fixture', 'rm', '-f', 'zk-' + RUN_ID])

    def test_changed_artifact_digest_is_rejected(self):
        candidate = self.sandbox.build(RUN_ID, self.source, lambda: False)
        self.command.hash = 'c' * 64
        with self.assertRaises(SkillError) as err:
            self.sandbox.probe(RUN_ID, candidate, 'test', lambda: False)
        self.assertEqual(err.exception.code, 'EVIDENCE_BINDING_MISMATCH')

    def test_invalid_handle_and_write_path_rejected(self):
        self.assertFalse(self.sandbox.cleanup('--all'))
        escaping = {'../escape': 'bad'}
        with self.assertRaises(SkillError):
            self.sandbox.build(RUN_ID, {'files': escaping, 'source_digest': digest(escaping)}, lambda: False)

    def test_cancelled_command_never_starts_process(self):
        with self.assertRaises(SkillError) as err:
            self.sandbox.cmd(['exec', 'fixture', 'java'], lambda: True)
        self.assertEqual(err.exception.code, 'RUN_CANCELLED')
        self.assertEqual(self.command.calls, [])

    def test_source_digest_mismatch_rejected_before_docker(self):
        with self.assertRaises(SkillError) as err:
            self.sandbox.build(RUN_ID, dict(self.source, source_digest='0' * 64), lambda: False)
        self.assertEqual(err.exception.code, 'SOURCE_DIGEST_MISMATCH')
        self.assertEqual(self.command.calls, [])

    def test_protected_cases_are_only_injected_into_separate_probe(self):
        candidate = self.sandbox.build(RUN_ID, self.source, lambda: False)
        self.sandbox.probe(RUN_ID, candidate, 'test', lambda: False)
        self.assertEqual(list(Path(self.root).rglob('suite.json')), [])
        java = next(c for c in self.command.calls if 'java' in c)
        self.assertFalse(any(a.startswith('ZKCODING_PROBE_CONFIG=') for a in java))
        probe = next(c for c in self.command.calls if c[-1] == 'test')
        self.assertIn('--user=65534:65534', probe)
        self.assertTrue(any(a.startswith('ZKCODING_PROBE_CONFIG=') for a in probe))