import hashlib import errno import importlib.util import io import json import os from pathlib import Path import stat import subprocess import sys import tarfile import tempfile from types import SimpleNamespace import unittest from unittest.mock import patch ROOT = Path(__file__).resolve().parents[2] SPEC = importlib.util.spec_from_file_location('apt_transaction', ROOT / 'tools/apt-transaction/apt_transaction.py') apt = importlib.util.module_from_spec(SPEC) sys.modules[SPEC.name] = apt SPEC.loader.exec_module(apt) def transaction(old=None): sha = 'a' * 64 return {'schema_version': 1, 'recipe_id': 'rmm-mvp-test', 'recipe_version': '1', 'platform': 'ubuntu-24.04-amd64', 'resolver_config_version': apt.RESOLVER, 'no_reboot': True, 'status_fingerprint': 'b' * 64, 'baseline_sha256': 'c' * 64, 'packages': [{'name': 'rmm-mvp-test', 'architecture': 'all', 'old_version': old, 'new_version': '1.1', 'origin': 'rmm-test', 'sha256': sha, 'size': 100, 'archive_path': str(apt.BASE / 'archives' / (sha + '.deb'))}]} def protocol(old=None): old_fields = old + ' all none' if old else '- - none' action = 'rmm-mvp-test ' + old_fields + ' < 1.1 all none ' return ('VERSION 3\nDPkg::Pre-Install-Pkgs::=' + apt.HOOK + '\n' 'DPkg::Tools::Options::' + apt.HOOK + '::Version=3\n' 'DPkg::Tools::Options::' + apt.HOOK + '::InfoFD=0\n' 'Dir::Bin::dpkg=/usr/bin/dpkg\nDir::State::status=/var/lib/dpkg/status\n' 'DPkg::ConfigurePending=false\nDPkg::TriggersPending=false\n' 'dpkg::selection::remove::approved=false\n\n' + action + transaction()['packages'][0]['archive_path'] + '\n' + action + '**CONFIGURE**\n').encode('ascii') class ProtocolTests(unittest.TestCase): def test_upstream_v3_new_install_and_update(self): for old in (None, '1.0'): tx = apt.ResolvedAptTransaction.parse(transaction(old)) config, actions = apt.parse_protocol3(protocol(old)) apt.check_hook_config(config) apt.validate_actions(tx, actions) def test_fixture_file(self): data = (Path(__file__).parent / 'fixtures/install-v3.txt').read_bytes() config, actions = apt.parse_protocol3(data) apt.check_hook_config(config) apt.validate_actions(apt.ResolvedAptTransaction.parse(transaction()), actions) def test_not_five_field_or_fantasy_hash_protocol(self): for data in (b'VERSION 2\n\npkg - < 1 /file\n', b'VERSION 3\n\npkg - < 1 /file sha256=aaa\n'): with self.assertRaises(apt.Veto): apt.parse_protocol3(data) def test_strict_malformed_and_bounds(self): original = protocol() for data in (b'', original[:-1], original.replace(b'VERSION 3', b'VERSION 4'), original.replace(b'all none', b'all nonsense'), original.replace(b'\n\n', b'\n'), original + b'\n', original.replace(b'rmm-mvp-test ', b'rmm-mvp-test '), original.replace(b'InfoFD=0', b'InfoFD=%GG'), original.replace(b'InfoFD=0', b'InfoFD=0\x00'), b'x' * (apt.MAX_INPUT + 1)): with self.subTest(data=data[:80]), self.assertRaises(apt.Veto): apt.parse_protocol3(data) def test_config_escaping_repeated_list_and_invalid_hook_binding(self): config, _ = apt.parse_protocol3(protocol().replace(b'VERSION 3\n', b'VERSION 3\nExample::=a%0Ab%25c\nExample::=two\n')) self.assertIn(('Example::', 'a\nb%c'), config) self.assertIn(('Example::', 'two'), config) for injected in (b'DPkg::Pre-Invoke::=/bin/true\n', ('DPkg::Pre-Install-Pkgs::=' + apt.HOOK + '\n').encode()): config, _ = apt.parse_protocol3(protocol().replace(b'\n\n', b'\n' + injected + b'\n')) with self.assertRaises(apt.Veto): apt.check_hook_config(config) def test_explicit_configure_and_no_pending_settings_are_required_in_actual_hook(self): original = protocol() for setting in (b'DPkg::ConfigurePending', b'DPkg::TriggersPending', b'dpkg::selection::remove::approved'): for changed in (original.replace(setting + b'=false\n', b''), original.replace(setting + b'=false', setting + b'=true')): config, _ = apt.parse_protocol3(changed) with self.subTest(setting=setting), self.assertRaises(apt.Veto): apt.check_hook_config(config) def test_entire_action_set_dependency_change_remove_configure(self): tx = apt.ResolvedAptTransaction.parse(transaction()) original = protocol() for data in (original.replace(b'**CONFIGURE**', b'**REMOVE**'), original.replace(b'rmm-mvp-test -', b'other-dependency -'), original.replace(b'1.1 all', b'1.2 all'), original.replace(b'1.1 all', b'1.1 amd64'), original.replace(b' < ', b' > '), original.replace(b'a' * 64 + b'.deb', b'b' * 64 + b'.deb'), original + original.split(b'\n')[-2] + b'\n', b'\n'.join(original.split(b'\n')[:-2]) + b'\n'): with self.subTest(data=data[-100:]), self.assertRaises(apt.Veto): _, actions = apt.parse_protocol3(data) apt.validate_actions(tx, actions) def test_downgrade_and_version_order(self): for old in ('1.1', '1.2', '1:1.0'): with self.assertRaises(apt.Veto): apt.ResolvedAptTransaction.parse(transaction(old)) apt.ResolvedAptTransaction.parse(transaction('1.1~rc1')) def test_schema_no_removal_unknown_fields_and_no_reboot(self): for key, value in (('no_reboot', False), ('packages', []), ('schema_version', True), ('platform', 'debian'), ('resolver_config_version', 'anything')): obj = transaction() obj[key] = value with self.assertRaises(apt.Veto): apt.ResolvedAptTransaction.parse(obj) for key, value in (('new_version', None), ('name', 'linux-image-test'), ('archive_path', '/tmp/evil.deb'), ('origin', 'https://llm.invalid/x'), ('sha256', 'z' * 64), ('size', True), ('remove', True)): obj = transaction() obj['packages'][0][key] = value with self.assertRaises(apt.Veto): apt.ResolvedAptTransaction.parse(obj) obj = transaction() obj['packages'] *= 2 with self.assertRaises(apt.Veto): apt.ResolvedAptTransaction.parse(obj) def test_immutable_and_duplicate_json(self): tx = apt.ResolvedAptTransaction.parse(transaction()) with self.assertRaises(AttributeError): tx.packages[0].new_version = '2' with self.assertRaises(apt.Veto): apt.json_bytes(b'{"a":1,"a":2}') class PreconditionsTests(unittest.TestCase): def test_both_deadlines_and_boot_bound(self): context = apt.VerifiedHelperContext.parse({ 'transaction_sha256': 'a' * 64, 'effect_armed_ledger_id': 'ledger-1', 'grant_id': 'grant-1', 'not_before_ms': 1000, 'start_before_ms': 61000, 'boot_id': 'boot-1', 'monotonic_start_before_ns': 10000, 'schema_version': 2, 'job_payload_sha256': 'd' * 64, 'action': 'apt-execute', 'execution_profile': 'dev-test', 'job_id': 'job-1', 'attempt_id': 'attempt-1', 'authorization_id': 'authorization-1', 'plan_sha256': 'e' * 64}) context.check_deadline(1000, 1, 'boot-1') for now, mono, boot in ((999, 1, 'boot-1'), (61000, 1, 'boot-1'), (2000, 10000, 'boot-1'), (2000, 1, 'boot-2')): with self.assertRaises(apt.Veto): context.check_deadline(now, mono, boot) def test_fingerprint_baseline_and_old_version(self): baseline = {'rmm-mvp-test:all': {'version': '1.0', 'status': 'install ok installed'}} obj = transaction('1.0') obj['baseline_sha256'] = apt.digest(apt.canonical(baseline)) tx = apt.ResolvedAptTransaction.parse(obj) with patch.object(apt, 'status_fingerprint', return_value=tx.status_fingerprint), \ patch.object(apt, 'installed_snapshot', return_value=baseline): apt.check_preconditions(tx, baseline) with self.assertRaises(apt.Veto): apt.check_preconditions(tx, {}) with patch.object(apt, 'status_fingerprint', return_value='d' * 64): with self.assertRaisesRegex(apt.Veto, 'STATUS_FINGERPRINT'): apt.check_preconditions(tx, baseline) with patch.object(apt, 'status_fingerprint', return_value=tx.status_fingerprint), \ patch.object(apt, 'installed_snapshot', return_value={}): with self.assertRaisesRegex(apt.Veto, 'STATUS_BASELINE_CHANGED'): apt.check_preconditions(tx, baseline) def test_durable_once_double_hook(self): with tempfile.TemporaryDirectory() as temp, patch.object(apt, 'secure_path'): marker = Path(temp) / 'armed.json' with patch.object(apt.os, 'fsync', wraps=os.fsync) as sync: apt.durable_once(marker, {'ledger': 'one'}) self.assertEqual(sync.call_count, 2) with self.assertRaisesRegex(apt.Veto, 'ALREADY_HANDED_OFF'): apt.durable_once(marker, {'ledger': 'two'}) self.assertEqual(json.loads(marker.read_bytes()), {'ledger': 'one'}) def test_archive_root_mode_size_links(self): valid = dict(st_uid=0, st_mode=stat.S_IFREG | 0o600, st_size=100, st_nlink=1) apt.archive_metadata(SimpleNamespace(**valid), 100) for key, value in (('st_uid', 1000), ('st_mode', stat.S_IFREG | 0o620), ('st_mode', stat.S_IFLNK | 0o777), ('st_size', 99), ('st_nlink', 2)): with self.assertRaises(apt.Veto): apt.archive_metadata(SimpleNamespace(**{**valid, key: value}), 100) def test_symlink_and_user_owned_path_rejected(self): with tempfile.TemporaryDirectory() as temp: path = Path(temp) / 'file' path.write_bytes(b'file') link = Path(temp) / 'link' link.symlink_to(path) with self.assertRaises(apt.Veto): apt.secure_path(link) if os.getuid() != 0: with self.assertRaises(apt.Veto): apt.secure_path(path) def test_postcondition_checks_entire_snapshot(self): tx = apt.ResolvedAptTransaction.parse(transaction()) expected = {'rmm-mvp-test:all': {'version': '1.1', 'status': 'install ok installed'}} with patch.object(apt, 'installed_snapshot', return_value=expected), \ patch.object(apt, 'run_read', return_value=b''): self.assertEqual(apt.verify_after(tx, {})['packages'][0]['version'], '1.1') for snapshot in ({}, {**expected, 'unexpected:all': {'version': '1', 'status': 'install ok installed'}}): with patch.object(apt, 'installed_snapshot', return_value=snapshot): with self.assertRaises(apt.Veto): apt.verify_after(tx, {}) def test_unprivileged_execute_and_sandbox_fail_closed(self): if os.geteuid() != 0: self.assertEqual(apt.execute({})['code'], 'ROOT_REQUIRED') with self.assertRaises(apt.Veto): apt.inspect_sandbox() def test_private_control_layouts_must_be_empty_or_absent_in_worker(self): for layout in ('etc-rmm', 'etc-rmm-remote', 'rmm-helper', 'rmm-agent', 'rmm-agent-remote'): with self.subTest(layout=layout), tempfile.TemporaryDirectory() as temp: path = Path(temp) / layout with patch.object(apt, 'PRIVATE_CONTROL_DIRECTORIES', (str(path),)): apt.inspect_private_control_paths() # optional layout absent path.mkdir() apt.inspect_private_control_paths() # masked empty directory (path / 'arbitrary-future-secret-name').write_text('synthetic') with self.assertRaisesRegex(apt.Veto, 'SANDBOX_LEDGER_OR_KEYS_VISIBLE'): apt.inspect_private_control_paths() def test_private_control_symlink_cannot_claim_an_empty_mask(self): with tempfile.TemporaryDirectory() as temp: base = Path(temp); (base / 'empty').mkdir() (base / 'link').symlink_to(base / 'empty', target_is_directory=True) with patch.object(apt, 'PRIVATE_CONTROL_DIRECTORIES', (str(base / 'link'),)): with self.assertRaisesRegex(apt.Veto, 'SANDBOX_LEDGER_OR_KEYS_VISIBLE'): apt.inspect_private_control_paths() (base / 'empty').rmdir() # dangling symlink is not an absent layout with self.assertRaisesRegex(apt.Veto, 'SANDBOX_LEDGER_OR_KEYS_VISIBLE'): apt.inspect_private_control_paths() def test_previous_launch_or_handoff_is_unknown_never_relaunched(self): for marker in ('launch.json', 'hook-armed.json'): with tempfile.TemporaryDirectory(dir='/tmp/opencode') as temp: base = Path(temp) (base / marker).write_text('{}') with patch.object(apt, 'BASE', base), patch.object(apt, 'ACTIVE', base), \ patch.object(apt, 'secure_path'), patch.object(apt.os, 'geteuid', return_value=0), \ patch.object(apt, 'load_active', return_value=(None, None, {})), \ patch.object(apt.subprocess, 'Popen') as spawn: result = apt.execute({'transaction_sha256': 'a' * 64, 'effect_armed_ledger_id': 'ledger-1'}) self.assertEqual(result['effect_state'], 'unknown') self.assertEqual(result['code'], 'PRIOR_ATTEMPT_UNKNOWN') spawn.assert_not_called() def test_unprivileged_seccomp_load_in_disposable_child(self): # Installs a filter only on this short-lived child, never the test # runner/host. No reboot, mount or other effectful syscall is attempted. code = '''import importlib.util, pathlib, sys sys.dont_write_bytecode = True s = importlib.util.spec_from_file_location('apt_transaction', sys.argv[1]) m = importlib.util.module_from_spec(s); sys.modules[s.name] = m; s.loader.exec_module(m) m.seccomp_filter() status = pathlib.Path('/proc/self/status').read_text() assert 'NoNewPrivs:\\t1' in status and 'Seccomp:\\t2' in status print('FILTER_LOADED') ''' output = subprocess.check_output(['/usr/bin/python3', '-I', '-c', code, str(ROOT / 'tools/apt-transaction/apt_transaction.py')]) self.assertEqual(output, b'FILTER_LOADED\n') def test_exact_argv_config_and_fixed_hook(self): tx = apt.ResolvedAptTransaction.parse(transaction()) argv = apt.apt_argv(tx) self.assertNotIn('--no-download', argv) # real v3 otherwise reports **ERROR** self.assertIn('--no-remove', argv) self.assertNotIn('update', argv) self.assertEqual(argv[-1], tx.packages[0].archive_path) self.assertEqual((ROOT / 'tools/apt-transaction/hook').read_bytes(), apt.hook_script()) self.assertIn(b'Dir::Etc::parts', apt.apt_config()) self.assertIn(b'APT::Get::Download "true";', apt.apt_config()) self.assertIn(b'dpkg::selection::remove::approved "false";', apt.apt_config()) self.assertIn(b'DPkg::ConfigurePending "false";', apt.apt_config()) self.assertIn(b'DPkg::TriggersPending "false";', apt.apt_config()) def test_ip_socket_denials_are_required_for_both_families(self): with patch.object(apt.socket, 'socket', side_effect=OSError(errno.EAFNOSUPPORT, 'synthetic')) as make: apt.verify_no_ip_sockets() self.assertEqual([call.args[0] for call in make.call_args_list], [apt.socket.AF_INET, apt.socket.AF_INET6]) def test_permitted_ipv4_socket_closes_and_vetoes(self): closed=[];candidate=SimpleNamespace(close=lambda:closed.append(True)) with patch.object(apt.socket, 'socket', return_value=candidate): with self.assertRaisesRegex(apt.Veto, 'SANDBOX_IP_SOCKET_ALLOWED'):apt.verify_no_ip_sockets() self.assertEqual(closed,[True]) def test_permitted_ipv6_cannot_hide_behind_denied_ipv4(self): closed=[];candidate=SimpleNamespace(close=lambda:closed.append(True)) with patch.object(apt.socket, 'socket', side_effect=[OSError(errno.EPERM,'synthetic'),candidate]): with self.assertRaisesRegex(apt.Veto, 'SANDBOX_IP_SOCKET_ALLOWED'):apt.verify_no_ip_sockets() self.assertEqual(closed,[True]) def test_resource_exhaustion_is_not_a_network_denial_proof(self): with patch.object(apt.socket, 'socket', side_effect=OSError(errno.EMFILE,'synthetic')): with self.assertRaisesRegex(apt.Veto, 'SANDBOX_IP_SOCKET_CHECK'):apt.verify_no_ip_sockets() class FixtureTests(unittest.TestCase): def test_actual_archive_hash_and_control_mismatch(self): with tempfile.TemporaryDirectory() as temp: records = json.loads(subprocess.check_output([ sys.executable, str(ROOT / 'tools/apt-transaction/build_fixture.py'), temp])) record = records[0] package = apt.PackageArchive('rmm-mvp-test', 'all', None, '1.0', 'rmm-test', record['sha256'], record['size'], record['local_build_path']) # Only root ownership is mocked for this unprivileged byte/control # test. Production secure_path and archive_metadata are never relaxed. with patch.object(apt, 'secure_path', side_effect=lambda path: Path(path)), \ patch.object(apt, 'archive_metadata'): apt.verify_archive(package) wrong_hash = apt.PackageArchive(**{**package.__dict__, 'sha256': '0' * 64}) with self.assertRaisesRegex(apt.Veto, 'ARCHIVE_HASH'): apt.verify_archive(wrong_hash) wrong_version = apt.PackageArchive(**{**package.__dict__, 'new_version': '2.0'}) with self.assertRaisesRegex(apt.Veto, 'DEB_CONTROL_OR_CONFLICT'): apt.verify_archive(wrong_version) def test_build_deb_versions_hash_control_payload_without_install(self): with tempfile.TemporaryDirectory() as temp: records = json.loads(subprocess.check_output([ sys.executable, str(ROOT / 'tools/apt-transaction/build_fixture.py'), temp])) self.assertEqual([r['new_version'] for r in records], ['1.0', '1.1']) for record in records: path = Path(record['local_build_path']) self.assertEqual(hashlib.sha256(path.read_bytes()).hexdigest(), record['sha256']) self.assertEqual(path.stat().st_size, record['size']) control = apt.run_read(['/usr/bin/dpkg-deb', '--show', '--showformat=${Package}\n${Version}\n${Architecture}\n', str(path)]) self.assertEqual(control.decode().splitlines(), ['rmm-mvp-test', record['new_version'], 'all']) payload = apt.run_read(['/usr/bin/dpkg-deb', '--fsys-tarfile', str(path)]) apt.validate_payload(payload) with tarfile.open(fileobj=io.BytesIO(payload)) as archive: self.assertEqual(archive.extractfile('./usr/share/rmm-mvp-test/version').read(), (record['new_version'] + '\n').encode()) def test_protected_payload_paths_even_in_innocent_package(self): for name in ('./boot/vmlinuz', './etc/cron.d/reboot', './usr/lib/systemd/system/a.service', '../escape', '/absolute', './var/lib/rmm-apt-transaction/active/context.json'): output = io.BytesIO() with tarfile.open(fileobj=output, mode='w') as archive: entry = tarfile.TarInfo(name) entry.size = 1 archive.addfile(entry, io.BytesIO(b'x')) with self.assertRaises(apt.Veto): apt.validate_payload(output.getvalue()) if __name__ == '__main__': unittest.main()