Files

2282 lines
125 KiB
Python

#!/usr/bin/python3
"""Root-helper-only, fail-closed local-archive APT transaction provider.
No network API, resolver approval, grant verifier, or automatic retry lives here.
See README.md before integrating. Python 3.9+, Linux amd64 only.
"""
import ctypes
import errno
import fcntl
import hashlib
import io
import json
import os
from pathlib import Path
import re
import selectors
import socket
import stat
import subprocess
import sys
import tarfile
import time
import uuid
from dataclasses import dataclass
from typing import Optional, Tuple
from urllib.parse import unquote_to_bytes
BASE = Path('/var/lib/rmm-apt-transaction')
ACTIVE = BASE / 'active'
CODE = Path('/usr/lib/rmm-apt-transaction/apt_transaction.py')
HOOK = '/usr/lib/rmm-apt-transaction/hook'
APT_UNIT = Path('/etc/systemd/system/rmm-apt-helper.service')
PRIVATE_CONTROL_DIRECTORIES = ('/etc/rmm', '/etc/rmm-remote', '/var/lib/rmm-helper',
'/var/lib/rmm-agent', '/var/lib/rmm-agent-remote')
MAX_INPUT = 1024 * 1024
MAX_PACKAGES = 128
RESOLVER = 'rmm-apt-local-v1'
FIXTURE_RECIPES = {'rmm-apt-fixture-install-1.0': (None, '1.0'),
'rmm-apt-fixture-update-1.1': ('1.0', '1.1')}
# Generated deterministic USTAR/ar bytes below; pinned after independent local
# dpkg-deb control/payload inspection. No runtime-supplied fixture hash is trusted.
FIXTURE_SHA256 = {'1.0': '74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867',
'1.1': 'ef67c9fe0ba1443fcfe465768e1204763063c369a2a1da04af6027d8a9c00491'}
HISTORICAL_CONFIGURED_RECOVERY = {
'grant_id': '33775478-15b0-46ec-b059-44f500dbb0b6',
'previous_grant_id': '31ef5e5e-5dbd-4428-a9a1-cbd15de2f5a0',
'partial_proof_sha256': 'dc3bf3870ea77c12f9291bac712c53ae72194eaec980a8646155a7fb5c0dbe21',
'provider_sha256': '5ff260f75cb2959678f6be729d3a806a4ea29febd5ae4003317fed41afc25327',
}
ENV = {'PATH': '/usr/sbin:/usr/bin:/sbin:/bin', 'LC_ALL': 'C',
'DEBIAN_FRONTEND': 'noninteractive', 'HOME': '/root'}
NAME = re.compile(r'[a-z0-9][a-z0-9+.-]{1,127}\Z')
VERSION = re.compile(r'[0-9][A-Za-z0-9.+:~\-]{0,255}\Z')
HASH = re.compile(r'[0-9a-f]{64}\Z')
IDENT = re.compile(r'[A-Za-z0-9_.-]{1,128}\Z')
FORBIDDEN = re.compile(r'^(linux-|kernel|grub|shim|systemd|initramfs|dracut|'
r'uboot|u-boot|firmware|base-files|ubuntu-release-upgrader|'
r'dpkg$|apt$|libapt|libc6$|libseccomp|python3|util-linux)')
class Veto(Exception):
"""A stable, non-secret error code, not raw child output."""
def require(condition, code):
if not condition:
raise Veto(code)
def exact(obj, keys):
require(type(obj) is dict and set(obj) == set(keys.split()), 'SCHEMA_FIELDS')
def digest(data):
return hashlib.sha256(data).hexdigest()
def canonical(obj):
return json.dumps(obj, sort_keys=True, separators=(',', ':'),
ensure_ascii=True).encode('ascii')
def json_bytes(data):
require(len(data) <= MAX_INPUT, 'INPUT_LIMIT')
def pairs(items):
result = {}
for key, value in items:
require(key not in result, 'DUPLICATE_JSON_KEY')
result[key] = value
return result
try:
return json.loads(data, object_pairs_hook=pairs,
parse_constant=lambda _: (_ for _ in ()).throw(Veto('JSON_NUMBER')))
except (ValueError, UnicodeError, RecursionError):
raise Veto('MALFORMED_JSON') from None
def token(value, pattern, code):
require(type(value) is str and pattern.fullmatch(value) is not None, code)
return value
def secure_path(path, directory=False, private=False):
"""All components must be real root-owned, non-writable-by-others paths.
Root administrators remain trusted. No testing UID override in production.
"""
path = Path(path)
require(path.is_absolute() and str(path) == os.path.normpath(str(path)), 'PATH')
for component in [*reversed(path.parents), path]:
st = component.lstat()
require(st.st_uid == 0 and not st.st_mode & 0o022 and
not stat.S_ISLNK(st.st_mode), 'PATH_OWNERSHIP_MODE')
st = path.lstat()
require(stat.S_ISDIR(st.st_mode) if directory else stat.S_ISREG(st.st_mode), 'PATH_TYPE')
if private:
require(not st.st_mode & 0o077, 'PATH_NOT_PRIVATE')
return path
def archive_metadata(st, expected_size):
require(st.st_uid == 0 and not st.st_mode & 0o022 and stat.S_ISREG(st.st_mode),
'ARCHIVE_OWNERSHIP_MODE')
require(st.st_size == expected_size and st.st_nlink == 1, 'ARCHIVE_SIZE_LINKS')
def sealed_read(path, limit=MAX_INPUT):
secure_path(path)
fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
with os.fdopen(fd, 'rb') as stream:
require(os.fstat(stream.fileno()).st_size <= limit, 'FILE_LIMIT')
data = stream.read(limit + 1)
require(len(data) <= limit, 'FILE_LIMIT')
return data
def durable_once(path, obj):
"""O_EXCL is the exactly-one handoff; partial/old files veto, never reset."""
secure_path(path.parent, directory=True, private=True)
try:
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
except FileExistsError:
raise Veto('ALREADY_HANDED_OFF') from None
with os.fdopen(fd, 'wb') as stream:
stream.write(canonical(obj))
stream.flush()
os.fsync(stream.fileno())
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY)
try:
os.fsync(fd)
finally:
os.close(fd)
def run_read(argv, limit=MAX_INPUT, timeout=30, pass_fds=(), env=None,
expected_returncode=0, merge_stderr=False):
"""Bound stdout/stderr while reading, not only after communicate()."""
proc = subprocess.Popen(argv, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=ENV if env is None else env,
pass_fds=pass_fds)
output = bytearray()
total = 0
deadline = time.monotonic() + timeout
with selectors.DefaultSelector() as selector:
selector.register(proc.stdout, selectors.EVENT_READ, True)
selector.register(proc.stderr, selectors.EVENT_READ, False)
try:
while selector.get_map():
require(time.monotonic() < deadline, 'READ_TIMEOUT')
for key, _ in selector.select(min(0.2, max(0, deadline - time.monotonic()))):
chunk = os.read(key.fileobj.fileno(), 65536)
if not chunk:
selector.unregister(key.fileobj)
total += len(chunk)
require(total <= limit, 'CHILD_OUTPUT_LIMIT')
if key.data or merge_stderr:
output.extend(chunk)
require(proc.wait(timeout=max(0.01, deadline - time.monotonic())) == expected_returncode,
'READ_COMMAND_FAILED')
except BaseException:
# Only harmless read commands use this routine. NEVER kill apt/dpkg.
proc.kill()
proc.wait()
raise
finally:
proc.stdout.close()
proc.stderr.close()
return bytes(output)
@dataclass(frozen=True)
class PackageArchive:
name: str
architecture: str
old_version: Optional[str]
new_version: str
origin: str
sha256: str
size: int
archive_path: str
@classmethod
def parse(cls, obj, configure_only=False):
exact(obj, 'name architecture old_version new_version origin sha256 size archive_path')
token(obj['name'], NAME, 'PACKAGE_NAME')
require(not FORBIDDEN.match(obj['name']), 'PROTECTED_PACKAGE')
require(obj['architecture'] in ('amd64', 'all'), 'ARCHITECTURE')
token(obj['new_version'], VERSION, 'VERSION')
if configure_only:
require(obj['old_version'] == obj['new_version'] == '1.0', 'RECOVERY_VERSION')
if obj['old_version'] is not None:
token(obj['old_version'], VERSION, 'VERSION')
# Debian ordering, not lexical/semver ordering. Read-only argv.
require((obj['old_version'] == obj['new_version'] == '1.0') if configure_only else
subprocess.run(['/usr/bin/dpkg', '--compare-versions', obj['old_version'],
'lt', obj['new_version']], env=ENV,
stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL).returncode == 0,
'DOWNGRADE_OR_REINSTALL')
token(obj['origin'], re.compile(r'(rmm-test|catalog:[A-Za-z0-9_.-]{1,128})\Z'), 'ORIGIN')
token(obj['sha256'], HASH, 'SHA256')
require(type(obj['size']) is int and 0 < obj['size'] <= 256 * 1024 * 1024, 'SIZE')
expected = str(BASE / 'archives' / (obj['sha256'] + '.deb'))
require(obj['archive_path'] == expected, 'UNSEALED_ARCHIVE_PATH')
return cls(**obj)
@dataclass(frozen=True)
class ResolvedAptTransaction:
schema_version: int
recipe_id: str
recipe_version: str
platform: str
resolver_config_version: str
no_reboot: bool
status_fingerprint: str
baseline_sha256: str
packages: Tuple[PackageArchive, ...]
operation: Optional[str] = None
@classmethod
def parse(cls, obj):
version = obj.get('schema_version') if type(obj) is dict else None
exact(obj, 'schema_version recipe_id recipe_version platform resolver_config_version '
'no_reboot status_fingerprint baseline_sha256 packages' + (' operation' if version == 2 else ''))
require(type(version) is int and version in (1, 2), 'SCHEMA_VERSION')
configure_only = version == 2
require(not configure_only or obj['operation'] == 'configure_only', 'TRANSACTION_OPERATION')
token(obj['recipe_id'], IDENT, 'RECIPE_ID')
token(obj['recipe_version'], IDENT, 'RECIPE_VERSION')
require(obj['platform'] == 'ubuntu-24.04-amd64', 'UNSUPPORTED_PLATFORM')
require(obj['resolver_config_version'] == RESOLVER, 'RESOLVER_VERSION')
require(obj['no_reboot'] is True, 'REBOOT_FORBIDDEN')
token(obj['status_fingerprint'], HASH, 'FINGERPRINT')
token(obj['baseline_sha256'], HASH, 'FINGERPRINT')
require(type(obj['packages']) is list and 0 < len(obj['packages']) <= MAX_PACKAGES,
'PACKAGE_COUNT')
packages = tuple(PackageArchive.parse(p, configure_only=configure_only) for p in obj['packages'])
require(len({(p.name, p.architecture) for p in packages}) == len(packages), 'DUPLICATE_PACKAGE')
transaction = cls(**{**obj, 'packages': packages})
if configure_only:
fixture_scope(transaction)
return transaction
@dataclass(frozen=True)
class VerifiedHelperContext:
transaction_sha256: str
effect_armed_ledger_id: str
grant_id: str
not_before_ms: int
start_before_ms: int
boot_id: str
monotonic_start_before_ns: int
schema_version: int
job_payload_sha256: str
action: str
execution_profile: str
job_id: str
attempt_id: str
authorization_id: str
plan_sha256: str
@classmethod
def parse(cls, obj):
exact(obj, 'transaction_sha256 effect_armed_ledger_id grant_id not_before_ms '
'start_before_ms boot_id monotonic_start_before_ns schema_version '
'job_payload_sha256 action execution_profile job_id attempt_id authorization_id plan_sha256')
require(type(obj['schema_version']) is int and obj['schema_version'] == 2, 'CONTEXT_SCHEMA')
require(obj['action'] in ('apt-execute', 'apt-native-acceptance'), 'CONTEXT_ACTION')
require(obj['execution_profile'] in ('dev-test', 'production'), 'CONTEXT_PROFILE')
token(obj['transaction_sha256'], HASH, 'TRANSACTION_HASH')
for key in ('job_payload_sha256', 'plan_sha256'):
token(obj[key], HASH, 'CONTEXT_HASH')
for key in ('effect_armed_ledger_id', 'grant_id', 'boot_id', 'job_id',
'attempt_id', 'authorization_id'):
token(obj[key], IDENT, 'CONTEXT_ID')
for key in ('not_before_ms', 'start_before_ms', 'monotonic_start_before_ns'):
require(type(obj[key]) is int and obj[key] > 0, 'CONTEXT_TIME')
require(0 < obj['start_before_ms'] - obj['not_before_ms'] <= 60000, 'GRANT_WINDOW')
return cls(**obj)
def check_deadline(self, now_ms=None, monotonic_ns=None, boot_id=None):
now_ms = time.time_ns() // 1000000 if now_ms is None else now_ms
monotonic_ns = time.monotonic_ns() if monotonic_ns is None else monotonic_ns
if boot_id is None:
boot_id = Path('/proc/sys/kernel/random/boot_id').read_text().strip()
require(boot_id == self.boot_id, 'BOOT_CHANGED')
require(self.not_before_ms <= now_ms < self.start_before_ms and
monotonic_ns < self.monotonic_start_before_ns, 'START_DEADLINE')
def fixture_archive(version):
"""Deterministic, script/trigger/dependency-free Debian ar archive."""
require(version in ('1.0', '1.1'), 'FIXTURE_VERSION')
def tar(entries):
output = io.BytesIO()
with tarfile.open(fileobj=output, mode='w', format=tarfile.USTAR_FORMAT) as archive:
for name, data in entries:
entry = tarfile.TarInfo(name)
entry.uid = entry.gid = 0
entry.uname = entry.gname = 'root'
entry.mtime = 1794441600
entry.mode = 0o755 if data is None else 0o644
entry.type = tarfile.DIRTYPE if data is None else tarfile.REGTYPE
entry.size = 0 if data is None else len(data)
archive.addfile(entry, None if data is None else io.BytesIO(data))
return output.getvalue()
control = ('Package: rmm-mvp-test\nVersion: ' + version + '\nArchitecture: all\n'
'Maintainer: RMM development fixture <nobody@example.invalid>\n'
'Section: misc\nPriority: optional\n'
'Description: Harmless manually imported RMM acceptance fixture\n').encode('ascii')
members = [('debian-binary', b'2.0\n'), ('control.tar', tar([('./control', control)])),
('data.tar', tar([('./usr', None), ('./usr/share', None),
('./usr/share/rmm-mvp-test', None),
('./usr/share/rmm-mvp-test/version', (version + '\n').encode('ascii'))]))]
result = bytearray(b'!<arch>\n')
for name, data in members:
header = '{:<16}{:<12}{:<6}{:<6}{:<8}{:<10}`\n'.format(
name + '/', 1794441600, 0, 0, '100644', len(data)).encode('ascii')
require(len(header) == 60, 'FIXTURE_AR_HEADER')
result.extend(header + data + (b'\n' if len(data) % 2 else b''))
return bytes(result)
def fixture_scope(transaction):
require(transaction.recipe_id in FIXTURE_RECIPES and transaction.recipe_version == '1',
'FIXTURE_RECIPE')
require(len(transaction.packages) == 1, 'FIXTURE_CLOSURE')
old, new = FIXTURE_RECIPES[transaction.recipe_id]
if transaction.operation == 'configure_only':
require(transaction.schema_version == 2 and transaction.recipe_id == 'rmm-apt-fixture-install-1.0',
'RECOVERY_FIXED_RECIPE')
old = new = '1.0'
package = transaction.packages[0]
require(package.name == 'rmm-mvp-test' and package.architecture == 'all' and
package.origin == 'rmm-test' and package.old_version == old and package.new_version == new,
'FIXTURE_PACKAGE')
require(package.sha256 == FIXTURE_SHA256[new] == digest(fixture_archive(new)) and
package.size == len(fixture_archive(new)), 'FIXTURE_PINNED_BYTES')
return {'recipe_id': transaction.recipe_id, 'recipe_version': '1',
'packages': [package.__dict__]}
def load_signed_action(transaction, context):
"""Helper verified this exact payload hash against the signed grant first.
This is NOT a second root-unsigned manifest that can replace the signed
action: the nested resolved transaction is required in the signed bytes.
"""
raw = sealed_read(ACTIVE / 'signed-action.json')
require(digest(raw) == context.job_payload_sha256, 'SIGNED_ACTION_HASH')
job = json_bytes(raw)
exact(job, 'schema_version tenant_id asset_id agent_id enrollment_generation assignment_version '
'job_id attempt_id action execution_identity not_before start_before max_runtime_seconds max_output_bytes')
require(type(job['schema_version']) is int and job['schema_version'] == 1 and
job['execution_identity'] == 'root' and job['job_id'] == context.job_id and
job['attempt_id'] == context.attempt_id, 'SIGNED_JOB_BINDING')
require(type(job['action']) is dict, 'SIGNED_JOB_ACTION')
outer_action = job['action'].get('action')
require(outer_action in ('ensure_package', 'apply_updates', 'apt_native_acceptance') and
context.action == ('apt-native-acceptance' if outer_action == 'apt_native_acceptance'
else 'apt-execute'), 'DEDICATED_HELPER_ACTION_REQUIRED')
action = job['action'].get('apt_manifest')
manifest_keys = 'type schema_version action execution_profile transaction_sha256 '
manifest_keys += ('resolved_apt_transaction provider_sha256 hook_sha256 apt_config_sha256 '
'runtime_sha256 test_result_id transaction_bytes')
version = action.get('schema_version') if type(action) is dict else None
exact(action, manifest_keys + (' native_retry' if version == 3 else ' native_recovery' if version == 4 else ''))
require(action['type'] == 'rmm.apt.helper-action' and
type(version) is int and version in (2, 3, 4),
'SIGNED_ACTION_SCHEMA')
if version == 3:
validate_retry_reference(action['native_retry'])
require(context.action == 'apt-native-acceptance' and context.execution_profile == 'dev-test',
'RETRY_NATIVE_TEST_ONLY')
if version == 4:
validate_recovery_reference(action['native_recovery'])
require(context.action == 'apt-native-acceptance' and context.execution_profile == 'dev-test' and
transaction.operation == 'configure_only', 'RECOVERY_NATIVE_CONFIGURE_ONLY')
else:
require(transaction.operation is None, 'RECOVERY_MANIFEST_REQUIRED')
expected_bytes = sealed_read(ACTIVE / 'expectation.json')
require(type(action['transaction_bytes']) is list and len(action['transaction_bytes']) <= 65536 and
all(type(value) is int and 0 <= value <= 255 for value in action['transaction_bytes']) and
bytes(action['transaction_bytes']) == expected_bytes and
digest(expected_bytes) == context.transaction_sha256, 'SIGNED_TRANSACTION_EXACT_BYTES')
require(action['action'] == context.action and action['execution_profile'] == context.execution_profile and
action['transaction_sha256'] == context.transaction_sha256 and
canonical(action['resolved_apt_transaction']) == canonical(json_bytes(expected_bytes)),
'SIGNED_ACTION_BINDING')
if outer_action == 'apply_updates':
require(job['action'].get('provider') == 'apt' and
job['action'].get('packages') == ['rmm-mvp-test'] and
job['action'].get('reboot_policy') == 'never' and
transaction.recipe_id == 'rmm-apt-fixture-update-1.1', 'SIGNED_UPDATE_SELECTION')
else:
require(job['action'].get('recipe_id') == transaction.recipe_id and
job['action'].get('recipe_version') == transaction.recipe_version, 'SIGNED_RECIPE_PARAMETERS')
token(action['test_result_id'], IDENT, 'TEST_RESULT_ID')
for field in ('provider_sha256', 'hook_sha256', 'apt_config_sha256', 'runtime_sha256'):
token(action[field], HASH, 'SIGNED_ACTION_HASH')
require(action['provider_sha256'] == digest(sealed_read(CODE)) and
action['hook_sha256'] == digest(sealed_read(Path(HOOK))) and
action['apt_config_sha256'] == digest(apt_config()), 'SIGNED_CODE_RECIPE')
return action
def record_path(transaction):
# Fixed allowlist before deriving filenames; no arbitrary recipe/path input.
fixture_scope(transaction)
return BASE / ('acceptance-' + transaction.recipe_id + '.json')
def check_native_gate(transaction, context, action, runtime, native_acceptance):
scope = fixture_scope(transaction)
require(action['runtime_sha256'] == digest(canonical(runtime)), 'SIGNED_RUNTIME_BINDING')
require(context.execution_profile == 'dev-test', 'PRODUCTION_ACCEPTANCE_REQUIRED')
require(context.action == ('apt-native-acceptance' if native_acceptance else 'apt-execute'),
'DEDICATED_HELPER_ACTION_REQUIRED')
path = record_path(transaction)
if native_acceptance:
if action.get('native_recovery') is not None:
verify_recovery_reference(transaction, context, action)
require(not os.path.lexists(BASE / ('recovery-' + action['native_recovery']['previous_grant_id'] + '.json')),
'RECOVERY_ALREADY_RECORDED')
return
require(not path.exists(), 'ACCEPTANCE_ALREADY_RECORDED')
return
proof = json_bytes(sealed_read(path))
validate_acceptance_record(proof, scope, runtime)
def validate_acceptance_record(proof, scope, runtime):
exact(proof, 'schema_version scope runtime test_acceptance noProductionEvidence '
'test_result_id transaction_sha256 job_payload_sha256 grant_id job_id attempt_id '
'authorization_id plan_sha256 native_prechecks_sha256 hook_marker_sha256 '
'postconditions_sha256 completed_at_ms native_prechecks_schema_version host_reboot_before_sha256 '
'host_reboot_required_before host_reboot_required_after reboot_required_introduced')
require(type(proof['schema_version']) is int and proof['schema_version'] == 3 and
proof['scope'] == scope and proof['runtime'] == runtime and
proof['test_acceptance'] is True and proof['noProductionEvidence'] is True,
'NATIVE_PROOF_SCOPE_OR_RUNTIME')
for key in ('transaction_sha256', 'job_payload_sha256', 'plan_sha256',
'native_prechecks_sha256', 'hook_marker_sha256', 'postconditions_sha256', 'host_reboot_before_sha256'):
token(proof[key], HASH, 'NATIVE_PROOF_HASH')
for key in ('test_result_id', 'grant_id', 'job_id', 'attempt_id', 'authorization_id'):
token(proof[key], IDENT, 'NATIVE_PROOF_ID')
require(type(proof['completed_at_ms']) is int and proof['completed_at_ms'] > 0, 'NATIVE_PROOF_TIME')
require(type(proof['native_prechecks_schema_version']) is int and proof['native_prechecks_schema_version'] == 2 and
type(proof['host_reboot_required_before']) is bool and type(proof['host_reboot_required_after']) is bool and
proof['host_reboot_required_before'] == proof['host_reboot_required_after'] and
proof['reboot_required_introduced'] is False, 'NATIVE_PROOF_BOUND_HOST_REBOOT')
def runtime_identity():
"""Versioned actual code/config/binary/OS identity, also signed in the job."""
require(os.uname().machine == 'x86_64', 'UNSUPPORTED_PLATFORM')
os_release = sealed_read(Path('/etc/os-release').resolve(strict=True))
require(b'\nID=ubuntu\n' in b'\n' + os_release and
b'\nVERSION_ID="24.04"\n' in b'\n' + os_release, 'UNSUPPORTED_PLATFORM')
paths = [str(CODE), HOOK, '/usr/local/libexec/rmm-privileged-helper', '/usr/bin/apt-get', '/usr/bin/dpkg', '/usr/bin/dpkg-deb',
'/usr/bin/dpkg-query', '/usr/bin/python3', '/usr/bin/unshare', '/usr/bin/mount', '/bin/sh']
# Identify the actually loaded shared library, not a guessed soname path.
lib = ctypes.CDLL('libseccomp.so.2')
require(bool(lib), 'SECCOMP_LIBRARY')
libraries = {line.split()[-1] for line in Path('/proc/self/maps').read_text().splitlines()
if '/libseccomp.so.' in line and line.split()[-1].startswith('/')}
require(len(libraries) == 1, 'SECCOMP_LIBRARY_IDENTITY')
paths.extend(sorted(libraries))
binaries = {}
for path in paths:
resolved = Path(path).resolve(strict=True)
binaries[path] = {'resolved_path': str(resolved),
'sha256': digest(sealed_read(resolved, 64 * MAX_INPUT))}
versions = {}
for program in ('apt-get', 'dpkg', 'dpkg-deb', 'dpkg-query', 'python3', 'unshare', 'mount'):
versions[program] = run_read(['/usr/bin/' + program, '--version']).decode('utf-8').splitlines()[0]
return {'schema_version': 1, 'platform': 'ubuntu-24.04-amd64',
'os_release_sha256': digest(os_release), 'kernel_release': os.uname().release,
'binaries': binaries, 'versions': versions, 'apt_config_sha256': digest(apt_config()),
'dpkg_config_sha256': dpkg_config_fingerprint(),
'unit_profile_sha256': digest(sealed_read(APT_UNIT))}
def attempt_binding(context):
return {'transaction_sha256': context.transaction_sha256,
'job_payload_sha256': context.job_payload_sha256,
'grant_id': context.grant_id, 'attempt_id': context.attempt_id}
def validate_retry_reference(ref):
exact(ref, 'schema_version previous_grant_id previous_attempt_id bootstrap_marker_sha256')
require(type(ref['schema_version']) is int and ref['schema_version'] == 1, 'RETRY_SCHEMA')
for key in ('previous_grant_id', 'previous_attempt_id'):
value = ref[key]
require(type(value) is str and str(uuid.UUID(value)) == value, 'RETRY_ID')
token(ref['bootstrap_marker_sha256'], HASH, 'RETRY_MARKER_HASH')
def validate_recovery_reference(ref):
exact(ref, 'schema_version previous_grant_id previous_attempt_id partial_proof_sha256')
require(type(ref['schema_version']) is int and ref['schema_version'] == 1, 'RECOVERY_SCHEMA')
for key in ('previous_grant_id', 'previous_attempt_id'):
value = ref[key]
require(type(value) is str and str(uuid.UUID(value)) == value and uuid.UUID(value).int != 0,
'RECOVERY_ID')
token(ref['partial_proof_sha256'], HASH, 'RECOVERY_PROOF_HASH')
def validate_partial_proof(proof):
exact(proof, 'schema_version type transaction_sha256 job_payload_sha256 effect_armed_ledger_id '
'grant_id job_id attempt_id authorization_id plan_sha256 original_evidence_sha256 '
'original_baseline_sha256 observed_snapshot_sha256 status_fingerprint fixture_payload_sha256 '
'snapshot checked_at_ms partial_effect postconditions_passed reboot_required')
require(type(proof['schema_version']) is int and proof['schema_version'] == 1 and
proof['type'] == 'rmm.apt.partial-reconciliation' and proof['partial_effect'] is True and
proof['postconditions_passed'] is False and proof['reboot_required'] is False and
type(proof['checked_at_ms']) is int and proof['checked_at_ms'] > 0, 'RECOVERY_PROOF_TYPE')
for key in ('transaction_sha256', 'job_payload_sha256', 'plan_sha256', 'original_evidence_sha256',
'original_baseline_sha256', 'observed_snapshot_sha256', 'status_fingerprint', 'fixture_payload_sha256'):
token(proof[key], HASH, 'RECOVERY_PROOF_HASH')
for key in ('grant_id','job_id','attempt_id','authorization_id'):
value = proof[key]
require(type(value) is str and str(uuid.UUID(value)) == value and uuid.UUID(value).int != 0,
'RECOVERY_PROOF_ID')
token(proof['effect_armed_ledger_id'], IDENT, 'RECOVERY_PROOF_LEDGER')
require(type(proof['snapshot']) is dict and
digest(canonical(proof['snapshot'])) == proof['observed_snapshot_sha256'] and
proof['snapshot'].get('rmm-mvp-test:all') == {'version':'1.0','status':'install ok unpacked'} and
proof['fixture_payload_sha256'] == digest(b'1.0\n'), 'RECOVERY_PROOF_SNAPSHOT')
def verify_recovery_reference(transaction, context, action):
"""Only immutable linkage here; current state is checked before the hook.
RootHelper additionally requires this proof in its original shared SQLite
ledger with terminal classified failure and the original verified Request.
Caller-provided JSON or a root-owned file alone never grants authority.
"""
ref = action['native_recovery']; validate_recovery_reference(ref)
require(context.action == 'apt-native-acceptance' and context.execution_profile == 'dev-test' and
action['schema_version'] == 4 and transaction.schema_version == 2 and
transaction.operation == 'configure_only', 'RECOVERY_DEDICATED_ACTION')
fixture_scope(transaction)
raw_proof = sealed_read(ACTIVE / 'partial-proof.json')
proof = json_bytes(raw_proof); validate_partial_proof(proof)
require(raw_proof == canonical(proof) and digest(raw_proof) == ref['partial_proof_sha256'] and
proof['grant_id'] == ref['previous_grant_id'] and proof['attempt_id'] == ref['previous_attempt_id'],
'RECOVERY_IMMUTABLE_PROOF_BINDING')
require(context.grant_id != proof['grant_id'] and context.attempt_id != proof['attempt_id'] and
context.job_id != proof['job_id'] and context.authorization_id != proof['authorization_id'] and
context.plan_sha256 != proof['plan_sha256'], 'RECOVERY_NEW_APPROVAL_REQUIRED')
require(transaction.baseline_sha256 == proof['observed_snapshot_sha256'] and
transaction.status_fingerprint == proof['status_fingerprint'] and
sealed_read(ACTIVE / 'baseline.json') == canonical(proof['snapshot']), 'RECOVERY_BASELINE_BINDING')
previous = BASE / 'history' / ref['previous_grant_id']
secure_path(previous, directory=True, private=True)
names = ('context.json','signed-action.json','expectation.json','baseline.json','launch.json',
'native-prechecks.json','sandbox-ready.json','sandbox-result.json','hook-armed.json')
historical = {name: sealed_read(previous / name) for name in names}
for prefix in ('bootstrap-attempt-', 'bootstrap-retry-'):
name = prefix + 'rmm-apt-fixture-install-1.0.json'
historical[name] = sealed_read(BASE / name)
require(digest(canonical({name:digest(raw) for name,raw in historical.items()})) ==
proof['original_evidence_sha256'], 'RECOVERY_HISTORY_CHANGED')
old = VerifiedHelperContext.parse(json_bytes(historical['context.json']))
require(all(getattr(old, key) == proof[key] for key in
('transaction_sha256','job_payload_sha256','effect_armed_ledger_id','grant_id',
'job_id','attempt_id','authorization_id','plan_sha256')) and
digest(historical['signed-action.json']) == proof['job_payload_sha256'] and
digest(historical['expectation.json']) == proof['transaction_sha256'] and
digest(historical['baseline.json']) == proof['original_baseline_sha256'],
'RECOVERY_ORIGINAL_CONTEXT_BINDING')
old_job = json_bytes(historical['signed-action.json'])
new_job = json_bytes(sealed_read(ACTIVE / 'signed-action.json'))
require(all(old_job[key] == new_job[key] for key in
('tenant_id','asset_id','agent_id','enrollment_generation','assignment_version')) and
digest(sealed_read(previous / 'apt.conf')) == old_job['action']['apt_manifest']['apt_config_sha256'],
'RECOVERY_ORIGINAL_TARGET_OR_CONFIG')
require(not os.path.lexists(BASE / 'acceptance-rmm-apt-fixture-install-1.0.json') and
not os.path.lexists(BASE / 'pending-acceptance-rmm-apt-fixture-install-1.0.json'),
'RECOVERY_NOT_INSTALL_ACCEPTANCE')
return proof
def historical_retry_evidence(transaction, context, action):
"""Recheck immutable no-handoff evidence, never turn unknown into failed.
The parent separately verifies its signed saved request and definitive
HOOK_NOT_HANDED_OFF result in the SAME consumed ledger before this call.
This evidence check cannot itself authorize a retry: the reference must be
inside the NEW exact signed/UI-approved job payload and consumed attempt.
"""
ref = action['native_retry']
validate_retry_reference(ref)
require(context.action == 'apt-native-acceptance' and context.execution_profile == 'dev-test' and
context.grant_id != ref['previous_grant_id'] and
context.attempt_id != ref['previous_attempt_id'], 'RETRY_NEW_APPROVED_ATTEMPT_REQUIRED')
original_path = BASE / ('bootstrap-attempt-' + transaction.recipe_id + '.json')
original_bytes = sealed_read(original_path)
require(digest(original_bytes) == ref['bootstrap_marker_sha256'], 'RETRY_ORIGINAL_MARKER_HASH')
previous = BASE / 'history' / ref['previous_grant_id']
secure_path(previous, directory=True, private=True)
require(not os.path.lexists(previous / 'hook-armed.json') and
not os.path.lexists(record_path(transaction)) and
not os.path.lexists(BASE / ('pending-acceptance-' + transaction.recipe_id + '.json')),
'RETRY_PRIOR_EFFECT_OR_ACCEPTANCE')
names = ('context.json', 'signed-action.json', 'expectation.json', 'baseline.json',
'launch.json', 'sandbox-result.json')
raw = {name: sealed_read(previous / name) for name in names}
old = VerifiedHelperContext.parse(json_bytes(raw['context.json']))
require(old.action == 'apt-native-acceptance' and old.execution_profile == 'dev-test' and
old.grant_id == ref['previous_grant_id'] and old.attempt_id == ref['previous_attempt_id'] and
json_bytes(original_bytes) == attempt_binding(old), 'RETRY_ORIGINAL_ATTEMPT_BINDING')
require(digest(raw['signed-action.json']) == old.job_payload_sha256 and
digest(raw['expectation.json']) == old.transaction_sha256, 'RETRY_PRIOR_PAYLOAD_HASH')
old_tx = ResolvedAptTransaction.parse(json_bytes(raw['expectation.json']))
require(fixture_scope(old_tx) == fixture_scope(transaction) and
old_tx.status_fingerprint == transaction.status_fingerprint and
old_tx.baseline_sha256 == transaction.baseline_sha256, 'RETRY_BASELINE_OR_RECIPE_CHANGED')
require(digest(canonical(json_bytes(raw['baseline.json']))) == old_tx.baseline_sha256 and
raw['baseline.json'] == sealed_read(ACTIVE / 'baseline.json'), 'RETRY_COMPLETE_BASELINE')
previous_job = json_bytes(raw['signed-action.json'])
current_job = json_bytes(sealed_read(ACTIVE / 'signed-action.json'))
require(all(previous_job[key] == current_job[key] for key in
('tenant_id', 'asset_id', 'agent_id', 'enrollment_generation', 'assignment_version')) and
previous_job['job_id'] == old.job_id and previous_job['attempt_id'] == old.attempt_id and
previous_job['execution_identity'] == 'root' and
previous_job['action']['action'] == 'apt_native_acceptance', 'RETRY_DEVICE_OR_JOB_BINDING')
old_manifest = previous_job['action']['apt_manifest']
require(old_manifest['schema_version'] == 2 and 'native_retry' not in old_manifest and
old_manifest['transaction_sha256'] == old.transaction_sha256 and
bytes(old_manifest['transaction_bytes']) == raw['expectation.json'] and
old_manifest['resolved_apt_transaction'] == json_bytes(raw['expectation.json']),
'RETRY_ORIGINAL_SIGNED_TRANSACTION')
require(json_bytes(raw['launch.json']) == {
'transaction_sha256': old.transaction_sha256,
'effect_armed_ledger_id': old.effect_armed_ledger_id} and
json_bytes(raw['sandbox-result.json']) == {
'transaction_sha256': old.transaction_sha256,
'apt_exit_code': 100, 'reboot_required': False}, 'RETRY_KNOWN_PRE_HOOK_FAILURE_REQUIRED')
require(context.job_id != old.job_id and context.authorization_id != old.authorization_id and
context.plan_sha256 != old.plan_sha256, 'RETRY_NEW_APPROVAL_REQUIRED')
return digest(canonical({name: digest(data) for name, data in raw.items()}))
def bootstrap_binding(transaction, context, action):
binding = attempt_binding(context)
if action.get('native_recovery') is not None:
verify_recovery_reference(transaction, context, action)
binding.update(native_recovery=action['native_recovery'])
return BASE / ('recovery-attempt-' + action['native_recovery']['previous_grant_id'] + '.json'), binding
if action.get('native_retry') is not None:
binding.update(native_retry=action['native_retry'], previous_evidence_sha256=
historical_retry_evidence(transaction, context, action))
return BASE / ('bootstrap-retry-' + transaction.recipe_id + '.json'), binding
return BASE / ('bootstrap-attempt-' + transaction.recipe_id + '.json'), binding
def check_bootstrap_attempt(transaction, context, action=None):
action = load_signed_action(transaction, context) if action is None else action
path, binding = bootstrap_binding(transaction, context, action)
require(json_bytes(sealed_read(path)) == binding, 'BOOTSTRAP_ATTEMPT_BINDING')
def invalid_control_syscall_probes():
"""Never pass valid reboot magic, valid kexec flags or valid kexec fds."""
seccomp = ctypes.CDLL('libseccomp.so.2')
seccomp.seccomp_syscall_resolve_name.argtypes = [ctypes.c_char_p]
seccomp.seccomp_syscall_resolve_name.restype = ctypes.c_int
libc = ctypes.CDLL(None, use_errno=True)
libc.syscall.restype = ctypes.c_long
probes = [('reboot', (0, 0, 0, 0)),
('kexec_load', (0, 0, 0, ctypes.c_ulong(0xffffffffffffffff))),
('kexec_file_load', (-1, -1, 0, 0, ctypes.c_ulong(0xffffffffffffffff)))]
for name, args in probes:
number = seccomp.seccomp_syscall_resolve_name(name.encode('ascii'))
require(number >= 0, 'PROBE_SYSCALL')
ctypes.set_errno(0)
result = libc.syscall(ctypes.c_long(number), *args)
require(result == -1 and ctypes.get_errno() == errno.EPERM, 'SECCOMP_CONTROL_PROBE')
return {'invalid_reboot_magic': 'EPERM', 'invalid_kexec_load_flags': 'EPERM',
'invalid_kexec_file_fds_flags': 'EPERM'}
def frontend_lock_probe(config_path=None):
"""Real APT check (read-only), while this process holds the actual lock.
Upstream apt-get.cc DoCheck only Cache.Open()/CheckDeps(), no dpkg/install.
Never unlink a native lock, kill an owner, or use a simulated APT lock.
"""
path = secure_path(Path('/var/lib/dpkg/lock-frontend'))
fd = os.open(path, os.O_RDWR | os.O_NOFOLLOW | os.O_CLOEXEC)
try:
try:
fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
raise Veto('FRONTEND_LOCK_BUSY') from None
data = run_read(['/usr/bin/apt-get', '-o', 'DPkg::Lock::Timeout=0', 'check'],
env={**ENV, 'APT_CONFIG': str(config_path or ACTIVE / 'apt.conf')},
expected_returncode=100, merge_stderr=True, timeout=15)
require(b'/var/lib/dpkg/lock-frontend' in data and
(b'Could not get lock' in data or b'Unable to acquire' in data),
'NATIVE_APT_LOCK_CONFLICT_NOT_PROVEN')
finally:
os.close(fd)
return 'native-apt-check-conflict'
def sandbox_checks(workspace=None):
workspace = ACTIVE if workspace is None else workspace
inspect_sandbox(workspace)
# Inspect mount flags, not a claim that setup commands probably worked.
mounts = {}
for line in Path('/proc/self/mountinfo').read_text().splitlines():
fields = line.split()
separator = fields.index('-')
mounts[fields[4]] = (set(fields[5].split(',')), fields[separator + 1])
for path in ('/sys', '/proc/sys', '/usr/lib/rmm-apt-transaction', str(BASE / 'archives')):
require(path in mounts and 'ro' in mounts[path][0], 'NATIVE_READONLY_MOUNT')
for path in ('/run', '/tmp', '/var/tmp', '/dev'):
require(path in mounts and mounts[path][1] == 'tmpfs', 'NATIVE_PRIVATE_TMPFS')
require(stat.S_ISCHR(Path('/proc/sysrq-trigger').stat().st_mode), 'NATIVE_SYSRQ_MASK')
probes = invalid_control_syscall_probes()
conflict = frontend_lock_probe() if workspace == ACTIVE else frontend_lock_probe(workspace / 'apt.conf')
return {'namespaces_caps_nnp_seccomp': True, 'readonly_controlpaths': True,
'private_tmpfs_sockets': True, 'control_syscalls': probes, 'frontend_lock': conflict}
def native_prechecks(context):
checks = sandbox_checks()
context.check_deadline()
before, before_sha = load_host_reboot_before(context)
return {'schema_version': 2, 'transaction_sha256': context.transaction_sha256,
'job_payload_sha256': context.job_payload_sha256, 'boot_id': context.boot_id,
'host_reboot_before_sha256': before_sha,
'host_reboot_required_before': before['host_reboot_required'],
'checks': checks}
def capture_host_reboot_before(context):
"""Parent namespace only, BEFORE unshare replaces /run with private tmpfs."""
context.check_deadline()
record = {'schema_version': 1, 'transaction_sha256': context.transaction_sha256,
'job_payload_sha256': context.job_payload_sha256,
'effect_armed_ledger_id': context.effect_armed_ledger_id,
'grant_id': context.grant_id, 'boot_id': context.boot_id,
'host_reboot_required': Path('/run/reboot-required').exists(),
'observed_at_ms': time.time_ns() // 1000000}
durable_once(ACTIVE / 'host-reboot-before.json', record)
context.check_deadline()
def load_host_reboot_before(context):
raw = sealed_read(ACTIVE / 'host-reboot-before.json')
record = json_bytes(raw)
exact(record, 'schema_version transaction_sha256 job_payload_sha256 effect_armed_ledger_id '
'grant_id boot_id host_reboot_required observed_at_ms')
require(raw == canonical(record) and type(record['schema_version']) is int and record['schema_version'] == 1 and
all(record[key] == getattr(context, key) for key in
('transaction_sha256', 'job_payload_sha256', 'effect_armed_ledger_id', 'grant_id', 'boot_id')) and
type(record['host_reboot_required']) is bool and type(record['observed_at_ms']) is int and
context.not_before_ms <= record['observed_at_ms'] < context.start_before_ms and
record['observed_at_ms'] <= time.time_ns() // 1000000, 'HOST_REBOOT_BEFORE_BINDING')
return record, digest(raw)
def verify_host_reboot_after(context, evidence):
"""Parent namespace observation; ambient true is honest pending evidence.
The private worker must never introduce a reboot request. Equal HOST flags
(including true/true) do not imply that a reboot was requested or performed.
"""
before, before_sha = load_host_reboot_before(context)
after = Path('/run/reboot-required').exists()
require(Path('/proc/sys/kernel/random/boot_id').read_text().strip() == context.boot_id,
'BOOT_CHANGED_DURING_TRANSACTION')
child = json_bytes(sealed_read(ACTIVE / 'sandbox-result.json'))
exact(child, 'transaction_sha256 apt_exit_code reboot_required')
require(child['transaction_sha256'] == context.transaction_sha256 and
type(child['apt_exit_code']) is int and child['apt_exit_code'] == 0 and
child['reboot_required'] is False, 'FIXTURE_PRIVATE_REBOOT_FLAG_INTRODUCED')
require(after == before['host_reboot_required'] and evidence['reboot_required'] is after,
'HOST_REBOOT_STATE_CHANGED_DURING_TRANSACTION')
return {'host_reboot_required_before': before['host_reboot_required'],
'host_reboot_required_after': after, 'host_reboot_before_sha256': before_sha,
'reboot_required_introduced': False}
def complete_acceptance(transaction, context, action, runtime, evidence):
"""Called only after real child success, armed hook AND independent verify."""
require(context.action == 'apt-native-acceptance' and context.execution_profile == 'dev-test',
'DEDICATED_HELPER_ACTION_REQUIRED')
check_bootstrap_attempt(transaction, context, action)
prechecks = json_bytes(sealed_read(ACTIVE / 'native-prechecks.json'))
expected_checks = {'namespaces_caps_nnp_seccomp': True, 'readonly_controlpaths': True,
'private_tmpfs_sockets': True,
'control_syscalls': {'invalid_reboot_magic': 'EPERM',
'invalid_kexec_load_flags': 'EPERM',
'invalid_kexec_file_fds_flags': 'EPERM'},
'frontend_lock': 'native-apt-check-conflict'}
before, before_sha = load_host_reboot_before(context)
require(prechecks == {'schema_version': 2, 'transaction_sha256': context.transaction_sha256,
'job_payload_sha256': context.job_payload_sha256,
'boot_id': context.boot_id, 'host_reboot_before_sha256': before_sha,
'host_reboot_required_before': before['host_reboot_required'],
'checks': expected_checks}, 'NATIVE_PRECHECKS_REQUIRED')
evidence.update(verify_host_reboot_after(context, evidence))
require(runtime_identity() == runtime, 'RUNTIME_CHANGED_DURING_ACCEPTANCE')
proof = {'schema_version': 3, 'scope': fixture_scope(transaction), 'runtime': runtime,
'test_acceptance': True, 'noProductionEvidence': True,
'test_result_id': action['test_result_id'],
'transaction_sha256': context.transaction_sha256,
'job_payload_sha256': context.job_payload_sha256, 'grant_id': context.grant_id,
'job_id': context.job_id, 'attempt_id': context.attempt_id,
'authorization_id': context.authorization_id, 'plan_sha256': context.plan_sha256,
'native_prechecks_sha256': digest(canonical(prechecks)),
'native_prechecks_schema_version': 2,
'host_reboot_before_sha256': before_sha,
'host_reboot_required_before': evidence['host_reboot_required_before'],
'host_reboot_required_after': evidence['host_reboot_required_after'],
'reboot_required_introduced': False,
'hook_marker_sha256': digest(sealed_read(ACTIVE / 'hook-armed.json')),
'postconditions_sha256': digest(canonical(evidence)),
'completed_at_ms': time.time_ns() // 1000000}
# Stage+fsync complete bytes before publishing. Failed writes never leave a
# parseable final partial record. An existing final record is never replaced.
recovery = action.get('native_recovery')
if recovery is not None:
verify_recovery_reference(transaction, context, action)
proof.update(schema_version=2, type='rmm.apt.native-recovery', operation='configure_only',
native_recovery=recovery)
path = BASE / ('recovery-' + recovery['previous_grant_id'] + '.json')
staged = BASE / ('pending-recovery-' + recovery['previous_grant_id'] + '.json')
else:
path = record_path(transaction)
staged = BASE / ('pending-acceptance-' + transaction.recipe_id + '.json')
durable_once(staged, proof)
linked = False
try:
os.link(staged, path, follow_symlinks=False)
linked = True
directory_fd = os.open(BASE, os.O_RDONLY | os.O_DIRECTORY)
try:
os.fsync(directory_fd)
finally:
os.close(directory_fd)
except BaseException:
if linked:
path.unlink()
raise
# Retain staged bytes as an immutable record witness; never reset attempts.
if recovery is not None:
return {'test_acceptance': True, 'noProductionEvidence': True, 'native_recovery': True,
'recovery_record_sha256': digest(canonical(proof)),
'partial_proof_sha256': recovery['partial_proof_sha256'],
'test_result_id': action['test_result_id']}
return {'test_acceptance': True, 'noProductionEvidence': True,
'native_record_sha256': digest(canonical(proof)), 'test_result_id': action['test_result_id']}
@dataclass(frozen=True)
class Action:
name: str
old_version: str
old_arch: str
old_multiarch: str
direction: str
new_version: str
new_arch: str
new_multiarch: str
action: str
def decode_config(value):
require(not re.search(r'%(?![0-9A-Fa-f]{2})', value), 'CONFIG_ESCAPE')
try:
return unquote_to_bytes(value).decode('utf-8', 'strict')
except UnicodeError:
raise Veto('CONFIG_ENCODING') from None
def parse_protocol3(data):
"""Real nine-field APT v3; config supports repeated unnamed list keys."""
require(type(data) is bytes and 0 < len(data) <= MAX_INPUT, 'INPUT_LIMIT')
try:
text = data.decode('ascii')
except UnicodeError:
raise Veto('PROTOCOL_ENCODING') from None
require(text.endswith('\n') and not re.search(r'[\x00-\x09\x0b-\x1f\x7f]', text),
'PROTOCOL_CONTROL')
lines = text.split('\n')
require(lines.pop(0) == 'VERSION 3', 'PROTOCOL_VERSION')
require('' in lines, 'CONFIG_TERMINATOR')
config = []
while lines and lines[0] != '':
line = lines.pop(0)
require(len(line) <= 16384 and '=' in line, 'CONFIG_LINE')
key, value = line.split('=', 1)
require(key != '', 'CONFIG_KEY')
config.append((decode_config(key), decode_config(value)))
lines.pop(0)
require(lines.pop() == '' and 0 < len(lines) <= MAX_PACKAGES * 2, 'ACTION_COUNT')
actions = []
for line in lines:
fields = line.split(' ')
require(len(fields) == 9 and all(fields), 'ACTION_FIELDS')
action = Action(*fields)
token(action.name, NAME, 'PACKAGE_NAME')
for version in (action.old_version, action.new_version):
require(version == '-' or VERSION.fullmatch(version), 'VERSION')
require(action.direction in ('<', '>', '='), 'DIRECTION')
for arch in (action.old_arch, action.new_arch):
require(arch in ('-', 'amd64', 'all'), 'ARCHITECTURE')
for multiarch in (action.old_multiarch, action.new_multiarch):
require(multiarch in ('none', 'no', 'same', 'foreign', 'allowed'), 'MULTIARCH')
require((action.old_version == '-') == (action.old_arch == '-'), 'OLD_ARCH')
require((action.new_version == '-') == (action.new_arch == '-'), 'NEW_ARCH')
actions.append(action)
return tuple(config), tuple(actions)
def validate_actions(transaction, actions):
if transaction.operation == 'configure_only':
fixture_scope(transaction)
require(len(actions) == 1 and actions[0] == Action(
'rmm-mvp-test', '1.0', 'all', 'none', '=', '1.0', 'all', 'none', '**CONFIGURE**'),
'RECOVERY_CONFIGURE_ACTION_ONLY')
return
expected = {(p.name, p.architecture): p for p in transaction.packages}
seen = set()
for action in actions:
key = (action.name, action.new_arch)
require(key in expected, 'EXTRA_ACTION')
package = expected[key]
require(action.old_version == (package.old_version or '-') and
action.new_version == package.new_version and action.direction == '<' and
action.old_arch == (package.architecture if package.old_version else '-'),
'ACTION_VERSION_ARCH')
# APT expands one CONFIGURE for every install before sending the hook.
kind = 'configure' if action.action == '**CONFIGURE**' else 'install'
require(action.action == '**CONFIGURE**' or action.action == package.archive_path,
'ACTION_PATH_OR_REMOVAL')
require((key, kind) not in seen, 'DUPLICATE_ACTION')
seen.add((key, kind))
require(seen == {(key, kind) for key in expected for kind in ('install', 'configure')},
'INCOMPLETE_TRANSACTION')
def verify_archive(package):
path = secure_path(package.archive_path)
fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
try:
st = os.fstat(fd)
archive_metadata(st, package.size)
sha = hashlib.sha256()
while True:
chunk = os.read(fd, 65536)
if not chunk:
break
sha.update(chunk)
require(sha.hexdigest() == package.sha256, 'ARCHIVE_HASH')
# Refer to our already opened inode, not a second path traversal.
fields = run_read(['/usr/bin/dpkg-deb', '--show',
'--showformat=${Package}\n${Version}\n${Architecture}\n'
'${Essential}\n${Protected}\n${Conflicts}\n${Breaks}\n${Replaces}\n',
'/proc/self/fd/' + str(fd)], limit=16384, pass_fds=(fd,))
values = fields.decode('utf-8', 'strict').splitlines()
require(len(values) == 8 and
values[:3] == [package.name, package.new_version, package.architecture] and
values[3] in ('', 'no') and values[4] in ('', 'no') and
values[5:] == ['', '', ''], 'DEB_CONTROL_OR_CONFLICT')
payload = run_read(['/usr/bin/dpkg-deb', '--fsys-tarfile', '/proc/self/fd/' + str(fd)],
limit=64 * MAX_INPUT, pass_fds=(fd,))
validate_payload(payload)
finally:
os.close(fd)
def validate_payload(payload):
"""Reject boot/control-plane payloads even if the package has an innocent name."""
forbidden = ('boot', 'lib/modules', 'usr/lib/modules', 'etc/kernel', 'etc/apt',
'etc/systemd', 'usr/lib/systemd', 'lib/systemd', 'etc/init',
'etc/cron', 'var/spool/cron', 'usr/lib/rmm-apt-transaction',
'var/lib/rmm-apt-transaction', 'proc', 'sys', 'dev', 'run')
try:
with tarfile.open(fileobj=io.BytesIO(payload), mode='r:') as archive:
count = 0
for entry in archive:
count += 1
require(count <= 10000, 'DEB_PAYLOAD_LIMIT')
name = entry.name
if name.startswith('./'):
name = name[2:]
name = name.rstrip('/')
require(not name.startswith('/') and '..' not in name.split('/'), 'DEB_PAYLOAD_PATH')
require(not any(name == prefix or name.startswith(prefix + '/') or
(prefix == 'etc/cron' and name.startswith(prefix))
for prefix in forbidden), 'DEB_PROTECTED_PATH')
require(entry.isfile() or entry.isdir() or entry.issym(), 'DEB_PAYLOAD_TYPE')
if entry.issym():
# Restrictive v1: no absolute or escaping package symlinks.
require(not entry.linkname.startswith('/') and
'..' not in entry.linkname.split('/'), 'DEB_SYMLINK_TARGET')
except tarfile.TarError:
raise Veto('DEB_PAYLOAD_FORMAT') from None
def status_fingerprint():
"""Resolver-relevant state, under native APT lock at hook time."""
updates = Path('/var/lib/dpkg/updates')
require(not list(updates.iterdir()), 'DPKG_DIRTY_UPDATES')
records = {}
for path in (Path('/var/lib/dpkg/status'), Path('/var/lib/dpkg/arch'),
Path('/var/lib/apt/extended_states')):
records[str(path)] = digest(sealed_read(path, 64 * MAX_INPUT)) if path.exists() else None
triggers = Path('/var/lib/dpkg/triggers')
for path in sorted(triggers.iterdir()):
if path.name != 'Lock':
records[str(path)] = digest(sealed_read(path, 16 * MAX_INPUT))
require(not (triggers / 'Unincorp').read_bytes(), 'DPKG_PENDING_TRIGGERS')
return digest(canonical(records))
def dpkg_config_fingerprint():
# dpkg has its own global configuration, independent of APT_CONFIG. Its
# exact contents require administrator review in the native acceptance.
records = {}
paths = [Path('/etc/dpkg/dpkg.cfg')]
directory = Path('/etc/dpkg/dpkg.cfg.d')
if directory.exists():
secure_path(directory, directory=True)
paths.extend(sorted(directory.iterdir()))
for path in paths:
records[str(path)] = digest(sealed_read(path)) if path.exists() else None
return digest(canonical(records))
def installed_snapshot():
data = run_read(['/usr/bin/dpkg-query', '--show',
'--showformat=${Package}\t${Architecture}\t${Version}\t${Status}\n'],
limit=32 * MAX_INPUT)
snapshot = {}
for line in data.decode('utf-8', 'strict').splitlines():
fields = line.split('\t')
require(len(fields) == 4, 'DPKG_QUERY_FORMAT')
name, arch, version, status = fields
key = name + ':' + arch
require(key not in snapshot, 'DPKG_QUERY_DUPLICATE')
require(status in ('install ok installed', 'deinstall ok config-files',
'purge ok not-installed', 'unknown ok not-installed'), 'DPKG_INCONSISTENT')
snapshot[key] = {'version': version, 'status': status}
return snapshot
def check_current_baseline(transaction, baseline):
require(digest(canonical(baseline)) == transaction.baseline_sha256, 'BASELINE_HASH')
require(status_fingerprint() == transaction.status_fingerprint, 'STATUS_FINGERPRINT')
snapshot = partial_installed_snapshot() if transaction.operation == 'configure_only' else installed_snapshot()
require(snapshot == baseline, 'STATUS_BASELINE_CHANGED')
if transaction.operation == 'configure_only':
fixture_scope(transaction)
require(baseline.get('rmm-mvp-test:all') == {'version': '1.0', 'status': 'install ok unpacked'} and
sealed_read(Path('/usr/share/rmm-mvp-test/version'), limit=32) == b'1.0\n',
'RECOVERY_PARTIAL_PRECONDITION')
def check_preconditions(transaction, baseline):
check_current_baseline(transaction, baseline)
for p in transaction.packages:
current = baseline.get(p.name + ':' + p.architecture)
require((current is None if p.old_version is None else
current == {'version': p.old_version, 'status':
'install ok unpacked' if transaction.operation == 'configure_only' else 'install ok installed'}),
'PACKAGE_PRECONDITION')
def apt_config():
"""Constant bytes: no job string, URL, shell interpolation, global hooks."""
# APT's default selection rewrite erases explicit Configure operations and
# substitutes --configure --pending. Keep the exact target Configure instead
# while both pending modes remain disabled (upstream dpkgpm.cc, APT 2.7.14).
return ('''Dir::Etc::parts "/var/lib/rmm-apt-transaction/active/empty";
Dir::Etc::main "/dev/null";
Dir::Etc::sourcelist "/dev/null";
Dir::Etc::sourceparts "/var/lib/rmm-apt-transaction/active/empty";
Dir::Etc::preferences "/dev/null";
Dir::Etc::preferencesparts "/var/lib/rmm-apt-transaction/active/empty";
Dir::State::status "/var/lib/dpkg/status";
Dir::State::lists "/var/lib/rmm-apt-transaction/active/lists";
Dir::Cache::archives "/var/lib/rmm-apt-transaction/active/cache";
Dir::Cache::pkgcache "";
Dir::Cache::srcpkgcache "";
Dir::Bin::dpkg "/usr/bin/dpkg";
Dir::Log "/var/lib/rmm-apt-transaction/log";
Dir::Log::Terminal "term.log";
Dir::Log::History "history.log";
Dir::State::extended_states "/var/lib/rmm-apt-transaction/state/extended_states";
DPkg::Options { "--log=/var/lib/rmm-apt-transaction/log/dpkg.log"; };
APT::Architecture "amd64";
APT::Architectures { "amd64"; };
APT::Install-Recommends "false";
APT::Install-Suggests "false";
APT::Get::AutomaticRemove "false";
APT::Get::Fix-Broken "false";
APT::Get::Fix-Missing "false";
APT::Get::Download "true";
APT::Get::allow-Downgrades "false";
APT::Get::allow-Remove-Essential "false";
DPkg::Lock::Timeout "10";
DPkg::ConfigurePending "false";
DPkg::TriggersPending "false";
dpkg::selection::remove::approved "false";
DPkg::Inhibit-Shutdown "false";
DPkg::Use-Pty "false";
DPkg::Pre-Install-Pkgs { "/usr/lib/rmm-apt-transaction/hook"; };
DPkg::Tools::Options::/usr/lib/rmm-apt-transaction/hook::Version "3";
DPkg::Tools::Options::/usr/lib/rmm-apt-transaction/hook::InfoFD "0";
''').encode('ascii')
def apt_argv(transaction):
if transaction.operation == 'configure_only':
fixture_scope(transaction)
return ['/usr/bin/apt-get', '--yes', '--no-remove', '--no-install-recommends',
'install', '--', 'rmm-mvp-test=1.0']
# APT's --no-download also prevents the local file method from resolving
# its Install filename (v3 emits **ERROR**). Permit local acquisition of
# the already sealed/hash-checked archive. Empty sources, fixed paths and
# the verified AF_UNIX-only private worker still forbid network retrieval.
return ['/usr/bin/apt-get', '--yes', '--no-remove', '--no-install-recommends',
'install', '--'] + [p.archive_path for p in transaction.packages]
def check_hook_config(config):
hooks = [(key.lower(), value) for key, value in config
if key.lower().startswith(('dpkg::pre-', 'dpkg::post-')) and value]
require(hooks == [('dpkg::pre-install-pkgs::', HOOK)], 'HOOK_CONFIG')
for key, expected in (
('dpkg::tools::options::' + HOOK + '::version', '3'),
('dpkg::tools::options::' + HOOK + '::infofd', '0'),
('dir::bin::dpkg', '/usr/bin/dpkg'),
('dir::state::status', '/var/lib/dpkg/status'),
('dpkg::configurepending', 'false'),
('dpkg::triggerspending', 'false'),
('dpkg::selection::remove::approved', 'false')):
require([value for name, value in config if name.lower() == key] == [expected],
'APT_CONFIG_BINDING')
def load_active():
secure_path(ACTIVE, directory=True, private=True)
raw = sealed_read(ACTIVE / 'expectation.json')
transaction = ResolvedAptTransaction.parse(json_bytes(raw))
context = VerifiedHelperContext.parse(json_bytes(sealed_read(ACTIVE / 'context.json')))
require(digest(raw) == context.transaction_sha256, 'TRANSACTION_BINDING')
baseline = json_bytes(sealed_read(ACTIVE / 'baseline.json'))
return transaction, context, baseline
def hook():
require(os.geteuid() == 0, 'ROOT_REQUIRED')
require(os.environ.get('APT_HOOK_INFO_FD') == '0' and
os.environ.get('DPKG_FRONTEND_LOCKED') == 'true', 'NATIVE_APT_HOOK_REQUIRED')
transaction, context, baseline = load_active()
action = load_signed_action(transaction, context)
native_acceptance = context.action == 'apt-native-acceptance'
check_native_gate(transaction, context, action, runtime_identity(), native_acceptance)
if native_acceptance:
check_bootstrap_attempt(transaction, context, action)
ready = json_bytes(sealed_read(ACTIVE / 'sandbox-ready.json'))
require(ready == {'transaction_sha256': context.transaction_sha256,
'sandbox_version': 1}, 'SANDBOX_HANDSHAKE')
inspect_sandbox()
config, actions = parse_protocol3(sys.stdin.buffer.read(MAX_INPUT + 1))
check_hook_config(config)
validate_actions(transaction, actions)
check_preconditions(transaction, baseline)
for package in transaction.packages:
verify_archive(package)
# Last gate AFTER hashing/read checks. Deadline applies before first dpkg.
context.check_deadline()
durable_once(ACTIVE / 'hook-armed.json', {
'effect_armed_ledger_id': context.effect_armed_ledger_id,
'grant_id': context.grant_id, 'transaction_sha256': context.transaction_sha256,
'protocol_sha256': digest(canonical([a.__dict__ for a in actions])),
'armed_at_ms': time.time_ns() // 1000000})
# File/directory fsync can outlive the startgrant. Veto before returning
# success to APT; retain the armed marker for conservative reconciliation,
# never reset it or permit another handoff after this uncertain boundary.
context.check_deadline()
def seccomp_filter():
# libseccomp resolves native syscall numbers; no hardcoded x86 syscall IDs.
lib = ctypes.CDLL('libseccomp.so.2', use_errno=True)
lib.seccomp_init.argtypes = [ctypes.c_uint32]
lib.seccomp_init.restype = ctypes.c_void_p
lib.seccomp_syscall_resolve_name.argtypes = [ctypes.c_char_p]
lib.seccomp_syscall_resolve_name.restype = ctypes.c_int
lib.seccomp_rule_add.argtypes = [ctypes.c_void_p, ctypes.c_uint32, ctypes.c_int, ctypes.c_uint]
lib.seccomp_load.argtypes = [ctypes.c_void_p]
lib.seccomp_release.argtypes = [ctypes.c_void_p]
class ArgCompare(ctypes.Structure):
_fields_ = [('arg', ctypes.c_uint), ('op', ctypes.c_uint),
('datum_a', ctypes.c_uint64), ('datum_b', ctypes.c_uint64)]
lib.seccomp_rule_add_array.argtypes = [ctypes.c_void_p, ctypes.c_uint32, ctypes.c_int,
ctypes.c_uint, ctypes.POINTER(ArgCompare)]
ctx = lib.seccomp_init(0x7fff0000) # SCMP_ACT_ALLOW
require(bool(ctx), 'SECCOMP_INIT')
try:
for name in ('reboot', 'kexec_load', 'kexec_file_load', 'mount', 'umount2',
'pivot_root', 'chroot', 'unshare', 'setns', 'fsopen', 'fsconfig',
'fsmount', 'move_mount', 'open_tree', 'mount_setattr', 'ptrace',
'process_vm_writev', 'bpf', 'init_module', 'finit_module',
'delete_module', 'swapon', 'swapoff', 'iopl', 'ioperm'):
number = lib.seccomp_syscall_resolve_name(name.encode('ascii'))
require(number >= 0, 'SECCOMP_SYSCALL_UNAVAILABLE')
require(lib.seccomp_rule_add(ctx, 0x50000 | errno.EPERM, number, 0) == 0,
'SECCOMP_RULE')
# clone3 has pointer-based flags: deny with ENOSYS so libc can fall back
# to ordinary clone/fork. clone's namespace flags are explicitly denied,
# including NEWUSER/NEWTIME, not just flags requiring CAP_SYS_ADMIN.
clone3 = lib.seccomp_syscall_resolve_name(b'clone3')
clone = lib.seccomp_syscall_resolve_name(b'clone')
require(clone3 >= 0 and clone >= 0, 'SECCOMP_CLONE_ABI')
require(lib.seccomp_rule_add(ctx, 0x50000 | errno.ENOSYS, clone3, 0) == 0, 'SECCOMP_CLONE3')
for flag in (0x80, 0x20000, 0x2000000, 0x4000000, 0x8000000,
0x10000000, 0x20000000, 0x40000000):
compare = ArgCompare(0, 7, flag, flag) # SCMP_CMP_MASKED_EQ
require(lib.seccomp_rule_add_array(ctx, 0x50000 | errno.EPERM, clone, 1,
ctypes.byref(compare)) == 0, 'SECCOMP_CLONE_FLAGS')
require(lib.seccomp_load(ctx) == 0, 'SECCOMP_LOAD')
finally:
lib.seccomp_release(ctx)
def drop_capabilities():
libc = ctypes.CDLL(None, use_errno=True)
# Keep only filesystem ownership/access and uid/gid capabilities needed by
# dpkg. No KILL, SYS_ADMIN, SYS_BOOT, SYS_PTRACE, SYS_RAWIO, NET_ADMIN, MKNOD.
allowed = {0, 1, 3, 4, 6, 7, 8, 31} # CHOWN,DAC_OVERRIDE,FOWNER,FSETID,SETGID,SETUID,SETPCAP,SETFCAP
last = int(Path('/proc/sys/kernel/cap_last_cap').read_text())
require(last < 64, 'CAPABILITY_ABI')
for number in range(last + 1):
if number not in allowed:
require(libc.prctl(24, number, 0, 0, 0) == 0, 'CAP_BOUNDING_DROP')
class Header(ctypes.Structure):
_fields_ = [('version', ctypes.c_uint32), ('pid', ctypes.c_int)]
class Data(ctypes.Structure):
_fields_ = [('effective', ctypes.c_uint32), ('permitted', ctypes.c_uint32),
('inheritable', ctypes.c_uint32)]
mask = sum(1 << cap for cap in allowed)
header = Header(0x20080522, 0)
values = (Data * 2)(Data(mask & 0xffffffff, mask & 0xffffffff, 0), Data(0, 0, 0))
require(libc.capset(ctypes.byref(header), values) == 0, 'CAPSET')
require(libc.prctl(38, 1, 0, 0, 0) == 0, 'NO_NEW_PRIVILEGES')
def mount(argv):
require(subprocess.run(['/usr/bin/mount'] + argv, env=ENV,
stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL).returncode == 0, 'SANDBOX_MOUNT')
def inspect_sandbox(workspace=None):
"""Check inherited kernel enforcement inside worker AND hook."""
status = dict(line.split(':', 1) for line in Path('/proc/self/status').read_text().splitlines()
if ':' in line)
require(status['NoNewPrivs'].strip() == '1' and status['Seccomp'].strip() == '2',
'SANDBOX_SECCOMP')
for key in ('CapEff', 'CapPrm', 'CapBnd'):
caps = int(status[key].strip(), 16)
require(caps == sum(1 << n for n in (0, 1, 3, 4, 6, 7, 8, 31)), 'SANDBOX_CAPS')
require(int(status['CapInh'].strip(), 16) == 0 and int(status['CapAmb'].strip(), 16) == 0,
'SANDBOX_INHERITED_CAPS')
verify_no_ip_sockets()
# Host PID1 must not be visible. Namespace PID1 is this trusted Python worker.
require(Path('/proc/1/cmdline').read_bytes().startswith(b'/usr/bin/python3\x00-I\x00'),
'SANDBOX_PID1')
require(not any(Path(path).exists() for path in (
'/run/systemd/private', '/run/dbus/system_bus_socket',
'/run/rmm/privileged-helper.sock', '/var/run/dbus/system_bus_socket')),
'SANDBOX_HOST_SOCKETS')
require(not Path('/var/lib/rmm-helper/consumption.sqlite').exists() and
not Path('/etc/rmm/helper.json').exists() and not Path('/etc/rmm/apt-helper.json').exists(),
'SANDBOX_LEDGER_OR_KEYS_VISIBLE')
inspect_private_control_paths()
# Parent gives us the original namespace identities; cannot accept flags alone.
workspace = ACTIVE if workspace is None else workspace
ids = json_bytes(sealed_read(workspace / 'host-namespaces.json'))
for name in ('pid', 'mnt', 'net'):
require(os.readlink('/proc/self/ns/' + name) != ids[name], 'SANDBOX_NAMESPACE')
def verify_no_ip_sockets():
"""Kernel enforcement, not a no-download flag or a network configuration claim."""
for family in (socket.AF_INET, socket.AF_INET6):
try:
candidate = socket.socket(family, socket.SOCK_STREAM)
except OSError as error:
require(error.errno in (errno.EAFNOSUPPORT, errno.EPERM, errno.EACCES),
'SANDBOX_IP_SOCKET_CHECK')
else:
candidate.close()
raise Veto('SANDBOX_IP_SOCKET_ALLOWED')
def inspect_private_control_paths():
# Validate directory contents rather than guessing future key filenames.
# Both historical and current cloud identity/config layouts must be hidden.
for name in PRIVATE_CONTROL_DIRECTORIES:
path = Path(name)
require(not path.is_symlink() and (not path.exists() or (path.is_dir()
and next(path.iterdir(), None) is None)), 'SANDBOX_LEDGER_OR_KEYS_VISIBLE')
def setup_sandbox(workspace=None, probe_db=None):
"""One trusted setup implementation for real jobs AND read-only probes."""
workspace = ACTIVE if workspace is None else workspace
require(os.geteuid() == 0 and os.getpid() == 1, 'SANDBOX_NAMESPACE')
for fd in os.listdir('/proc/self/fd'):
if int(fd) > 2:
try:
os.close(int(fd))
except OSError as error:
require(error.errno == errno.EBADF, 'SANDBOX_INHERITED_FD')
# unshare makes a private mount namespace; never propagate these mounts.
mount(['--make-rprivate', '/'])
if probe_db is not None:
mount(['--bind', str(probe_db), '/var/lib/dpkg'])
# Neither the signed-key/config files nor shared SQLite/flock inodes are
# available to the package child. Only the outside root controller sees them.
for hidden in ('/etc/rmm', '/var/lib/rmm-helper'):
require(Path(hidden).is_dir(), 'SANDBOX_PRIVATE_CONTROL_PATH_REQUIRED')
for hidden in (*PRIVATE_CONTROL_DIRECTORIES, '/home', '/root'):
if Path(hidden).is_dir():
require(not Path(hidden).is_symlink(), 'SANDBOX_PRIVATE_CONTROL_PATH_REQUIRED')
mount(['-t', 'tmpfs', '-o', 'mode=0700,nosuid,nodev,noexec', 'tmpfs', hidden])
# Hide ALL conventional host control sockets, not merely systemctl binaries.
mount(['-t', 'tmpfs', '-o', 'mode=0755,nosuid,nodev,noexec', 'tmpfs', '/run'])
mount(['-t', 'tmpfs', '-o', 'mode=1777,nosuid,nodev', 'tmpfs', '/tmp'])
mount(['-t', 'tmpfs', '-o', 'mode=1777,nosuid,nodev', 'tmpfs', '/var/tmp'])
mount(['-t', 'tmpfs', '-o', 'mode=0755,nosuid,noexec', 'tmpfs', '/dev'])
# Bind only basic devices from proc fd? /dev was hidden, so use mknod while
# CAP_MKNOD is still held; no block devices or consoles are exposed.
for name, mode, major, minor in (('null', 0o666, 1, 3), ('zero', 0o666, 1, 5),
('random', 0o666, 1, 8), ('urandom', 0o666, 1, 9)):
os.mknod('/dev/' + name, stat.S_IFCHR | mode, os.makedev(major, minor))
os.symlink('/proc/self/fd', '/dev/fd')
for path in ('/sys', '/proc/sys', '/proc/irq', '/proc/bus', '/boot',
'/usr/lib/rmm-apt-transaction', str(BASE / 'archives'),
'/etc/systemd', '/usr/lib/systemd', '/etc/cron.d', '/etc/crontab',
'/etc/cron.daily', '/etc/cron.hourly', '/etc/cron.weekly',
'/etc/cron.monthly', '/var/spool/cron'):
if Path(path).exists():
mount(['--bind', path, path])
mount(['-o', 'remount,bind,ro,nosuid,nodev', path])
for path in ('/proc/sysrq-trigger', '/proc/kcore', '/proc/keys', '/proc/timer_list'):
if Path(path).exists():
mount(['--bind', '/dev/null', path])
drop_capabilities()
seccomp_filter()
inspect_sandbox(workspace)
def sandbox_worker():
transaction, context, _ = load_active()
action = load_signed_action(transaction, context)
check_native_gate(transaction, context, action, runtime_identity(),
context.action == 'apt-native-acceptance')
if context.action == 'apt-native-acceptance':
check_bootstrap_attempt(transaction, context, action)
setup_sandbox()
# Executed natively in the actual mutation sandbox, never synthesized by
# the parent or by a bootstrap flag. Also required for record-backed runs.
durable_once(ACTIVE / 'native-prechecks.json', native_prechecks(context))
durable_once(ACTIVE / 'sandbox-ready.json', {
'transaction_sha256': context.transaction_sha256, 'sandbox_version': 1})
context.check_deadline()
# Never timeout/kill an active package manager. Parent journals unknown on
# transport/process loss; it must not retry. Native lock wait itself is 10s.
proc = subprocess.Popen(apt_argv(transaction), env={**ENV, 'APT_CONFIG': str(ACTIVE / 'apt.conf')},
stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
code = proc.wait()
# As namespace PID1, do not exit and implicitly SIGKILL any orphaned dpkg
# child if APT itself died. Reap/wait for all adopted descendants first.
while True:
try:
os.waitpid(-1, 0)
except ChildProcessError:
break
# /run is private: export this observation before the namespace disappears.
# Parent also checks the host flag; neither observation initiates a reboot.
durable_once(ACTIVE / 'sandbox-result.json', {
'transaction_sha256': context.transaction_sha256, 'apt_exit_code': code,
'reboot_required': Path('/run/reboot-required').exists()})
os._exit(0 if code == 0 else 100)
def verify_after(transaction, baseline):
observed = installed_snapshot()
expected = dict(baseline)
for package in transaction.packages:
expected[package.name + ':' + package.architecture] = {
'version': package.new_version, 'status': 'install ok installed'}
require(observed == expected, 'POSTCONDITION_OR_UNEXPECTED_CHANGE')
require(run_read(['/usr/bin/dpkg', '--audit'], limit=MAX_INPUT) == b'', 'DPKG_AUDIT')
evidence = {'snapshot_sha256': digest(canonical(observed)),
'reboot_required': Path('/run/reboot-required').exists(),
'packages': [{'name': p.name, 'architecture': p.architecture,
'version': p.new_version} for p in transaction.packages]}
if transaction.recipe_id in FIXTURE_RECIPES:
fixture_scope(transaction)
data = sealed_read(Path('/usr/share/rmm-mvp-test/version'), limit=32)
require(data == (transaction.packages[0].new_version + '\n').encode('ascii'),
'FIXTURE_PAYLOAD_POSTCONDITION')
evidence['fixture_payload_sha256'] = digest(data)
return evidence
def partial_installed_snapshot():
"""Readonly original-job verification, never a general planning baseline.
Only this exact script/trigger/dependency-free fixture may be unpacked.
Normal inventory/planning/execution keep rejecting inconsistent dpkg state.
"""
data = run_read(['/usr/bin/dpkg-query', '--show',
'--showformat=${Package}\t${Architecture}\t${Version}\t${Status}\n'],
limit=32 * MAX_INPUT)
snapshot = {}
for line in data.decode('utf-8', 'strict').splitlines():
fields = line.split('\t')
require(len(fields) == 4, 'DPKG_QUERY_FORMAT')
name, arch, version, status = fields
key = name + ':' + arch
require(key not in snapshot, 'DPKG_QUERY_DUPLICATE')
ordinary = status in ('install ok installed', 'deinstall ok config-files',
'purge ok not-installed', 'unknown ok not-installed')
partial = key == 'rmm-mvp-test:all' and version == '1.0' and status == 'install ok unpacked'
require(ordinary or partial, 'PARTIAL_OTHER_INCONSISTENT_PACKAGE')
snapshot[key] = {'version': version, 'status': status}
return snapshot
def verify_partial(request):
"""Recheck ONLY the fixed original job's postcondition, with no mutation.
RootHelper independently verifies its historical signed Request and the
unresolved consumed row first. These caller bindings are not authority to
execute: this mode has no APT/dpkg effect call or writable metadata path.
Current code/config/runtime need not equal the historical execution runtime;
original signed bytes and original apt.conf remain immutable evidence.
"""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
fields = ('transaction_sha256 job_payload_sha256 effect_armed_ledger_id grant_id '
'job_id attempt_id authorization_id plan_sha256')
exact(request, fields)
for key in ('transaction_sha256', 'job_payload_sha256', 'plan_sha256'):
token(request[key], HASH, 'PARTIAL_REQUEST_HASH')
token(request['effect_armed_ledger_id'], IDENT, 'PARTIAL_REQUEST_LEDGER')
for key in ('grant_id', 'job_id', 'attempt_id', 'authorization_id'):
value = request[key]
require(type(value) is str and str(uuid.UUID(value)) == value and
uuid.UUID(value).int != 0, 'PARTIAL_REQUEST_ID')
secure_path(BASE, directory=True, private=True)
secure_path(ACTIVE, directory=True, private=True)
names = ('context.json', 'signed-action.json', 'expectation.json', 'baseline.json',
'launch.json', 'native-prechecks.json', 'sandbox-ready.json',
'sandbox-result.json', 'hook-armed.json')
raw = {name: sealed_read(ACTIVE / name) for name in names}
ctx = VerifiedHelperContext.parse(json_bytes(raw['context.json']))
require(ctx.action == 'apt-native-acceptance' and ctx.execution_profile == 'dev-test' and
all(getattr(ctx, key) == request[key] for key in fields.split()), 'PARTIAL_CONTEXT_BINDING')
require(Path('/proc/sys/kernel/random/boot_id').read_text().strip() == ctx.boot_id,
'PARTIAL_BOOT_CHANGED')
require(digest(raw['signed-action.json']) == ctx.job_payload_sha256 and
digest(raw['expectation.json']) == ctx.transaction_sha256, 'PARTIAL_SIGNED_BYTES')
tx = ResolvedAptTransaction.parse(json_bytes(raw['expectation.json']))
fixture_scope(tx)
require(tx.recipe_id == 'rmm-apt-fixture-install-1.0', 'PARTIAL_FIXED_INSTALL_ONLY')
baseline = json_bytes(raw['baseline.json'])
require(type(baseline) is dict and raw['baseline.json'] == canonical(baseline) and
digest(raw['baseline.json']) == tx.baseline_sha256 and
'rmm-mvp-test:all' not in baseline, 'PARTIAL_ORIGINAL_BASELINE')
job = json_bytes(raw['signed-action.json'])
exact(job, 'schema_version tenant_id asset_id agent_id enrollment_generation assignment_version '
'job_id attempt_id action execution_identity not_before start_before max_runtime_seconds max_output_bytes')
require(type(job['schema_version']) is int and job['schema_version'] == 1 and
job['job_id'] == ctx.job_id and job['attempt_id'] == ctx.attempt_id and
job['execution_identity'] == 'root', 'PARTIAL_ORIGINAL_JOB')
outer = job['action']
exact(outer, 'action recipe_id recipe_version apt_manifest')
require(outer['action'] == 'apt_native_acceptance' and outer['recipe_id'] == tx.recipe_id and
outer['recipe_version'] == tx.recipe_version, 'PARTIAL_ORIGINAL_ACTION')
action = outer['apt_manifest']
exact(action, 'type schema_version action execution_profile transaction_sha256 '
'resolved_apt_transaction provider_sha256 hook_sha256 apt_config_sha256 '
'runtime_sha256 test_result_id transaction_bytes native_retry')
require(action['type'] == 'rmm.apt.helper-action' and type(action['schema_version']) is int and
action['schema_version'] == 3 and action['action'] == ctx.action and
action['execution_profile'] == ctx.execution_profile and
action['transaction_sha256'] == ctx.transaction_sha256 and
canonical(action['resolved_apt_transaction']) == canonical(json_bytes(raw['expectation.json'])) and
type(action['transaction_bytes']) is list and
all(type(n) is int and 0 <= n <= 255 for n in action['transaction_bytes']) and
bytes(action['transaction_bytes']) == raw['expectation.json'], 'PARTIAL_ORIGINAL_MANIFEST')
for key in ('provider_sha256', 'hook_sha256', 'apt_config_sha256', 'runtime_sha256'):
token(action[key], HASH, 'PARTIAL_ORIGINAL_RUNTIME_HASH')
token(action['test_result_id'], IDENT, 'PARTIAL_ORIGINAL_TEST_ID')
require(digest(sealed_read(ACTIVE / 'apt.conf')) == action['apt_config_sha256'],
'PARTIAL_ORIGINAL_CONFIG')
# This reuses only immutable historical binding checks, never the current
# executable gate or an acceptance publication. It also verifies both once
# markers and the original failed no-handoff history referenced by retry.
check_bootstrap_attempt(tx, ctx, action)
for prefix in ('bootstrap-attempt-', 'bootstrap-retry-'):
name = prefix + tx.recipe_id + '.json'
raw[name] = sealed_read(BASE / name)
for prefix in ('acceptance-', 'pending-acceptance-'):
require(not os.path.lexists(BASE / (prefix + tx.recipe_id + '.json')),
'PARTIAL_ACCEPTANCE_ALREADY_EXISTS')
require(canonical(json_bytes(raw['launch.json'])) == canonical({
'transaction_sha256': ctx.transaction_sha256,
'effect_armed_ledger_id': ctx.effect_armed_ledger_id}), 'PARTIAL_LAUNCH_BINDING')
prechecks = {'schema_version': 1, 'transaction_sha256': ctx.transaction_sha256,
'job_payload_sha256': ctx.job_payload_sha256, 'boot_id': ctx.boot_id,
'checks': {'namespaces_caps_nnp_seccomp': True, 'readonly_controlpaths': True,
'private_tmpfs_sockets': True,
'control_syscalls': {'invalid_reboot_magic': 'EPERM',
'invalid_kexec_load_flags': 'EPERM',
'invalid_kexec_file_fds_flags': 'EPERM'},
'frontend_lock': 'native-apt-check-conflict'}}
require(canonical(json_bytes(raw['native-prechecks.json'])) == canonical(prechecks) and
canonical(json_bytes(raw['sandbox-ready.json'])) == canonical({
'sandbox_version': 1, 'transaction_sha256': ctx.transaction_sha256}) and
canonical(json_bytes(raw['sandbox-result.json'])) == canonical({
'transaction_sha256': ctx.transaction_sha256, 'apt_exit_code': 0,
'reboot_required': False}), 'PARTIAL_NATIVE_COMPLETION_REQUIRED')
marker = json_bytes(raw['hook-armed.json'])
exact(marker, 'armed_at_ms effect_armed_ledger_id grant_id protocol_sha256 transaction_sha256')
require(marker['effect_armed_ledger_id'] == ctx.effect_armed_ledger_id and
marker['grant_id'] == ctx.grant_id and marker['transaction_sha256'] == ctx.transaction_sha256 and
type(marker['armed_at_ms']) is int and
ctx.not_before_ms <= marker['armed_at_ms'] < ctx.start_before_ms, 'PARTIAL_HOOK_BINDING')
token(marker['protocol_sha256'], HASH, 'PARTIAL_HOOK_PROTOCOL_HASH')
require(not observe_host_frontend_lock() and
not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')), 'FOREIGN_PACKAGE_LOCK')
fingerprint = status_fingerprint()
observed = partial_installed_snapshot()
expected = dict(baseline)
expected['rmm-mvp-test:all'] = {'version': '1.0', 'status': 'install ok unpacked'}
require(observed == expected, 'PARTIAL_UNEXPECTED_PACKAGE_CHANGE')
verify_archive(tx.packages[0])
payload = sealed_read(Path('/usr/share/rmm-mvp-test/version'), limit=32)
require(payload == b'1.0\n', 'PARTIAL_FIXTURE_PAYLOAD')
require(status_fingerprint() == fingerprint and partial_installed_snapshot() == observed and
not observe_host_frontend_lock() and
not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')), 'PARTIAL_STATE_CHANGED')
# Re-read the historical witnesses too: a stable live package projection
# cannot compensate for changed/tampered original evidence.
for name, data in raw.items():
path = ACTIVE / name if name in names else BASE / name
require(sealed_read(path) == data, 'PARTIAL_HISTORICAL_EVIDENCE_CHANGED')
proof = dict(schema_version=1, type='rmm.apt.partial-reconciliation', **request,
original_evidence_sha256=digest(canonical({name: digest(data) for name, data in raw.items()})),
original_baseline_sha256=tx.baseline_sha256,
observed_snapshot_sha256=digest(canonical(observed)), status_fingerprint=fingerprint,
fixture_payload_sha256=digest(payload), snapshot=observed,
checked_at_ms=time.time_ns() // 1000000, partial_effect=True,
postconditions_passed=False, reboot_required=False)
result = dict(effect_state='known_failed', code='APT_PARTIAL_UNCONFIGURED_VERIFIED', proof=proof)
require(len(canonical(result)) <= MAX_INPUT, 'PARTIAL_PROOF_LIMIT')
return result
def verify_configured_recovery(request):
"""Readonly classification of the ONE historical schema-4 attempt.
Rust independently checks the original signed Request, immutable ledger
unknown code and the closed original partial proof. No host-before sample
exists for this old runtime: even complete package effects NEVER become a
retroactive acceptance or success. No package mutation or metadata write.
"""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
fields = ('transaction_sha256 job_payload_sha256 effect_armed_ledger_id grant_id '
'job_id attempt_id authorization_id plan_sha256')
exact(request, fields)
for key in ('transaction_sha256', 'job_payload_sha256', 'plan_sha256'):
token(request[key], HASH, 'CONFIGURED_REQUEST_HASH')
token(request['effect_armed_ledger_id'], IDENT, 'CONFIGURED_REQUEST_LEDGER')
for key in ('grant_id', 'job_id', 'attempt_id', 'authorization_id'):
value = request[key]
require(type(value) is str and str(uuid.UUID(value)) == value and uuid.UUID(value).int != 0,
'CONFIGURED_REQUEST_ID')
pin = HISTORICAL_CONFIGURED_RECOVERY
require(request['grant_id'] == pin['grant_id'], 'CONFIGURED_HISTORICAL_GRANT_ONLY')
secure_path(BASE, directory=True, private=True)
secure_path(ACTIVE, directory=True, private=True)
names = ('context.json', 'signed-action.json', 'expectation.json', 'baseline.json',
'launch.json', 'native-prechecks.json', 'sandbox-ready.json', 'sandbox-result.json',
'hook-armed.json', 'partial-proof.json')
raw = {name: sealed_read(ACTIVE / name) for name in names}
for name in ('bootstrap-attempt-rmm-apt-fixture-install-1.0.json',
'bootstrap-retry-rmm-apt-fixture-install-1.0.json',
'recovery-attempt-' + pin['previous_grant_id'] + '.json'):
raw[name] = sealed_read(BASE / name)
require(not os.path.lexists(ACTIVE / 'host-reboot-before.json'),
'CONFIGURED_HISTORICAL_BEFORE_SAMPLE_ABSENT')
context = VerifiedHelperContext.parse(json_bytes(raw['context.json']))
require(context.action == 'apt-native-acceptance' and context.execution_profile == 'dev-test' and
all(getattr(context, key) == request[key] for key in fields.split()), 'CONFIGURED_CONTEXT_BINDING')
require(Path('/proc/sys/kernel/random/boot_id').read_text().strip() == context.boot_id,
'CONFIGURED_BOOT_CHANGED')
require(digest(raw['signed-action.json']) == context.job_payload_sha256 and
digest(raw['expectation.json']) == context.transaction_sha256, 'CONFIGURED_SIGNED_BYTES')
transaction = ResolvedAptTransaction.parse(json_bytes(raw['expectation.json']))
fixture_scope(transaction)
require(transaction.schema_version == 2 and transaction.operation == 'configure_only',
'CONFIGURED_FIXED_OPERATION')
baseline = json_bytes(raw['baseline.json'])
require(type(baseline) is dict and raw['baseline.json'] == canonical(baseline) and
digest(raw['baseline.json']) == transaction.baseline_sha256 and
baseline.get('rmm-mvp-test:all') == {'version': '1.0', 'status': 'install ok unpacked'},
'CONFIGURED_ORIGINAL_PARTIAL_BASELINE')
job = json_bytes(raw['signed-action.json'])
exact(job, 'schema_version tenant_id asset_id agent_id enrollment_generation assignment_version '
'job_id attempt_id action execution_identity not_before start_before max_runtime_seconds max_output_bytes')
require(type(job['schema_version']) is int and job['schema_version'] == 1 and
job['execution_identity'] == 'root' and job['job_id'] == context.job_id and
job['attempt_id'] == context.attempt_id, 'CONFIGURED_ORIGINAL_JOB')
outer = job['action']; exact(outer, 'action recipe_id recipe_version apt_manifest')
require(outer['action'] == 'apt_native_acceptance' and outer['recipe_id'] == transaction.recipe_id and
outer['recipe_version'] == transaction.recipe_version, 'CONFIGURED_ORIGINAL_ACTION')
action = outer['apt_manifest']
exact(action, 'type schema_version action execution_profile transaction_sha256 '
'resolved_apt_transaction provider_sha256 hook_sha256 apt_config_sha256 runtime_sha256 '
'test_result_id transaction_bytes native_recovery')
require(action['type'] == 'rmm.apt.helper-action' and type(action['schema_version']) is int and
action['schema_version'] == 4 and action['action'] == context.action and
action['execution_profile'] == context.execution_profile and
action['provider_sha256'] == pin['provider_sha256'] and
action['transaction_sha256'] == context.transaction_sha256 and
canonical(action['resolved_apt_transaction']) == canonical(json_bytes(raw['expectation.json'])) and
type(action['transaction_bytes']) is list and
all(type(value) is int and 0 <= value <= 255 for value in action['transaction_bytes']) and
bytes(action['transaction_bytes']) == raw['expectation.json'], 'CONFIGURED_ORIGINAL_MANIFEST')
for key in ('provider_sha256', 'hook_sha256', 'apt_config_sha256', 'runtime_sha256'):
token(action[key], HASH, 'CONFIGURED_ORIGINAL_RUNTIME_HASH')
token(action['test_result_id'], IDENT, 'CONFIGURED_ORIGINAL_TEST_ID')
require(digest(sealed_read(ACTIVE / 'apt.conf')) == action['apt_config_sha256'],
'CONFIGURED_ORIGINAL_APT_CONFIG')
reference = action['native_recovery']; validate_recovery_reference(reference)
require(reference['previous_grant_id'] == pin['previous_grant_id'] and
reference['partial_proof_sha256'] == pin['partial_proof_sha256'], 'CONFIGURED_ORIGINAL_PARTIAL_REFERENCE')
verify_recovery_reference(transaction, context, action)
check_bootstrap_attempt(transaction, context, action)
require(canonical(json_bytes(raw['launch.json'])) == canonical({
'transaction_sha256': context.transaction_sha256,
'effect_armed_ledger_id': context.effect_armed_ledger_id}) and
canonical(json_bytes(raw['sandbox-ready.json'])) == canonical({
'transaction_sha256': context.transaction_sha256, 'sandbox_version': 1}) and
canonical(json_bytes(raw['sandbox-result.json'])) == canonical({
'transaction_sha256': context.transaction_sha256, 'apt_exit_code': 0, 'reboot_required': False}),
'CONFIGURED_NATIVE_COMPLETION')
checks = {'schema_version': 1, 'transaction_sha256': context.transaction_sha256,
'job_payload_sha256': context.job_payload_sha256, 'boot_id': context.boot_id,
'checks': {'namespaces_caps_nnp_seccomp': True, 'readonly_controlpaths': True,
'private_tmpfs_sockets': True,
'control_syscalls': {'invalid_reboot_magic': 'EPERM',
'invalid_kexec_load_flags': 'EPERM',
'invalid_kexec_file_fds_flags': 'EPERM'},
'frontend_lock': 'native-apt-check-conflict'}}
require(canonical(json_bytes(raw['native-prechecks.json'])) == canonical(checks),
'CONFIGURED_HISTORICAL_PRECHECKS')
marker = json_bytes(raw['hook-armed.json'])
exact(marker, 'armed_at_ms effect_armed_ledger_id grant_id protocol_sha256 transaction_sha256')
require(marker['effect_armed_ledger_id'] == context.effect_armed_ledger_id and
marker['grant_id'] == context.grant_id and marker['transaction_sha256'] == context.transaction_sha256 and
type(marker['armed_at_ms']) is int and
context.not_before_ms <= marker['armed_at_ms'] < context.start_before_ms,
'CONFIGURED_HOOK_BINDING')
token(marker['protocol_sha256'], HASH, 'CONFIGURED_HOOK_PROTOCOL_HASH')
require(marker['protocol_sha256'] == digest(canonical([
Action('rmm-mvp-test', '1.0', 'all', 'none', '=', '1.0', 'all', 'none', '**CONFIGURE**').__dict__])),
'CONFIGURED_EXACT_CONFIGURE_PROTOCOL')
for name in ('acceptance-rmm-apt-fixture-install-1.0.json', 'pending-acceptance-rmm-apt-fixture-install-1.0.json',
'recovery-' + pin['previous_grant_id'] + '.json', 'pending-recovery-' + pin['previous_grant_id'] + '.json'):
require(not os.path.lexists(BASE / name), 'CONFIGURED_NO_RETROACTIVE_ACCEPTANCE')
require(not observe_host_frontend_lock() and not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')),
'FOREIGN_PACKAGE_LOCK')
fingerprint = status_fingerprint(); observed = installed_snapshot()
expected = dict(baseline); expected['rmm-mvp-test:all'] = {'version': '1.0', 'status': 'install ok installed'}
require(observed == expected, 'CONFIGURED_UNEXPECTED_PACKAGE_CHANGE')
verify_archive(transaction.packages[0])
require(run_read(['/usr/bin/dpkg', '--audit']) == b'', 'CONFIGURED_DPKG_AUDIT')
payload = sealed_read(Path('/usr/share/rmm-mvp-test/version'), limit=32)
require(payload == b'1.0\n', 'CONFIGURED_FIXTURE_PAYLOAD')
host_marker = sealed_read(Path('/run/reboot-required'), limit=4096)
require(Path('/run/reboot-required').exists(), 'CONFIGURED_ACTUAL_HOST_REBOOT_FLAG')
require(status_fingerprint() == fingerprint and installed_snapshot() == observed and
run_read(['/usr/bin/dpkg', '--audit']) == b'' and
sealed_read(Path('/usr/share/rmm-mvp-test/version'), limit=32) == payload and
sealed_read(Path('/run/reboot-required'), limit=4096) == host_marker and
Path('/run/reboot-required').exists() and
Path('/proc/sys/kernel/random/boot_id').read_text().strip() == context.boot_id and
not observe_host_frontend_lock() and not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')),
'CONFIGURED_CURRENT_STATE_CHANGED')
verify_recovery_reference(transaction, context, action)
for name, data in raw.items():
require(sealed_read(ACTIVE / name if name in names else BASE / name) == data,
'CONFIGURED_HISTORICAL_EVIDENCE_CHANGED')
require(not os.path.lexists(ACTIVE / 'host-reboot-before.json'),
'CONFIGURED_HISTORICAL_BEFORE_SAMPLE_ABSENT')
proof = dict(schema_version=1, type='rmm.apt.configured-recovery-reconciliation', **request,
original_evidence_sha256=digest(canonical({name: digest(data) for name, data in raw.items()})),
partial_proof_sha256=reference['partial_proof_sha256'],
original_baseline_sha256=transaction.baseline_sha256,
observed_snapshot_sha256=digest(canonical(observed)), status_fingerprint=fingerprint,
fixture_payload_sha256=digest(payload), snapshot=observed, checked_at_ms=time.time_ns() // 1000000,
effect_complete=True, partial_effect=False, postconditions_passed=False,
reboot_required=True, host_reboot_required=True, host_reboot_marker_sha256=digest(host_marker))
result = dict(effect_state='known_failed', code='APT_RECOVERY_CONFIGURED_ACCEPTANCE_REBOOT_FLAG_VERIFIED', proof=proof)
require(len(canonical(result)) <= MAX_INPUT, 'CONFIGURED_PROOF_LIMIT')
return result
def verified_no_change(transaction, baseline, context):
"""Independently verify the full selected postcondition, never run APT."""
fixture_scope(transaction) # Cannot promote unknown catalog recipes.
if not all(baseline.get(p.name + ':' + p.architecture) ==
{'version': p.new_version, 'status': 'install ok installed'}
for p in transaction.packages):
return None
require(not observe_host_frontend_lock() and
not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')), 'FOREIGN_PACKAGE_LOCK')
check_current_baseline(transaction, baseline)
evidence = verify_after(transaction, baseline)
# Repeat after the independent query/audit/payload check. Dirty/changed or
# unknown state is never a successful declarative observation.
check_current_baseline(transaction, baseline)
require(not observe_host_frontend_lock() and
not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')), 'FOREIGN_PACKAGE_LOCK')
context.check_deadline()
evidence.update(changed=False, already_desired=True, postcondition_already_met=True,
transaction_executed=False, effect_armed_ledger_id=context.effect_armed_ledger_id)
return evidence
def execute(request, native_acceptance=False):
"""Only called by the privileged helper AFTER its own durable grant consume."""
armed = False
launched = False
try:
require(os.geteuid() == 0, 'ROOT_REQUIRED')
exact(request, 'transaction_sha256 effect_armed_ledger_id')
secure_path(BASE, directory=True, private=True)
lockfd = os.open(BASE / 'provider.lock', os.O_CREAT | os.O_RDWR | os.O_NOFOLLOW, 0o600)
try:
fcntl.flock(lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
os.close(lockfd)
raise Veto('PROVIDER_BUSY') from None
try:
transaction, context, baseline = load_active()
armed = (ACTIVE / 'hook-armed.json').exists()
launched = (ACTIVE / 'launch.json').exists()
require(not armed and not launched, 'PRIOR_ATTEMPT_UNKNOWN')
require(request == {'transaction_sha256': context.transaction_sha256,
'effect_armed_ledger_id': context.effect_armed_ledger_id}, 'HELPER_BINDING')
action = load_signed_action(transaction, context)
runtime = runtime_identity()
check_native_gate(transaction, context, action, runtime, native_acceptance)
secure_path(CODE)
require(sealed_read(Path(HOOK)) == hook_script(), 'HOOK_CODE_BINDING')
require(sealed_read(ACTIVE / 'apt.conf') == apt_config(), 'UNTRUSTED_APT_CONFIG')
require(not list(secure_path(ACTIVE / 'empty', directory=True).iterdir()) and
not list(secure_path(ACTIVE / 'lists', directory=True).iterdir()), 'ISOLATED_APT_DIRS')
secure_path(ACTIVE / 'cache', directory=True, private=True)
for path in ('hook-armed.json', 'sandbox-ready.json', 'sandbox-result.json', 'native-prechecks.json',
'host-namespaces.json', 'host-reboot-before.json', 'launch.json'):
require(not (ACTIVE / path).exists(), 'PRIOR_ATTEMPT_UNKNOWN')
check_current_baseline(transaction, baseline)
for package in transaction.packages:
verify_archive(package)
# The exact bound unpacked fixture is the declared recovery input;
# ordinary jobs continue to require a clean audit before mutation.
if transaction.operation != 'configure_only':
require(run_read(['/usr/bin/dpkg', '--audit']) == b'', 'DPKG_AUDIT')
context.check_deadline()
if not native_acceptance:
evidence = verified_no_change(transaction, baseline, context)
if evidence is not None:
return {'effect_state': 'verified_no_change',
'code': 'POSTCONDITION_ALREADY_MET', 'evidence': evidence}
# Only the mutating path requires the recipe's historical version.
# No reinstall/downgrade/remove is introduced by the no-change path.
check_preconditions(transaction, baseline)
if native_acceptance:
# Original marker never changes. One separately signed retry
# may reference proven no-handoff history; it has its OWN
# create-once tombstone, never a reset of the original attempt.
path, binding = bootstrap_binding(transaction, context, action)
durable_once(path, binding)
capture_host_reboot_before(context)
durable_once(ACTIVE / 'host-namespaces.json', {
name: os.readlink('/proc/self/ns/' + name) for name in ('pid', 'mnt', 'net')})
durable_once(ACTIVE / 'launch.json', {'transaction_sha256': context.transaction_sha256,
'effect_armed_ledger_id': context.effect_armed_ledger_id})
launched = True
proc = subprocess.Popen(['/usr/bin/unshare', '--mount', '--pid', '--fork', '--mount-proc',
'--net', '/usr/bin/python3', '-I', str(CODE), 'sandbox-worker'],
env=ENV, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
code = proc.wait()
armed = (ACTIVE / 'hook-armed.json').exists()
if not armed:
# Trusted fixed config makes a missing hook a veto, not an
# after-the-fact substitute for pre-dpkg validation.
current = partial_installed_snapshot() if transaction.operation == 'configure_only' else installed_snapshot()
require(current == baseline, 'MISSING_HOOK_WITH_CHANGE')
return {'effect_state': 'known_failed', 'code': 'HOOK_NOT_HANDED_OFF',
'evidence': {'test_acceptance': True, 'noProductionEvidence': True}
if native_acceptance else {}}
marker = json_bytes(sealed_read(ACTIVE / 'hook-armed.json'))
require(marker.get('transaction_sha256') == context.transaction_sha256 and
marker.get('effect_armed_ledger_id') == context.effect_armed_ledger_id and
marker.get('grant_id') == context.grant_id, 'HOOK_MARKER_BINDING')
evidence = verify_after(transaction, baseline)
require(code == 0, 'APT_EXIT_AFTER_POSSIBLE_EFFECT')
child_result = json_bytes(sealed_read(ACTIVE / 'sandbox-result.json'))
exact(child_result, 'transaction_sha256 apt_exit_code reboot_required')
require(child_result['transaction_sha256'] == context.transaction_sha256 and
type(child_result['apt_exit_code']) is int and child_result['apt_exit_code'] == 0 and
type(child_result['reboot_required']) is bool, 'SANDBOX_RESULT_BINDING')
evidence['reboot_required'] |= child_result['reboot_required']
evidence['effect_armed_ledger_id'] = context.effect_armed_ledger_id
evidence.update(verify_host_reboot_after(context, evidence))
if native_acceptance:
evidence.update(complete_acceptance(transaction, context, action, runtime, evidence))
# This recipe has version/consistency postconditions, not post-boot
# conditions. Reboot-needed is evidence; never invoke a reboot.
return {'effect_state': 'verified', 'code': 'POSTCONDITIONS_VERIFIED', 'evidence': evidence}
finally:
os.close(lockfd)
except (Veto, OSError, ValueError, UnicodeError, subprocess.SubprocessError) as error:
return {'effect_state': 'unknown' if armed or launched else 'known_failed',
'code': str(error) if isinstance(error, Veto) else 'PROVIDER_IO_FAILURE',
'evidence': {'test_acceptance': True, 'noProductionEvidence': True}
if native_acceptance else {}}
def hook_script():
return b'#!/bin/sh\nexec /usr/bin/python3 -I /usr/lib/rmm-apt-transaction/apt_transaction.py hook\n'
def provision_fixture_store():
"""Explicit administrator artifact preparation, never package installation.
Run before planning/final grants. Only code-pinned bytes can be imported;
this creates neither authorization nor native-acceptance evidence.
"""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
secure_path(BASE, directory=True, private=True)
secure_path(BASE / 'archives', directory=True, private=True)
secure_path(BASE / 'baselines', directory=True, private=True)
records = []
for version in ('1.0', '1.1'):
data = fixture_archive(version)
sha = FIXTURE_SHA256[version]
require(digest(data) == sha, 'FIXTURE_PINNED_BYTES')
path = BASE / 'archives' / (sha + '.deb')
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'wb') as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
directory = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY)
try:
os.fsync(directory)
finally:
os.close(directory)
durable_once(BASE / ('prefetch-' + sha + '.json'), {
'schema_version': 1, 'sha256': sha, 'size': len(data),
'sealed_at_ms': time.time_ns() // 1000000})
records.append({'version': version, 'sha256': sha, 'size': len(data)})
return {'fixtures': records, **prepare_baseline_store()}
def prepare_baseline_store():
"""Pre-grant planning snapshot; no artifact overwrite or job authority."""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
secure_path(BASE, directory=True, private=True)
secure_path(BASE / 'baselines', directory=True, private=True)
baseline = canonical(installed_snapshot())
baseline_sha = digest(baseline)
path = BASE / 'baselines' / (baseline_sha + '.json')
if path.exists():
require(sealed_read(path) == baseline, 'SEALED_BASELINE_MISMATCH')
else:
# durable_once uses the same canonical codec as this computed hash.
durable_once(path, json_bytes(baseline))
return {'baseline_sha256': baseline_sha,
'status_fingerprint': status_fingerprint(), 'authorization_created': False,
'native_acceptance_created': False}
def recovery_planning(request):
"""Fresh passive projection of one ledger-verified, closed partial failure.
Rust verifies the signed original request, terminal failure and immutable
SQLite proof before invoking this fixed mode. No job or execution is made.
"""
exact(request, 'native_recovery proof')
ref, proof = request['native_recovery'], request['proof']
validate_recovery_reference(ref)
validate_partial_proof(proof)
require(digest(canonical(proof)) == ref['partial_proof_sha256'] and
proof['grant_id'] == ref['previous_grant_id'] and
proof['attempt_id'] == ref['previous_attempt_id'], 'RECOVERY_PLANNING_PROOF_BINDING')
fields = ('transaction_sha256 job_payload_sha256 effect_armed_ledger_id grant_id '
'job_id attempt_id authorization_id plan_sha256')
current = verify_partial({key: proof[key] for key in fields.split()})['proof']
require({key: value for key, value in current.items() if key != 'checked_at_ms'} ==
{key: value for key, value in proof.items() if key != 'checked_at_ms'},
'RECOVERY_PLANNING_STATE_CHANGED')
require(not os.path.lexists(BASE / ('recovery-attempt-' + ref['previous_grant_id'] + '.json')) and
not os.path.lexists(BASE / ('recovery-' + ref['previous_grant_id'] + '.json')),
'RECOVERY_ALREADY_ATTEMPTED')
result = _planning_status(proof)
result['native_recovery'] = ref
return result
def planning_status():
return _planning_status()
def _planning_status(recovery_proof=None):
"""Fixed passive fixture projection; complete dpkg state remains root-private.
Only content-addressed, fsynced helper metadata may be created here. No
artifact download, acceptance, package manager write, grant or job exists.
The caller bounds this entire metadata subprocess, including runtime reads.
"""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
secure_path(BASE, directory=True, private=True)
secure_path(BASE / 'baselines', directory=True, private=True)
require(not observe_host_frontend_lock() and
not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')), 'FOREIGN_PACKAGE_LOCK')
fingerprint = status_fingerprint() # Vetoes dirty updates/pending triggers.
snapshot_reader = partial_installed_snapshot if recovery_proof is not None else installed_snapshot
snapshot = snapshot_reader()
host_reboot_required = Path('/run/reboot-required').exists()
if recovery_proof is not None:
require(snapshot == recovery_proof['snapshot'] and fingerprint == recovery_proof['status_fingerprint'],
'RECOVERY_PLANNING_STATE_CHANGED')
runtime = runtime_identity()
prefetch = {}
for version in ('1.0', '1.1'):
sha = FIXTURE_SHA256[version]
path = BASE / 'archives' / (sha + '.deb')
data = sealed_read(path, 20672)
archive_metadata(path.lstat(), 20672)
require(len(data) == 20672 and digest(data) == sha, 'PREFETCH_ARCHIVE_HASH')
receipt = json_bytes(sealed_read(BASE / ('prefetch-' + sha + '.json')))
exact(receipt, 'schema_version sha256 size sealed_at_ms')
require(type(receipt['schema_version']) is int and receipt['schema_version'] == 1 and
receipt['sha256'] == sha and type(receipt['size']) is int and receipt['size'] == len(data) and
type(receipt['sealed_at_ms']) is int and 0 < receipt['sealed_at_ms'] <= time.time_ns() // 1000000,
'PREFETCH_RECEIPT')
prefetch[sha] = receipt
require(status_fingerprint() == fingerprint and snapshot_reader() == snapshot and
Path('/run/reboot-required').exists() == host_reboot_required,
'PLANNING_STATE_CHANGED')
require(not observe_host_frontend_lock() and
not observe_host_frontend_lock(Path('/var/lib/dpkg/lock')), 'FOREIGN_PACKAGE_LOCK')
baseline = canonical(snapshot)
baseline_sha = digest(baseline)
path = BASE / 'baselines' / (baseline_sha + '.json')
if path.exists():
require(sealed_read(path, 32 * MAX_INPUT) == baseline, 'SEALED_BASELINE_MISMATCH')
# A previous bounded metadata process may have died after writing its
# full bytes but before fsync. Re-establish durability before calling an
# existing content-addressed file a seal; never rewrite/repair its data.
fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
try:
os.fsync(fd)
finally:
os.close(fd)
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_CLOEXEC)
try:
os.fsync(fd)
finally:
os.close(fd)
else:
durable_once(path, snapshot)
# Do not publish a stale baseline if state changed during fsync.
require(status_fingerprint() == fingerprint and snapshot_reader() == snapshot and
Path('/run/reboot-required').exists() == host_reboot_required,
'PLANNING_STATE_CHANGED')
return {'observed_at': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
'host_reboot_required': host_reboot_required,
'fixture_package': snapshot.get('rmm-mvp-test:all'),
'baseline_sha256': baseline_sha, 'sealed_baseline_sha256': baseline_sha,
'status_fingerprint': fingerprint, 'dpkg_updates_empty': True, 'pending_triggers_empty': True,
'runtime': runtime, 'runtime_sha256': digest(canonical(runtime)),
'provider_sha256': digest(sealed_read(CODE)), 'hook_sha256': digest(sealed_read(Path(HOOK))),
'apt_config_sha256': digest(apt_config()), 'prefetch': prefetch}
def observe_host_frontend_lock(path=Path('/var/lib/dpkg/lock-frontend')):
"""F_GETLK on O_RDONLY only. Never F_SETLK/flock/lockf a host probe fd."""
path = secure_path(path)
class Lock(ctypes.Structure):
_fields_ = [('kind', ctypes.c_short), ('whence', ctypes.c_short),
('start', ctypes.c_long), ('length', ctypes.c_long), ('pid', ctypes.c_int)]
lock = Lock(fcntl.F_WRLCK, os.SEEK_SET, 0, 0, 0)
fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
try:
answer = fcntl.fcntl(fd, fcntl.F_GETLK, bytes(lock))
finally:
os.close(fd)
return Lock.from_buffer_copy(answer).kind != fcntl.F_UNLCK
def probe_config(workspace):
# All substitutions are fixed/generated root-private workspace paths, not
# caller arguments. No sources, hooks or installer command is used here.
text = apt_config().decode('ascii').replace(str(ACTIVE), str(workspace))
text = text.replace(str(BASE / 'log'), str(workspace / 'log'))
text = text.replace(str(BASE / 'state'), str(workspace / 'state'))
return ('\n'.join(line for line in text.splitlines()
if not line.startswith(('DPkg::Pre-Install-Pkgs', 'DPkg::Tools::Options')))
+ '\n').encode('ascii')
def probe_worker():
request = json_bytes(sys.stdin.buffer.read(MAX_INPUT + 1))
exact(request, 'probe_id')
probe_id = str(uuid.UUID(request['probe_id']))
require(probe_id == request['probe_id'], 'PROBE_ID')
workspace = BASE / 'probes' / probe_id
secure_path(workspace, directory=True, private=True)
require(sealed_read(workspace / 'apt.conf') == probe_config(workspace), 'PROBE_CONFIG')
setup_sandbox(workspace, workspace / 'dpkg')
checks = sandbox_checks(workspace)
# The negative lock test above and this positive check see ONLY copied dpkg
# state, bound over /var/lib/dpkg in the new mount namespace.
run_read(['/usr/bin/apt-get', '-o', 'DPkg::Lock::Timeout=0', 'check'],
env={**ENV, 'APT_CONFIG': str(workspace / 'apt.conf')})
durable_once(workspace / 'probe-result.json', {
'probe_id': probe_id, 'checks': checks, 'isolated_dpkg_check': True,
'namespaces': {name: os.readlink('/proc/self/ns/' + name) for name in ('pid', 'mnt', 'net')}})
def validate_probe_result(result, probe_id, parents):
exact(result, 'probe_id checks isolated_dpkg_check namespaces')
expected = {'namespaces_caps_nnp_seccomp': True, 'readonly_controlpaths': True,
'private_tmpfs_sockets': True,
'control_syscalls': {'invalid_reboot_magic': 'EPERM',
'invalid_kexec_load_flags': 'EPERM',
'invalid_kexec_file_fds_flags': 'EPERM'},
'frontend_lock': 'native-apt-check-conflict'}
require(result['probe_id'] == probe_id and result['isolated_dpkg_check'] is True and
result['checks'] == expected, 'NATIVE_PROBE_RESULT')
for key in ('namespaces_caps_nnp_seccomp', 'readonly_controlpaths', 'private_tmpfs_sockets'):
require(result['checks'][key] is True, 'NATIVE_PROBE_BOOLEAN')
exact(result['namespaces'], 'pid mnt net')
exact(parents, 'pid mnt net')
for name in ('pid', 'mnt', 'net'):
token(result['namespaces'][name], re.compile(name + r':\[[0-9]+\]\Z'), 'PROBE_NAMESPACE_ID')
token(parents[name], re.compile(name + r':\[[0-9]+\]\Z'), 'PROBE_PARENT_NAMESPACE_ID')
require(result['namespaces'][name] != parents[name], 'PROBE_NAMESPACE_NOT_PRIVATE')
def probe_native():
"""Root ADMIN readiness only: no grant, packages, receipt or effect marker."""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
verify_controller_profile()
secure_path(BASE, directory=True, private=True)
runtime = runtime_identity()
probes = BASE / 'probes'
secure_path(probes, directory=True, private=True)
probe_id = str(uuid.uuid4())
workspace = probes / probe_id
workspace.mkdir(mode=0o700)
for name in ('dpkg', 'empty', 'lists', 'cache', 'log', 'state'):
(workspace / name).mkdir(mode=0o700)
for name in ('updates', 'triggers'):
(workspace / 'dpkg' / name).mkdir(mode=0o700)
status = sealed_read(Path('/var/lib/dpkg/status'), 64 * MAX_INPUT)
# Exclusive writes into a generated directory. Never open host status or
# lock for writing, never invoke an install command for a readiness probe.
for name, data in [('status', status), ('lock', b''), ('lock-frontend', b'')]:
path = workspace / 'dpkg' / name
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'wb') as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
(workspace / 'dpkg' / 'triggers' / 'Unincorp').touch(mode=0o600, exist_ok=False)
(workspace / 'state' / 'extended_states').touch(mode=0o600, exist_ok=False)
(workspace / 'apt.conf').write_bytes(probe_config(workspace))
(workspace / 'apt.conf').chmod(0o600)
durable_once(workspace / 'host-namespaces.json', {
name: os.readlink('/proc/self/ns/' + name) for name in ('pid', 'mnt', 'net')})
foreign_lock = observe_host_frontend_lock()
# Only the read-only, copied-database probe can be timeout-aborted. The
# mutation driver's no-kill semantics remain unchanged.
completed = subprocess.run(['/usr/bin/unshare', '--mount', '--pid', '--fork', '--mount-proc',
'--net', '/usr/bin/python3', '-I', str(CODE), 'probe-worker'],
input=canonical({'probe_id': probe_id}), env=ENV,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=90)
require(completed.returncode == 0, 'NATIVE_PROBE_FAILED')
result = json_bytes(sealed_read(workspace / 'probe-result.json'))
parents = json_bytes(sealed_read(workspace / 'host-namespaces.json'))
validate_probe_result(result, probe_id, parents)
require(sealed_read(Path('/var/lib/dpkg/status'), 64 * MAX_INPUT) == status,
'HOST_STATUS_CHANGED_DURING_PROBE')
require(runtime_identity() == runtime, 'PROBE_RUNTIME_CHANGED')
report = {'schema_version': 1, 'profile': 'apt_only', 'probe_id': probe_id,
'runtime': runtime, 'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(),
'host_status_sha256': digest(status), 'foreign_frontend_lock': foreign_lock,
'result': result, 'parent_namespaces': parents,
'readiness_only': True, 'native_acceptance': False}
durable_once(workspace / 'readiness-report.json', report)
target = BASE / 'native-readiness.json'
if target.exists():
secure_path(target, private=True)
os.replace(workspace / 'readiness-report.json', target)
fd = os.open(BASE, os.O_RDONLY | os.O_DIRECTORY)
try:
os.fsync(fd)
finally:
os.close(fd)
return {'readiness_report_sha256': digest(canonical(report)), 'readiness_only': True,
'native_acceptance': False, 'probe_id': probe_id}
def verify_controller_profile():
"""The real service profile, not a root shell/JSON assertion, is required."""
require(os.geteuid() == 0, 'ROOT_REQUIRED')
status = dict(line.split(':', 1) for line in Path('/proc/self/status').read_text().splitlines()
if ':' in line)
mask = sum(1 << bit for bit in (0, 1, 3, 4, 6, 7, 8, 31, 21, 27))
require(status.get('NoNewPrivs', '').strip() == '1', 'APT_CONTROLLER_NNP')
require(status.get('Seccomp', '').strip() == '2', 'APT_CONTROLLER_OUTER_FILTER')
for key in ('CapEff', 'CapPrm', 'CapBnd'):
require(int(status[key].strip(), 16) == mask, 'APT_CONTROLLER_CAPABILITIES')
require(int(status['CapInh'].strip(), 16) == 0 and int(status['CapAmb'].strip(), 16) == 0,
'APT_CONTROLLER_INHERITED_CAPABILITIES')
require(any(line.rsplit(':', 1)[-1].rstrip('/').endswith('/rmm-apt-helper.service')
for line in Path('/proc/self/cgroup').read_text().splitlines()), 'APT_CONTROLLER_UNIT')
for path in ('/usr', '/etc', '/var'):
require(bool(os.statvfs(path).f_flag & os.ST_RDONLY), 'APT_CONTROLLER_READONLY_SYSTEM')
writable = ('/var/lib/dpkg', '/var/lib/rmm-helper', str(BASE), '/usr/share/rmm-mvp-test')
for path in writable:
require(not os.statvfs(path).f_flag & os.ST_RDONLY, 'APT_CONTROLLER_WRITE_TARGET_REQUIRED')
# Reject broad or unexpected writable submounts even when parent /usr/etc/
# var remains readonly (e.g. an unreviewed systemd drop-in adding /usr/share).
for line in Path('/proc/self/mountinfo').read_text().splitlines():
fields = line.split()
require(len(fields) >= 7, 'APT_CONTROLLER_MOUNTINFO')
target = fields[4]
if 'rw' in fields[5].split(',') and target.startswith(('/usr/', '/etc/', '/var/')):
require(any(target == path or target.startswith(path + '/') for path in (*writable, '/var/tmp')),
'APT_CONTROLLER_EXTRA_WRITE_MOUNT')
def readiness_status():
require(os.geteuid() == 0, 'ROOT_REQUIRED')
runtime = runtime_identity()
report = json_bytes(sealed_read(BASE / 'native-readiness.json'))
exact(report, 'schema_version profile probe_id runtime boot_id host_status_sha256 '
'foreign_frontend_lock result parent_namespaces readiness_only native_acceptance')
require(type(report['schema_version']) is int and str(uuid.UUID(report['probe_id'])) == report['probe_id'],
'READINESS_SCHEMA_OR_ID')
require(report.get('schema_version') == 1 and report.get('profile') == 'apt_only' and
report.get('readiness_only') is True and report.get('native_acceptance') is False and
report.get('runtime') == runtime and report.get('boot_id') ==
Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'READINESS_STALE_OR_UNVERIFIED')
validate_probe_result(report['result'], report['probe_id'], report['parent_namespaces'])
accepted = []
for recipe, (old, version) in FIXTURE_RECIPES.items():
path = BASE / ('acceptance-' + recipe + '.json')
if not path.exists():
continue
proof = json_bytes(sealed_read(path))
expected_package = {'name': 'rmm-mvp-test', 'architecture': 'all', 'old_version': old,
'new_version': version, 'origin': 'rmm-test', 'sha256': FIXTURE_SHA256[version],
'size': len(fixture_archive(version)),
'archive_path': str(BASE / 'archives' / (FIXTURE_SHA256[version] + '.deb'))}
validate_acceptance_record(proof, {'recipe_id': recipe, 'recipe_version': '1',
'packages': [expected_package]}, runtime)
accepted.append(recipe)
return {'schema_version': 1, 'fixture_acceptance_ready': True, 'accepted_recipes': accepted,
'runtime_sha256': digest(canonical(runtime)),
'readiness_report_sha256': digest(canonical(report))}
def main():
require(len(sys.argv) == 2, 'CLI_MODE')
mode = sys.argv[1]
if mode in ('execute', 'native-acceptance'):
result = execute(json_bytes(sys.stdin.buffer.read(MAX_INPUT + 1)),
native_acceptance=mode == 'native-acceptance')
print(canonical(result).decode('ascii'))
return 0
if mode == 'hook':
hook()
elif mode == 'sandbox-worker':
sandbox_worker()
elif mode == 'print-config':
sys.stdout.buffer.write(apt_config())
elif mode == 'inspect-runtime':
require(os.geteuid() == 0, 'ROOT_REQUIRED')
sys.stdout.buffer.write(canonical(runtime_identity()) + b'\n')
elif mode == 'provision-fixture-store':
sys.stdout.buffer.write(canonical(provision_fixture_store()) + b'\n')
elif mode == 'prepare-baseline':
sys.stdout.buffer.write(canonical(prepare_baseline_store()) + b'\n')
elif mode == 'planning-status':
sys.stdout.buffer.write(canonical(planning_status()) + b'\n')
elif mode == 'recovery-planning':
sys.stdout.buffer.write(canonical(recovery_planning(json_bytes(sys.stdin.buffer.read(MAX_INPUT + 1)))) + b'\n')
elif mode == 'probe-native':
sys.stdout.buffer.write(canonical(probe_native()) + b'\n')
elif mode == 'probe-worker':
probe_worker()
elif mode == 'readiness-status':
sys.stdout.buffer.write(canonical(readiness_status()) + b'\n')
elif mode == 'verify-partial':
sys.stdout.buffer.write(canonical(verify_partial(json_bytes(sys.stdin.buffer.read(MAX_INPUT + 1)))) + b'\n')
elif mode == 'verify-configured-recovery':
sys.stdout.buffer.write(canonical(verify_configured_recovery(json_bytes(sys.stdin.buffer.read(MAX_INPUT + 1)))) + b'\n')
elif mode == 'verify-controller':
verify_controller_profile()
elif mode == 'inspect-sandbox':
inspect_sandbox()
else:
raise Veto('CLI_MODE')
return 0
if __name__ == '__main__':
try:
sys.exit(main())
except (Veto, OSError, ValueError, UnicodeError, subprocess.SubprocessError):
# Hook exits nonzero; no secret/raw protocol/child diagnostics escape.
print('APT_TRANSACTION_VETO', file=sys.stderr)
sys.exit(100)