Provision explicit MCP root planning right without approval authority
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -0,0 +1,552 @@
|
||||
#!/usr/bin/env python3
|
||||
"""One short, exact development Root-policy scope; never a job/approval tool.
|
||||
|
||||
prepare-local reads a Root-accepted native attestation, no target. open/read/close
|
||||
use only the existing server SSH transport. A SEPARATE explicit provision case
|
||||
can add only root:execute to one existing development automation actor. Scope
|
||||
open never provisions. No VM, token/session, service or approval operation.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import datetime as dt
|
||||
import hashlib
|
||||
import inspect
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import stat
|
||||
import uuid
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
STATE = ROOT / 'devstate/script-console-policy-scope'
|
||||
TENANT = '11111111-1111-4111-8111-111111111111'
|
||||
SIMULATED = 'simulated-testprincipal-a'
|
||||
OLD_POLICY_SHA = 'cf15cbb68b590475df6def28e7dcffb7d88e0ca2d2555a06174fb654eeff05f4'
|
||||
INSTALL_CASE = '2e27c312-58cc-444d-92a6-863a11ac6ffd'
|
||||
AUTOMATION_RIGHTS = ['inventory:read', 'logs:read', 'operations:read', 'operations:plan',
|
||||
'operations:submit', 'jobs:cancel', 'scripts:execute']
|
||||
SUPPORT = {
|
||||
'deploy/remote_client_bootstrap.py': '785c43a51dfe3f93e39798dbd7611c353752ae2fc64b22e41ba168e221620d30',
|
||||
'deploy/vm_access_check.py': '5c8107ea9151a9f498b2530cdc61c1a7a6d745aff853a9b05710f3395838c0dd',
|
||||
}
|
||||
|
||||
|
||||
def require(value, code):
|
||||
if not value:
|
||||
raise RuntimeError(code)
|
||||
|
||||
|
||||
def sha(raw):
|
||||
return hashlib.sha256(raw).hexdigest()
|
||||
|
||||
|
||||
def encode(value):
|
||||
return json.dumps(value, sort_keys=True, separators=(',', ':')).encode()
|
||||
|
||||
|
||||
def digest(value):
|
||||
return isinstance(value, str) and re.fullmatch('[a-f0-9]{64}', value) is not None
|
||||
|
||||
|
||||
def protected(path, limit=8 * 1024 * 1024):
|
||||
value = path.lstat()
|
||||
require(not path.is_symlink() and stat.S_ISREG(value.st_mode) and value.st_uid == os.getuid()
|
||||
and stat.S_IMODE(value.st_mode) == 0o600 and value.st_nlink == 1 and value.st_size <= limit,
|
||||
'private owned local evidence')
|
||||
return path.read_bytes()
|
||||
|
||||
|
||||
def private_directory(path):
|
||||
value = path.lstat()
|
||||
require(not path.is_symlink() and stat.S_ISDIR(value.st_mode) and value.st_uid == os.getuid()
|
||||
and stat.S_IMODE(value.st_mode) == 0o700, 'private owned local case directory')
|
||||
|
||||
|
||||
def create(path, raw):
|
||||
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
|
||||
with os.fdopen(fd, 'wb') as out:
|
||||
out.write(raw); out.flush(); os.fsync(out.fileno())
|
||||
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
|
||||
try:
|
||||
os.fsync(fd)
|
||||
finally:
|
||||
os.close(fd)
|
||||
|
||||
|
||||
def accepted_native(path, expected):
|
||||
"""Accepted digest is an explicit Root-reviewed evidence input, not a grant."""
|
||||
raw = protected(path)
|
||||
require(digest(expected) and sha(raw) == expected, 'explicit accepted attestation bytes')
|
||||
attested = json.loads(raw)
|
||||
require(attested['case_id'] == INSTALL_CASE and attested['verified_preservation'] is True
|
||||
and attested['verified_normal_signed_sync'] is True and attested['stored_heartbeat_advances'] == 2
|
||||
and attested['specific_inventory_queue_convergence'] is True and attested['tenant_rls_denial'] is True
|
||||
and attested['read_only'] is True and attested['rmm_jobs'] is False and attested['approvals'] is False
|
||||
and attested['full_job_accepted'] is False and len(attested['sample_sha256']) == 3,
|
||||
'accepted three-sample preservation and normal Sync qualification')
|
||||
intent = json.loads(protected(path.parent / 'intent.json'))
|
||||
require(intent['type'] == 'rmm.script-console.read-only-post-attestation-v1'
|
||||
and intent['case_id'] == INSTALL_CASE and intent['runner_sha256'] == attested['runner_sha256'],
|
||||
'same attested observation and installation provenance')
|
||||
samples = []
|
||||
for number, expected_sample in enumerate(attested['sample_sha256']):
|
||||
sample_raw = protected(path.parent / ('sample-' + str(number) + '.json'))
|
||||
require(digest(expected_sample) and sha(sample_raw) == expected_sample, 'original accepted sample bytes')
|
||||
samples.append(json.loads(sample_raw))
|
||||
pin = samples[-1]['vm']['full_pin']
|
||||
require(pin['schema_version'] == 2 and pin['profile'] == 'full_maintenance_v1'
|
||||
and digest(pin['policy_sha256']) and digest(pin['helper_binary_sha256']), 'actual native Full policy/code pin')
|
||||
identity = pin['identity']
|
||||
target = {key: identity[key] for key in ('tenant_id', 'asset_id', 'agent_id', 'enrollment_generation', 'assignment_version')}
|
||||
require(target['tenant_id'] == TENANT and all(str(uuid.UUID(target[key])) == target[key]
|
||||
for key in ('tenant_id', 'asset_id', 'agent_id'))
|
||||
and all(type(target[key]) is int and target[key] > 0 for key in ('enrollment_generation', 'assignment_version')),
|
||||
'exact qualified cloud target/generations')
|
||||
for sample in samples:
|
||||
native = sample['vm']; stored = sample['server']; current = stored['installation']
|
||||
require(native['case_id'] == INSTALL_CASE and native['full_pin'] == pin
|
||||
and native['verified_state_preservation'] is True and native['root_unresolved'] == 0
|
||||
and native['read_only'] is True and native['product_state_writes'] is False
|
||||
and native['rmm_jobs'] is False and native['approvals'] is False
|
||||
and native['processes']['full']['sha256'] == pin['helper_binary_sha256']
|
||||
and native['processes']['full']['uids'] == ['0'] * 4
|
||||
and stored['central_root_scope_closed'] is True and current['sync_ready'] is True
|
||||
and current['helper_sync_ready'] is True and current['revoked_at'] is None,
|
||||
'accepted actual native root process and closed stored server state')
|
||||
needed = ('rmm.sync.v1', 'helper.root.v1', 'root:run_script', 'run_script', 'script.full_maintenance/1',
|
||||
'helper.policy.sha256:' + pin['policy_sha256'], 'helper.binary.sha256:' + pin['helper_binary_sha256'])
|
||||
require(all(cap in current['capabilities'] for cap in needed), 'accepted actual Full capability publication')
|
||||
require(all(intent['install']['target'][key] == target[key] for key in ('tenant_id', 'asset_id', 'agent_id')),
|
||||
'accepted installation targets agree')
|
||||
return {'target': target, 'full_policy_sha256': pin['policy_sha256'],
|
||||
'helper_binary_sha256': pin['helper_binary_sha256'], 'boot_id': samples[-1]['vm']['boot_id'],
|
||||
'connection_generation': samples[-1]['vm']['generation'], 'attestation_sha256': expected,
|
||||
'attestation_runner_sha256': attested['runner_sha256'], 'sample_sha256': attested['sample_sha256']}
|
||||
|
||||
|
||||
def remote(p):
|
||||
"""Fixed server-only operations. Policy data is public; no private key/token."""
|
||||
import datetime as dt
|
||||
import fcntl
|
||||
import http.client
|
||||
import socket
|
||||
import ssl
|
||||
import stat
|
||||
import subprocess
|
||||
os.umask(0o077)
|
||||
require(os.geteuid() == 0 and p['action'] in ('open', 'read', 'close', 'provision-mcp-root'), 'fixed server bootstrap operation')
|
||||
intent = p['intent']; ident = str(uuid.UUID(intent['id']))
|
||||
require(ident == intent['id'] and intent['type'] in ('rmm.script-console.policy-scope.v1',
|
||||
'rmm.script-console.mcp-root-provision.v1'), 'canonical own policy intent')
|
||||
provision = intent['type'] == 'rmm.script-console.mcp-root-provision.v1'
|
||||
require(p['action'] in ('provision-mcp-root', 'read') if provision else p['action'] in ('open', 'read', 'close'),
|
||||
'separate provision and scope operations; no automatic side effects')
|
||||
root = Path('/opt/rust-discovery'); directory = root / 'devstate/root-policy'; policy_path = directory / 'policy.json'
|
||||
case = root / 'devstate' / (('script-console-mcp-root-provision-' if provision else 'script-console-policy-scope-') + ident)
|
||||
compose = ['docker', 'compose', '--env-file', str(root / 'devstate/.env'), '-f', str(root / 'deploy/server.compose.yaml')]
|
||||
old_hash = 'cf15cbb68b590475df6def28e7dcffb7d88e0ca2d2555a06174fb654eeff05f4'
|
||||
def enc(value): return json.dumps(value, sort_keys=True, separators=(',', ':')).encode()
|
||||
def hash_bytes(raw): return hashlib.sha256(raw).hexdigest()
|
||||
def now(): return dt.datetime.now(dt.timezone.utc)
|
||||
def stamp(value):
|
||||
parsed = dt.datetime.fromisoformat(value.replace('Z', '+00:00'))
|
||||
require(parsed.utcoffset() is not None, 'explicit UTC/timezone bound')
|
||||
return parsed
|
||||
def run(args, timeout=15, **kwargs):
|
||||
result = subprocess.run(args, capture_output=True, timeout=timeout, **kwargs)
|
||||
require(result.returncode == 0, 'fixed server command incomplete; private details withheld')
|
||||
return result.stdout
|
||||
def syncdir(path):
|
||||
fd = os.open(path, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
|
||||
try: os.fsync(fd)
|
||||
finally: os.close(fd)
|
||||
def once(path, raw, uid=0, gid=0, mode=0o600, times=None):
|
||||
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode)
|
||||
with os.fdopen(fd, 'wb') as out:
|
||||
out.write(raw); out.flush(); os.fchown(out.fileno(), uid, gid); os.fchmod(out.fileno(), mode)
|
||||
if times is not None: os.utime(out.fileno(), ns=times)
|
||||
os.fsync(out.fileno())
|
||||
syncdir(path.parent)
|
||||
def owned(path, directory=False):
|
||||
value = path.lstat()
|
||||
require(not path.is_symlink() and value.st_uid == 0 and stat.S_IMODE(value.st_mode) == (0o700 if directory else 0o600)
|
||||
and (stat.S_ISDIR(value.st_mode) if directory else stat.S_ISREG(value.st_mode) and value.st_nlink == 1),
|
||||
'own protected policy history')
|
||||
return value
|
||||
def load(path):
|
||||
value = owned(path); require(value.st_size <= 8 * 1024 * 1024, 'bounded history receipt')
|
||||
return json.loads(path.read_bytes())
|
||||
def read_policy():
|
||||
parent = directory.lstat()
|
||||
require(not directory.is_symlink() and stat.S_ISDIR(parent.st_mode) and parent.st_uid == 10001
|
||||
and not parent.st_mode & 0o022, 'preserved protected policy parent')
|
||||
fd = os.open(policy_path, os.O_RDONLY | os.O_NOFOLLOW)
|
||||
try:
|
||||
value = os.fstat(fd)
|
||||
require(stat.S_ISREG(value.st_mode) and value.st_uid == 10001 and stat.S_IMODE(value.st_mode) == 0o600
|
||||
and value.st_nlink == 1 and 0 < value.st_size <= 65536, 'protected bounded current policy')
|
||||
raw = os.read(fd, 65537); after = os.fstat(fd); named = policy_path.lstat()
|
||||
require(len(raw) == value.st_size and (value.st_dev, value.st_ino, value.st_size, value.st_mtime_ns, value.st_ctime_ns)
|
||||
== (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns)
|
||||
and (named.st_dev, named.st_ino) == (value.st_dev, value.st_ino), 'same complete named policy through read')
|
||||
metadata = {'device': value.st_dev, 'inode': value.st_ino, 'uid': value.st_uid, 'gid': value.st_gid,
|
||||
'mode': stat.S_IMODE(value.st_mode), 'bytes': value.st_size, 'atime_ns': value.st_atime_ns,
|
||||
'mtime_ns': value.st_mtime_ns, 'ctime_ns': value.st_ctime_ns}
|
||||
return raw, metadata
|
||||
finally: os.close(fd)
|
||||
def summary(raw, metadata):
|
||||
out = {'sha256': hash_bytes(raw), 'metadata': metadata}
|
||||
try:
|
||||
policy = json.loads(raw)
|
||||
out.update(schema_version=policy['schema_version'], profile=policy['profile'], expires_at=policy['expires_at'],
|
||||
scope_count=len(policy['scopes']), expired=stamp(policy['expires_at']) <= now())
|
||||
except Exception as error: out['parse_error_class'] = type(error).__name__
|
||||
return out
|
||||
def candidate():
|
||||
raw = base64.b64decode(intent['candidate_bytes_b64'], validate=True)
|
||||
require(len(raw) <= 65536 and hash_bytes(raw) == intent['candidate_sha256'], 'immutable exact candidate bytes')
|
||||
body = json.loads(raw); target = intent['qualification']['target']
|
||||
require(set(body) == {'schema_version', 'profile', 'expires_at', 'scopes'} and body['schema_version'] == 2
|
||||
and type(body['schema_version']) is int and body['profile'] == 'development'
|
||||
and body['expires_at'] == intent['expires_at'] and len(body['scopes']) == 1, 'one schema2 development scope')
|
||||
expected = dict(target, principals=intent['principals'], helper_policy_sha256=intent['qualification']['full_policy_sha256'],
|
||||
helper_binary_sha256=intent['qualification']['helper_binary_sha256'],
|
||||
acceptance_evidence_id='script-console-full-linux-attested:' + intent['qualification']['attestation_sha256'],
|
||||
allowed_services=[], allow_root_scripts=True, allowed_script_profiles=['full_maintenance_v1'], allow_reboot=False)
|
||||
require(body['scopes'] == [expected] and 'apt' not in expected and 'root_logs' not in expected,
|
||||
'exact target/principals/Full pins; no service/APT/log/reboot scope')
|
||||
require(stamp(intent['expires_at']) - stamp(intent['created_at']) == dt.timedelta(seconds=900), 'fixed fifteen-minute intent')
|
||||
return raw
|
||||
def server_gate():
|
||||
target = intent['qualification']['target']; tenant = str(uuid.UUID(target['tenant_id'])); agent = str(uuid.UUID(target['agent_id']))
|
||||
require(tenant == '11111111-1111-4111-8111-111111111111' and tenant == target['tenant_id'] and agent == target['agent_id'], 'fixed target UUIDs')
|
||||
scope = "tenant_id='" + tenant + "' AND agent_id='" + agent + "'"
|
||||
# Only fixed public names, roles, permissions, capability/status fields.
|
||||
principals = intent['principals']; automation = 'automation:' + tenant
|
||||
require(principals == [automation, 'simulated-testprincipal-a'], 'exact existing MCP creator and simulated UI approver IDs')
|
||||
selected = ','.join("'" + name + "'" for name in principals)
|
||||
query = ("BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY; SELECT json_build_object('observed_at',now(),"
|
||||
"'installation',(SELECT json_build_object('tenant_id',tenant_id,'asset_id',asset_id,'agent_id',agent_id,"
|
||||
"'enrollment_generation',enrollment_generation,'assignment_version',assignment_version,'capabilities',capabilities,"
|
||||
"'connection_generation',connection_generation,'connection_boot_id',connection_boot_id,'last_contact_at',last_contact_at,"
|
||||
"'certificate_sha256',certificate_sha256,'last_authenticated_certificate_sha256',last_authenticated_certificate_sha256,"
|
||||
"'revoked_at',revoked_at,'sync_ready',sync_ready,'helper_sync_ready',helper_sync_ready,'restore_blocked',restore_blocked,"
|
||||
"'sequence_regressed',sequence_regressed,'sync_recovery_required',sync_recovery_required) FROM agent_installations WHERE " + scope + "),"
|
||||
"'memberships',(SELECT COALESCE(json_agg(q ORDER BY principal),'[]'::json) FROM (SELECT principal,kind,permissions,revoked_at FROM memberships WHERE tenant_id='" + tenant + "' AND principal IN (" + selected + ")) q),"
|
||||
"'jobs',(SELECT count(*) FROM jobs WHERE " + scope + "),"
|
||||
"'outbox',(SELECT count(*) FROM outbox o JOIN jobs j USING(tenant_id,job_id,attempt_id) WHERE " + scope.replace('tenant_id=', 'j.tenant_id=').replace('agent_id=', 'j.agent_id=') + "),"
|
||||
"'permits',(SELECT count(*) FROM execution_permits e JOIN jobs j USING(tenant_id,job_id,attempt_id) WHERE " + scope.replace('tenant_id=', 'j.tenant_id=').replace('agent_id=', 'j.agent_id=') + "),"
|
||||
"'unresolved',(SELECT count(*) FROM jobs WHERE tenant_id='" + tenant + "' AND state NOT IN ('succeeded','failed','cancelled','expired')),"
|
||||
"'migrations',(SELECT json_agg(version ORDER BY version) FROM _sqlx_migrations WHERE success)); COMMIT;")
|
||||
data = json.loads(run(compose + ['exec', '-T', 'postgres', 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1',
|
||||
'-U', 'postgres', '-d', 'rmm'], input=query.encode()))
|
||||
installed = data['installation']
|
||||
require(installed is not None and all(installed[key] == value for key, value in target.items()), 'same stored enrolled target/generations')
|
||||
require(data['migrations'] == list(range(1, 15)), 'actual additive migration14 server prerequisite')
|
||||
require([data[key] for key in ('jobs', 'outbox', 'permits')] == [30, 30, 26], 'same target-scoped closed30/30/26 before scope open')
|
||||
require(data['unresolved'] == 0 and installed['revoked_at'] is None and installed['sync_ready'] is True
|
||||
and installed['helper_sync_ready'] is True and all(installed[key] is False for key in
|
||||
('restore_blocked', 'sequence_regressed', 'sync_recovery_required'))
|
||||
and installed['connection_boot_id'] == intent['qualification']['boot_id']
|
||||
and installed['connection_generation'] >= intent['qualification']['connection_generation']
|
||||
and installed['certificate_sha256'] == installed['last_authenticated_certificate_sha256']
|
||||
and 0 <= (now() - stamp(installed['last_contact_at'])).total_seconds() <= 45, 'fresh authenticated ready stored Cloud client')
|
||||
needed = ('rmm.sync.v1', 'helper.root.v1', 'root:run_script', 'run_script', 'script.full_maintenance/1',
|
||||
'helper.policy.sha256:' + intent['qualification']['full_policy_sha256'],
|
||||
'helper.binary.sha256:' + intent['qualification']['helper_binary_sha256'])
|
||||
require(all(value in installed['capabilities'] for value in needed), 'fresh stored Full policy/code capability binding')
|
||||
rows = {row['principal']: row for row in data['memberships']}
|
||||
require(set(rows) == set(principals), 'all explicitly bound existing principals')
|
||||
for name in principals:
|
||||
row = rows[name]; permissions = {'root:execute', 'scripts:execute', 'operations:plan', 'operations:submit', 'operations:read'}
|
||||
permissions.add('plans:approve' if name == 'simulated-testprincipal-a' else 'operations:plan')
|
||||
require(row['revoked_at'] is None and row['kind'] == ('test_human' if name == 'simulated-testprincipal-a' else 'automation')
|
||||
and permissions <= set(row['permissions']), 'existing principal lacks required scope; never mutate memberships')
|
||||
if name == automation:
|
||||
exact = ['inventory:read', 'logs:read', 'operations:read', 'operations:plan',
|
||||
'operations:submit', 'jobs:cancel', 'scripts:execute', 'root:execute']
|
||||
require(row['permissions'] == exact, 'exact provisioned automation rights; no approval/revoke/SYSTEM authority')
|
||||
return data
|
||||
def roles_and_auth():
|
||||
out = {}
|
||||
names = ('RMM_PROFILE', 'RMM_DEV_AUTH', 'RMM_SERVER_ROLE', 'RMM_UI_ORIGIN', 'RMM_DEV_ROOT_ENABLED',
|
||||
'RMM_DEV_ROOT_POLICY_FILE', 'RMM_DEV_SYSTEM_ENABLED', 'RMM_DEV_SYSTEM_POLICY_FILE',
|
||||
'RMM_DEV_DELIVERY_FAULTS', 'RMM_DEV_DELIVERY_FAULTS_FILE')
|
||||
select = ' '.join('(eq $key "' + name + '")' for name in names)
|
||||
template = '{{range .Config.Env}}{{$key := index (split . "=") 0}}{{if or ' + select + '}}{{println .}}{{end}}{{end}}'
|
||||
for role in ('api', 'gateway'):
|
||||
cid = run(compose + ['ps', '-q', role]).decode().strip(); require(cid and '\n' not in cid, 'one actual role')
|
||||
image = run(['docker', 'inspect', cid, '--format', '{{.Image}}']).decode().strip()
|
||||
require(image == intent['expected_server_image'], 'exact Root-reviewed deployed server image')
|
||||
env = {}
|
||||
for line in run(['docker', 'inspect', cid, '--format', template]).decode().splitlines():
|
||||
if not line:
|
||||
continue
|
||||
key, separator, value = line.partition('=')
|
||||
require(separator == '=' and key in names and key not in env, 'strict unique selected public environment field')
|
||||
env[key] = value
|
||||
require(env.get('RMM_PROFILE') == 'development' and env.get('RMM_DEV_AUTH') == 'true'
|
||||
and env.get('RMM_SERVER_ROLE') == role and env.get('RMM_UI_ORIGIN') == 'https://localhost:18443'
|
||||
and env.get('RMM_DEV_ROOT_ENABLED') == 'true' and env.get('RMM_DEV_ROOT_POLICY_FILE') == '/root-policy/policy.json'
|
||||
and env.get('RMM_DEV_SYSTEM_ENABLED') is None and env.get('RMM_DEV_SYSTEM_POLICY_FILE') is None
|
||||
and env.get('RMM_DEV_DELIVERY_FAULTS') == 'false' and env.get('RMM_DEV_DELIVERY_FAULTS_FILE') is None,
|
||||
'unchanged existing dev/test roles/flags; no auth or server flag changes')
|
||||
mounts = json.loads(run(['docker', 'inspect', cid, '--format', '{{json .Mounts}}']))
|
||||
policy_mounts = [mount for mount in mounts if mount['Destination'] == '/root-policy']
|
||||
require(len(policy_mounts) == 1 and policy_mounts[0]['Type'] == 'bind' and policy_mounts[0]['RW'] is False
|
||||
and policy_mounts[0]['Source'] == str(directory), 'actual unchanged read-only Root policy mount')
|
||||
out[role] = {'container_id': cid, 'image_id': image, 'settings': env, 'policy_mount': policy_mounts[0]}
|
||||
class HTTPS(http.client.HTTPSConnection):
|
||||
def connect(self):
|
||||
self.sock = self._context.wrap_socket(socket.create_connection(('127.0.0.1', 18443), timeout=5), server_hostname=self.host)
|
||||
client = HTTPS('localhost', 18443, timeout=5, context=ssl.create_default_context(cafile=str(root / 'devstate/api-pki/ca.pem')))
|
||||
try:
|
||||
client.request('GET', '/auth/config'); response = client.getresponse(); raw = response.read(4097)
|
||||
require(response.status == 200 and len(raw) <= 4096 and json.loads(raw) ==
|
||||
{'oidc_configured': False, 'oidc_login_url': None, 'dev_login_enabled': True}, 'honest private dev/test auth config')
|
||||
finally: client.close()
|
||||
return out
|
||||
def provision_state():
|
||||
tenant = '11111111-1111-4111-8111-111111111111'; actor = 'automation:' + tenant
|
||||
query = ("BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY; SELECT json_build_object('actor',"
|
||||
"(SELECT row_to_json(q) FROM (SELECT tenant_id,principal,kind,permissions,revoked_at FROM memberships WHERE tenant_id='" + tenant + "' AND principal='" + actor + "') q),"
|
||||
"'jobs',(SELECT count(*) FROM jobs WHERE tenant_id='" + tenant + "'),"
|
||||
"'outbox',(SELECT count(*) FROM outbox WHERE tenant_id='" + tenant + "'),"
|
||||
"'permits',(SELECT count(*) FROM execution_permits WHERE tenant_id='" + tenant + "'),"
|
||||
"'unresolved',(SELECT count(*) FROM jobs WHERE tenant_id='" + tenant + "' AND state NOT IN ('succeeded','failed','cancelled','expired')),"
|
||||
"'other_memberships_sha256',(SELECT encode(sha256(convert_to(coalesce(string_agg(to_jsonb(m)::text,E'\\n' ORDER BY tenant_id,principal),''),'UTF8')),'hex') FROM memberships m WHERE NOT(tenant_id='" + tenant + "' AND principal='" + actor + "'))); COMMIT;")
|
||||
return json.loads(run(compose + ['exec', '-T', 'postgres', 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1',
|
||||
'-U', 'postgres', '-d', 'rmm'], input=query.encode()))
|
||||
if provision:
|
||||
before_rights = ['inventory:read', 'logs:read', 'operations:read', 'operations:plan',
|
||||
'operations:submit', 'jobs:cancel', 'scripts:execute']
|
||||
actor = 'automation:11111111-1111-4111-8111-111111111111'
|
||||
tenant = '11111111-1111-4111-8111-111111111111'
|
||||
expected_actor = {'tenant_id': tenant, 'principal': actor, 'kind': 'automation',
|
||||
'permissions': before_rights, 'revoked_at': None}
|
||||
require(intent['actor_before'] == expected_actor and intent['actor_after'] == dict(expected_actor,
|
||||
permissions=before_rights + ['root:execute']) and intent['old_policy_sha256'] == old_hash
|
||||
and hash_bytes(enc(intent)) == p['intent_sha256'], 'exact one existing actor/rights transition')
|
||||
if p['action'] == 'read':
|
||||
out = {'id': ident, 'read_only': True, 'case_present': case.exists(), 'retry_allowed': False}
|
||||
for key, fn in (('database', provision_state), ('roles', roles_and_auth)):
|
||||
try: out[key] = fn()
|
||||
except Exception as error: out[key] = {'read_error_class': type(error).__name__}
|
||||
try:
|
||||
current, metadata = read_policy(); out['current_policy'] = summary(current, metadata)
|
||||
except Exception as error: out['policy_read_error_class'] = type(error).__name__
|
||||
if case.exists():
|
||||
owned(case, True)
|
||||
for name in ('intent.json', 'before.json', 'provision-entered.json', 'sql-result.json', 'after.json', 'provision-result.json'):
|
||||
if (case / name).exists():
|
||||
try: out[name] = load(case / name)
|
||||
except Exception as error: out[name] = {'read_error_class': type(error).__name__}
|
||||
if (case / 'intent.json').exists(): require(load(case / 'intent.json') == intent, 'same remote provision intent')
|
||||
return out
|
||||
lock = os.open(root / 'devstate/.script-console-policy-scope.lock', os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW, 0o600)
|
||||
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
try:
|
||||
require(not case.exists() and not case.is_symlink() and stamp(intent['created_at']) <= now()
|
||||
< stamp(intent['provision_before']) <= now() + dt.timedelta(seconds=900), 'new short-lived explicit provision case')
|
||||
roles = roles_and_auth(); current, metadata = read_policy(); body = json.loads(current)
|
||||
require(hash_bytes(current) == old_hash and body['schema_version'] == 1 and body['profile'] == 'development'
|
||||
and stamp(body['expires_at']) <= now(), 'same exact expired closed Root policy before provisioning')
|
||||
before = provision_state()
|
||||
require(before['actor'] == expected_actor and {key: before[key] for key in ('jobs', 'outbox', 'permits', 'unresolved')}
|
||||
== {'jobs': 30, 'outbox': 30, 'permits': 26, 'unresolved': 0}, 'exact current seven-right actor and closed30/30/26')
|
||||
owned(root / 'devstate', True); case.mkdir(mode=0o700); syncdir(case.parent)
|
||||
once(case / 'intent.json', enc(intent)); once(case / 'before.json', enc({'database': before,
|
||||
'roles': roles, 'policy_sha256': old_hash, 'policy_metadata': metadata}))
|
||||
once(case / 'provision-entered.json', enc({'id': ident, 'intent_sha256': p['intent_sha256'],
|
||||
'adds_only': 'root:execute', 'no_retry': True}))
|
||||
latest, _ = read_policy(); require(latest == current, 'closed policy CAS immediately before SQL')
|
||||
# Exact existing row, tenant context, closed-job predicate and a
|
||||
# RETURNING count assertion in the transaction. ON_ERROR_STOP means
|
||||
# count0 aborts before COMMIT; connection close rolls back.
|
||||
rights_sql = 'ARRAY[' + ','.join("'" + value + "'" for value in before_rights) + ']::text[]'
|
||||
query = ("BEGIN ISOLATION LEVEL SERIALIZABLE; SET LOCAL app.tenant_id='" + tenant + "'; "
|
||||
"WITH changed AS (UPDATE memberships SET permissions=array_append(permissions,'root:execute') "
|
||||
"WHERE tenant_id='" + tenant + "' AND principal='" + actor + "' AND kind='automation' AND revoked_at IS NULL "
|
||||
"AND permissions=" + rights_sql + " AND (SELECT count(*) FROM jobs WHERE tenant_id='" + tenant + "')=30 "
|
||||
"AND (SELECT count(*) FROM outbox WHERE tenant_id='" + tenant + "')=30 "
|
||||
"AND (SELECT count(*) FROM execution_permits WHERE tenant_id='" + tenant + "')=26 "
|
||||
"AND NOT EXISTS(SELECT 1 FROM jobs WHERE tenant_id='" + tenant + "' AND state NOT IN ('succeeded','failed','cancelled','expired')) "
|
||||
"RETURNING tenant_id,principal,kind,permissions,revoked_at) "
|
||||
"SELECT json_build_object('changed_count',count(*),'assert_one',1/count(*),'after',(json_agg(changed))->0) FROM changed; COMMIT;")
|
||||
result = json.loads(run(compose + ['exec', '-T', 'postgres', 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1',
|
||||
'-U', 'postgres', '-d', 'rmm'], input=query.encode()))
|
||||
require(result == {'changed_count': 1, 'assert_one': 1, 'after': intent['actor_after']}, 'exact committed public actor row')
|
||||
once(case / 'sql-result.json', enc(result))
|
||||
after = provision_state(); once(case / 'after.json', enc(after))
|
||||
require(after == dict(before, actor=intent['actor_after']), 'only this one actor permission changed; all other memberships and counts retained')
|
||||
latest, latest_metadata = read_policy()
|
||||
require(latest == current and latest_metadata['inode'] == metadata['inode'] and roles_and_auth() == roles,
|
||||
'closed policy and server flags/roles unchanged after provisioning')
|
||||
final = {'id': ident, 'provisioned': True, 'actor': actor, 'added_permission': 'root:execute',
|
||||
'other_memberships_unchanged': True, 'policy_remains_closed': True, 'jobs_created': False,
|
||||
'approvals_created': False, 'tokens_or_sessions_created': False, 'automatic_scope_open': False}
|
||||
once(case / 'provision-result.json', enc(final)); return final
|
||||
finally: os.close(lock)
|
||||
raw_candidate = candidate()
|
||||
require(intent['old_policy_sha256'] == old_hash and hash_bytes(enc(intent)) == p['intent_sha256'], 'own complete immutable policy intent')
|
||||
if p['action'] == 'read':
|
||||
out = {'id': ident, 'read_only': True, 'case_present': case.exists(), 'retry_allowed': False}
|
||||
try:
|
||||
raw, metadata = read_policy(); out['current_policy'] = summary(raw, metadata)
|
||||
out['matches_original_closed'] = hash_bytes(raw) == old_hash
|
||||
out['matches_own_candidate'] = hash_bytes(raw) == intent['candidate_sha256']
|
||||
except Exception as error: out['policy_read_error_class'] = type(error).__name__
|
||||
if case.exists():
|
||||
owned(case, True)
|
||||
for name in ('intent.json', 'original-metadata.json', 'open-entered.json', 'open-result.json', 'close-entered.json', 'close-result.json'):
|
||||
if (case / name).exists():
|
||||
try: out[name] = load(case / name)
|
||||
except Exception as error: out[name] = {'read_error_class': type(error).__name__}
|
||||
if (case / 'intent.json').exists(): require(load(case / 'intent.json') == intent, 'same remote original intent')
|
||||
return out
|
||||
# Policy writers using this source serialize. Other root maintenance must be
|
||||
# coordinated; unexpected current bytes/inode always fail the final CAS.
|
||||
lock = os.open(root / 'devstate/.script-console-policy-scope.lock', os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW, 0o600)
|
||||
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
try:
|
||||
if p['action'] == 'open':
|
||||
require(not case.exists() and not case.is_symlink(), 'existing policy case; read only')
|
||||
require(stamp(intent['created_at']) <= now() < stamp(intent['expires_at']) <= now() + dt.timedelta(seconds=900), 'fresh fixed bounded candidate expiry')
|
||||
gate = server_gate(); roles = roles_and_auth(); previous, metadata = read_policy()
|
||||
body = json.loads(previous)
|
||||
require(hash_bytes(previous) == old_hash and set(body) == {'schema_version', 'profile', 'expires_at', 'scopes'}
|
||||
and type(body['schema_version']) is int and body['schema_version'] == 1 and body['profile'] == 'development'
|
||||
and isinstance(body['scopes'], list) and stamp(body['expires_at']) <= now(), 'exact historical closed schema1 policy CAS')
|
||||
parent = root / 'devstate'; owned(parent, True)
|
||||
case.mkdir(mode=0o700); syncdir(parent)
|
||||
once(case / 'intent.json', enc(intent)); once(case / 'original-policy.json', previous)
|
||||
once(case / 'original-metadata.json', enc(metadata)); once(case / 'before-server.json', enc({'gate': gate, 'roles': roles}))
|
||||
# Durable one-use marker BEFORE any policy exposure or rename.
|
||||
once(case / 'open-entered.json', enc({'id': ident, 'intent_sha256': p['intent_sha256'], 'candidate_sha256': intent['candidate_sha256']}))
|
||||
next_path = directory / ('script-full-' + ident + '.open-next')
|
||||
once(next_path, raw_candidate, uid=10001, gid=10001)
|
||||
current, current_metadata = read_policy()
|
||||
require(hash_bytes(current) == old_hash and current_metadata['device'] == metadata['device']
|
||||
and current_metadata['inode'] == metadata['inode'] and current_metadata['mtime_ns'] == metadata['mtime_ns'], 'last exact closed policy/inode CAS')
|
||||
require(now() < stamp(intent['expires_at']), 'candidate still unexpired immediately before exposure')
|
||||
os.replace(next_path, policy_path); syncdir(directory)
|
||||
current, current_metadata = read_policy(); require(current == raw_candidate, 'actual exact new policy bytes')
|
||||
result = {'id': ident, 'opened': True, 'policy_sha256': hash_bytes(current), 'expires_at': intent['expires_at'],
|
||||
'metadata': current_metadata, 'server_flags_unchanged': roles_and_auth() == roles,
|
||||
'jobs_created': False, 'approvals_created': False, 'database_mutations': False}
|
||||
require(result['server_flags_unchanged'], 'same roles and flags after bounded policy replacement')
|
||||
once(case / 'open-result.json', enc(result)); return result
|
||||
owned(case, True); require(load(case / 'intent.json') == intent, 'close only original own remote case')
|
||||
require((case / 'open-entered.json').exists() and not (case / 'close-entered.json').exists(), 'one close after own open; read only on uncertainty')
|
||||
owned(case / 'original-policy.json'); previous = (case / 'original-policy.json').read_bytes()
|
||||
metadata = load(case / 'original-metadata.json')
|
||||
require(hash_bytes(previous) == old_hash and metadata['uid'] == 10001 and metadata['mode'] == 0o600, 'original private closed backup and metadata')
|
||||
current, current_metadata = read_policy(); require(current == raw_candidate, 'foreign or changed policy; never overwrite')
|
||||
once(case / 'close-entered.json', enc({'id': ident, 'expected_current_sha256': intent['candidate_sha256'], 'restore_sha256': old_hash}))
|
||||
next_path = directory / ('script-full-' + ident + '.close-next')
|
||||
once(next_path, previous, uid=metadata['uid'], gid=metadata['gid'], mode=metadata['mode'], times=(metadata['atime_ns'], metadata['mtime_ns']))
|
||||
last, last_metadata = read_policy()
|
||||
require(last == raw_candidate and last_metadata['device'] == current_metadata['device']
|
||||
and last_metadata['inode'] == current_metadata['inode'], 'last exact own policy/inode CAS')
|
||||
os.replace(next_path, policy_path); syncdir(directory)
|
||||
restored, restored_metadata = read_policy()
|
||||
require(restored == previous and all(restored_metadata[key] == metadata[key] for key in ('uid', 'gid', 'mode', 'bytes', 'mtime_ns'))
|
||||
and stamp(json.loads(restored)['expires_at']) <= now(), 'exact old bytes/owner/mode/mtime restored and closed')
|
||||
result = {'id': ident, 'closed': True, 'restored_sha256': hash_bytes(restored), 'metadata': restored_metadata,
|
||||
'historical_original_inode_retained_in_receipt': True, 'restored_inode_is_atomic_replacement': True,
|
||||
'jobs_created': False, 'approvals_created': False, 'database_mutations': False}
|
||||
once(case / 'close-result.json', enc(result)); return result
|
||||
finally: os.close(lock)
|
||||
|
||||
|
||||
def prepare(args):
|
||||
qualification = accepted_native(args.attestation.resolve(), args.accepted_attestation_sha)
|
||||
require(re.fullmatch('sha256:[a-f0-9]{64}', args.expected_server_image) is not None, 'explicit reviewed deployed image ID')
|
||||
principals = ['automation:' + TENANT, SIMULATED]
|
||||
created = dt.datetime.now(dt.timezone.utc).replace(microsecond=0); expiry = created + dt.timedelta(minutes=15)
|
||||
scope = dict(qualification['target'], principals=principals, helper_policy_sha256=qualification['full_policy_sha256'],
|
||||
helper_binary_sha256=qualification['helper_binary_sha256'],
|
||||
acceptance_evidence_id='script-console-full-linux-attested:' + qualification['attestation_sha256'],
|
||||
allowed_services=[], allow_root_scripts=True, allowed_script_profiles=['full_maintenance_v1'], allow_reboot=False)
|
||||
candidate = encode({'schema_version': 2, 'profile': 'development', 'expires_at': expiry.isoformat(), 'scopes': [scope]})
|
||||
ident = str(uuid.uuid4()); STATE.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||
private_directory(STATE); folder = STATE / ident; folder.mkdir(mode=0o700)
|
||||
intent = {'type': 'rmm.script-console.policy-scope.v1', 'id': ident, 'runner_sha256': sha(Path(__file__).read_bytes()),
|
||||
'remote_source_sha256': sha(inspect.getsource(remote).encode()), 'support_sha256': SUPPORT,
|
||||
'qualification': qualification, 'attestation_path': str(args.attestation.resolve()), 'principals': principals,
|
||||
'expected_server_image': args.expected_server_image, 'old_policy_sha256': OLD_POLICY_SHA,
|
||||
'created_at': created.isoformat(), 'expires_at': expiry.isoformat(), 'candidate_sha256': sha(candidate),
|
||||
'candidate_bytes_b64': base64.b64encode(candidate).decode(), 'no_jobs_or_approvals': True}
|
||||
create(folder / 'intent.json', encode(intent)); create(folder / 'candidate-policy.json', candidate)
|
||||
return {'id': ident, 'intent': str(folder / 'intent.json'), 'intent_sha256': sha(encode(intent)),
|
||||
'candidate_sha256': sha(candidate), 'expires_at': intent['expires_at'], 'target_called': False}
|
||||
|
||||
|
||||
def prepare_actor(args):
|
||||
require(re.fullmatch('sha256:[a-f0-9]{64}', args.expected_server_image) is not None, 'explicit reviewed deployed image ID')
|
||||
actor = {'tenant_id': TENANT, 'principal': 'automation:' + TENANT, 'kind': 'automation',
|
||||
'permissions': AUTOMATION_RIGHTS, 'revoked_at': None}
|
||||
created = dt.datetime.now(dt.timezone.utc).replace(microsecond=0)
|
||||
ident = str(uuid.uuid4()); STATE.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||
private_directory(STATE); folder = STATE / ident; folder.mkdir(mode=0o700)
|
||||
intent = {'type': 'rmm.script-console.mcp-root-provision.v1', 'id': ident,
|
||||
'runner_sha256': sha(Path(__file__).read_bytes()), 'remote_source_sha256': sha(inspect.getsource(remote).encode()),
|
||||
'support_sha256': SUPPORT, 'expected_server_image': args.expected_server_image,
|
||||
'old_policy_sha256': OLD_POLICY_SHA, 'actor_before': actor,
|
||||
'actor_after': dict(actor, permissions=AUTOMATION_RIGHTS + ['root:execute']),
|
||||
'created_at': created.isoformat(), 'provision_before': (created + dt.timedelta(minutes=15)).isoformat(),
|
||||
'authorization_basis': 'Explicit user AI/MCP Root maintenance objective; separately reviewed development actor provisioning',
|
||||
'no_jobs_or_approvals': True, 'no_scope_open': True}
|
||||
create(folder / 'intent.json', encode(intent))
|
||||
return {'id': ident, 'intent': str(folder / 'intent.json'), 'intent_sha256': sha(encode(intent)),
|
||||
'adds_only': 'root:execute', 'automatic_scope_open': False, 'target_called': False}
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('phase', choices=('prepare-local', 'open', 'read', 'close', 'prepare-mcp-root-local', 'provision-mcp-root'))
|
||||
parser.add_argument('--id'); parser.add_argument('--attestation', type=Path)
|
||||
parser.add_argument('--accepted-attestation-sha'); parser.add_argument('--expected-server-image')
|
||||
parser.add_argument('--access-root', type=Path, default=Path('/home/kevin/Schreibtisch/Coding/rust-discovery'))
|
||||
parser.add_argument('--execute-policy-open', action='store_true'); parser.add_argument('--execute-policy-close', action='store_true')
|
||||
parser.add_argument('--execute-mcp-root-provision', action='store_true')
|
||||
args = parser.parse_args(); os.umask(0o077)
|
||||
require(all(sha((ROOT / name).read_bytes()) == value for name, value in SUPPORT.items()), 'exact existing strict SSH support')
|
||||
if args.phase == 'prepare-local':
|
||||
require(args.id is None and args.attestation is not None and args.accepted_attestation_sha is not None
|
||||
and args.expected_server_image is not None, 'explicit Root accepted native proof and deployed image')
|
||||
print(json.dumps(prepare(args))); return
|
||||
if args.phase == 'prepare-mcp-root-local':
|
||||
require(args.id is None and args.expected_server_image is not None, 'new explicitly reviewed actor provision intent')
|
||||
print(json.dumps(prepare_actor(args))); return
|
||||
ident = str(uuid.UUID(args.id)); require(ident == args.id, 'canonical original case UUID')
|
||||
private_directory(STATE); folder = STATE / ident; private_directory(folder)
|
||||
intent = json.loads(protected(folder / 'intent.json'))
|
||||
require(intent['id'] == ident and intent['runner_sha256'] == sha(Path(__file__).read_bytes())
|
||||
and intent['remote_source_sha256'] == sha(inspect.getsource(remote).encode()) and intent['support_sha256'] == SUPPORT,
|
||||
'original same-source immutable policy case')
|
||||
provision = intent['type'] == 'rmm.script-console.mcp-root-provision.v1'
|
||||
require(args.phase in ('provision-mcp-root', 'read') if provision else args.phase in ('open', 'read', 'close'), 'same original intent operation kind')
|
||||
if args.phase in ('open', 'close', 'provision-mcp-root'):
|
||||
allowed = {'open': args.execute_policy_open, 'close': args.execute_policy_close,
|
||||
'provision-mcp-root': args.execute_mcp_root_provision}[args.phase]
|
||||
require(allowed, 'explicit separate bounded bootstrap operation')
|
||||
if args.phase == 'open':
|
||||
require(accepted_native(Path(intent['attestation_path']), intent['qualification']['attestation_sha256']) == intent['qualification'], 'accepted evidence unchanged before open')
|
||||
create(folder / (args.phase + '-requested.json'), encode({'id': ident, 'intent_sha256': sha(encode(intent)), 'retry_allowed': False}))
|
||||
import remote_client_bootstrap as bootstrap
|
||||
bootstrap.ROOT = args.access_root.resolve(); bootstrap.access.ROOT = bootstrap.ROOT
|
||||
settings = bootstrap.access.load_config(bootstrap.ROOT / 'credentials/server.conf')
|
||||
require(settings['address'] in ('88.99.80.202', 'discovery.ease-technologies.de') and settings['username'] == 'root'
|
||||
and settings.get('port', '22') == '22', 'fixed independently trusted cloud server')
|
||||
result = bootstrap.rpc('server.conf', remote, {'action': args.phase, 'intent': intent, 'intent_sha256': sha(encode(intent))})
|
||||
create(folder / (args.phase + '-reply-' + str(uuid.uuid4()) + '.json'), encode(result))
|
||||
print(json.dumps(result))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try: main()
|
||||
except Exception as error:
|
||||
print('SCRIPT_POLICY_SCOPE_INCOMPLETE:' + type(error).__name__ + '; preserve case, read only after any requested mutation')
|
||||
raise SystemExit(2) from None
|
||||
Reference in New Issue
Block a user