1709 lines
87 KiB
Python
1709 lines
87 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'}
|
|
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):
|
|
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 obj['old_version'] is not None:
|
|
token(obj['old_version'], VERSION, 'VERSION')
|
|
# Debian ordering, not lexical/semver ordering. Read-only argv.
|
|
require(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, ...]
|
|
|
|
@classmethod
|
|
def parse(cls, obj):
|
|
exact(obj, 'schema_version recipe_id recipe_version platform resolver_config_version '
|
|
'no_reboot status_fingerprint baseline_sha256 packages')
|
|
require(type(obj['schema_version']) is int and obj['schema_version'] == 1, 'SCHEMA_VERSION')
|
|
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) for p in obj['packages'])
|
|
require(len({(p.name, p.architecture) for p in packages}) == len(packages), 'DUPLICATE_PACKAGE')
|
|
return cls(**{**obj, 'packages': packages})
|
|
|
|
|
|
@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]
|
|
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 ''))
|
|
require(action['type'] == 'rmm.apt.helper-action' and
|
|
type(version) is int and version in (2, 3),
|
|
'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')
|
|
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:
|
|
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')
|
|
require(type(proof['schema_version']) is int and proof['schema_version'] == 2 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'):
|
|
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')
|
|
|
|
|
|
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 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_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()
|
|
return {'schema_version': 1, 'transaction_sha256': context.transaction_sha256,
|
|
'job_payload_sha256': context.job_payload_sha256, 'boot_id': context.boot_id,
|
|
'checks': checks}
|
|
|
|
|
|
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'}
|
|
require(prechecks == {'schema_version': 1, 'transaction_sha256': context.transaction_sha256,
|
|
'job_payload_sha256': context.job_payload_sha256,
|
|
'boot_id': context.boot_id, 'checks': expected_checks}, 'NATIVE_PRECHECKS_REQUIRED')
|
|
require(not evidence['reboot_required'], 'FIXTURE_UNEXPECTED_REBOOT_REQUIRED')
|
|
require(runtime_identity() == runtime, 'RUNTIME_CHANGED_DURING_ACCEPTANCE')
|
|
proof = {'schema_version': 2, '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)),
|
|
'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.
|
|
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.
|
|
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):
|
|
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')
|
|
require(installed_snapshot() == baseline, 'STATUS_BASELINE_CHANGED')
|
|
|
|
|
|
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 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):
|
|
# 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 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', 'launch.json'):
|
|
require(not (ACTIVE / path).exists(), 'PRIOR_ATTEMPT_UNKNOWN')
|
|
check_current_baseline(transaction, baseline)
|
|
for package in transaction.packages:
|
|
verify_archive(package)
|
|
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)
|
|
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.
|
|
require(installed_snapshot() == 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
|
|
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 planning_status():
|
|
"""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 = installed_snapshot()
|
|
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 installed_snapshot() == snapshot,
|
|
'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 installed_snapshot() == snapshot,
|
|
'PLANNING_STATE_CHANGED')
|
|
return {'observed_at': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
|
|
'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 == '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-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)
|