diff --git a/deploy/script_console_policy_scope.py b/deploy/script_console_policy_scope.py new file mode 100644 index 0000000..c86a3a4 --- /dev/null +++ b/deploy/script_console_policy_scope.py @@ -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 diff --git a/docs/script-console-browser-acceptance.md b/docs/script-console-browser-acceptance.md new file mode 100644 index 0000000..e497403 --- /dev/null +++ b/docs/script-console-browser-acceptance.md @@ -0,0 +1,332 @@ +# Geplante Browserabnahme der Linux-Full-Skriptkonsole + +Stand: **Opsvorbereitung, keine ausgeführte Browser-/Jobabnahme**. Der Subagent +hat weder Browser, SSH, MCP, Anmeldung, Job noch Policyänderung ausgeführt und +keine Zugangsdaten gelesen. Deployment-v2 und Frozen158 bleiben unverändert. +Neue Playwright-Testdateien oder ein weiteres Testframework wurden nicht angelegt. + +Die Vorlagen liegen geschützt unter +`devstate/output/playwright-private/console-full-v1/`: + +| Datei | Zweck | +| --- | --- | +| `browser-cli.config.template.json` | CLI-Konfiguration mit echten TLS-Prüfungen und privatem Profil | +| `launch-chromium.sh.template` | ausschließlich Browser-Namespace, kein HOME-Override | +| `linux-full-script.sh` | exakte geplante benigne Jobbytes, nicht lokal ausführen | +| `mcp-plan-input.template.json` | einzelner fester Linux-Antrag, Ziel/Zeiten noch einzutragen | +| `acceptance-required.json` | erwartete Pending-, Audit-, Identitäts- und Ausgabewerte | +| `root-policy.template.json` | nicht ausführbare Schema2-Vorlage mit ungelösten Pflichtpins | +| `root-policy-change.review.json` | einmaliger Policy-CAS-/History-/Schließungsplan; kein Mutator | +| `prepared.json` | Einzelhashes und ausdrücklicher Vorbereitungsstatus | + +## Voraussetzungen und Vertrauensbindung + +Zuerst müssen der neue Serverbuild, Migration14 und Web49 tatsächlich gesund +bereitgestellt sein. Die zentrale Rootpolicy ist dabei noch die exakt bekannte +abgelaufene `cf15cbb68b590475df6def28e7dcffb7d88e0ca2d2555a06174fb654eeff05f4`. +Ein Serverbuild allein qualifiziert weder Agent noch Fullprofil. + +Die Cloud-Linux-VM muss separat die neue laufende Agent-/Helpergeneration, +Fullhelper-Readiness, tatsächlichen gehaltenen Helpercodehash, lokale Fullpolicy, +unveränderte Geräteidentität, vertrauenswürdige Uhr und signierten Sync belegen. +Gespeicherte Capabilities müssen insbesondere `script.full_maintenance/1`, den +konkreten `helper.policy.sha256:` und +`helper.binary.sha256:` enthalten. Aus Source, UI-Auswahl oder +Buildartefakten werden keine tatsächlichen Capabilities abgeleitet. Notebook und +Windows-VM sind kein Ziel dieses ersten Abnahmeschritts. + +Vor Browserstart wird die Authkonfiguration ausschließlich lesend über den +geprüften privaten API-TLS-Weg kontrolliert: development/dev/test, Devlogin +aktiviert und Produktions-OIDC ehrlich nicht konfiguriert. Für API18443 ist +**`devstate/api-pki/ca.pem`** die richtige Vertrauensquelle; ein vorhandenes +öffentliches `credentials/server-ca.pem` darf nur bei unabhängig festgestellter +Byte-/Fingerprintgleichheit benutzt werden. Alte HTTP-Helfer wie +`cloud_mvp_acceptance.server(kind=http)` hardcoden noch `pki/ca.pem` und sind +hierfür nicht ungeprüft wiederzuverwenden. Keine Zertifikats-/Namensausnahme. + +Der bestehende strikt geprüfte SSH-Tunnel bindet nur +`127.0.0.1:18443 → Server 127.0.0.1:18443`. Die Browserorigin bleibt exakt +`https://localhost:18443`, passend zum dokumentierten SAN und zur CSRF-Origin. +Ein Tunnel ist weder lokaler RMM-Server noch Enrollment des Notebooks. + +## CLI und Browser ohne Änderung von HOME oder globalem Trust + +Der [Playwright-Skill](/home/kevin/.codex/skills/playwright/SKILL.md) wurde gelesen. +`npx` ist vorhanden. Die lokal gecachte CLI0.1.24 mit Playwright1.66-Alpha wurde +anhand ihrer installierten Quellen geprüft: Config, `userDataDir`, eigener +`executablePath`, `downloadsPath` und redigierte Secret-Namen werden unterstützt. +Der tatsächliche Browser ist der vorhandene Chromium141.0.7390.37 unter +`/home/kevin/Schreibtisch/Coding/rust-discovery/web/node_modules/.cache/playwright-browsers/chromium-1194/chrome-linux/chrome`. +Die Kombination ist noch nicht durch einen Browserstart qualifiziert. + +Runtimeartefakte gehören unter ein neues privates +`output/playwright//`, Modus0700. Dieses Verzeichnis und +`/.playwright-cli/` sind ausgeschlossen. Vorlagen mit `@CASE_DIR@` sind noch nicht +startfähig; Root materialisiert sie auf genau dieses absolute Caseverzeichnis. +Der CLI-Skillwrapper wird **mit `bash`** aufgerufen, nicht ausführbar gemacht. + +Die konfigurierte Browser-Executable ist dieser eigene private Wrapper: + +```bash +#!/usr/bin/env bash +set -euo pipefail +rmm_browser_rw='@CASE_DIR@/browser-rw' +rmm_chromium='/home/kevin/Schreibtisch/Coding/rust-discovery/web/node_modules/.cache/playwright-browsers/chromium-1194/chrome-linux/chrome' +exec /usr/bin/bwrap --die-with-parent --new-session --ro-bind / / \ + --bind "$rmm_browser_rw/nss-root" /home/kevin/.pki \ + --bind "$rmm_browser_rw" "$rmm_browser_rw" \ + --tmpfs /tmp --dev /dev -- "$rmm_chromium" "$@" +``` + +`HOME` bleibt unverändert `/home/kevin`. Nur im Browser-Mountnamespace verdeckt +der private NSS-Baum den bereits vorhandenen Pfad `/home/kevin/.pki`. +Globale Trustdaten werden nicht geöffnet oder verändert. Der einzige zusätzliche +Schreibbind ist `browser-rw`; Rootprofil, Downloads und CLI-Cache liegen darin. +Ein expliziter `userDataDir` und `downloadsPath` vermeiden, dass der Browser +Ausgaben in einem nur für ihn sichtbaren `/tmp` ablegt, auf die der CLI-Treiber +anschließend nicht zugreifen könnte. Netzwerk bleibt für den lokalen Tunnel +erreichbar. Die Konfiguration setzt `ignoreHTTPSErrors:false` und +`chromiumSandbox:true`; bei einem tatsächlichen Startproblem keine stillen +TLS-/Sandboxausnahmen ergänzen. + +Für die spätere lokale Materialisierung sind die erforderlichen Verzeichnisse +`browser-rw/{profile,downloads,cache,nss-root/nssdb}` und `evidence` privat +anzulegen. Konfiguration und Wrapper werden aus den Vorlagen mit dem festen +Casepfad erzeugt; nur der neu erzeugte Browserwrapper erhält0700. Der öffentliche +**API-CA-Beleg** wird per bestehendem geprüften Transport beschafft und unter +`trust/api-ca.pem` abgelegt; dieser Schritt wurde hier nicht ausgeführt. + +Geplante NSS-Einrichtung, noch nicht ausgeführt: + +```bash +rmm_certutil='/home/kevin/Schreibtisch/Coding/rust-discovery/web/node_modules/.cache/nss-tools/root/usr/bin/certutil' +"$rmm_certutil" -N -d "sql:$rmm_case/browser-rw/nss-root/nssdb" --empty-password +"$rmm_certutil" -A -d "sql:$rmm_case/browser-rw/nss-root/nssdb" -n 'RMM fixed API CA' -t 'C,,' -i "$rmm_case/trust/api-ca.pem" +"$rmm_certutil" -V -d "sql:$rmm_case/browser-rw/nss-root/nssdb" -n 'RMM fixed API CA' -u L +``` + +Vor Anmeldung müssen eine leere separate NSS-Fixture die untrusted-CA-Verbindung +und die vertrauende Fixture einen falschen TLS-Namen verweigern. Der positive +Aufruf zu `https://localhost:18443` muss ohne Zertifikatsfehler funktionieren. +Keine Warnseite wegklicken, kein `ignore-certificate-errors`, kein SPKI-Bypass. + +Der bestehende geschützte Login wird erst durch Root zur tatsächlichen Anmeldung +lokal verarbeitet. Die CLI unterstützt `PLAYWRIGHT_MCP_SECRETS_FILE` als private +Dotenv-Datei mit den Namen `RMM_LOGIN_USER` und `RMM_LOGIN_PASSWORD`. Root erzeugt +sie ausschließlich aus dem geprüften bestehenden Login-JSON, ohne Werte zu +loggen oder als CLI-Argumente zu übergeben. Hier wurde sie nicht erzeugt. +CLI-Fill erhält nur den Secret-Namen; die installierte CLI löst und redigiert ihn. +Session-/Cookie-/CSRF-Daten dürfen nicht als ganze Dumps ausgegeben werden. + +Geplante CLI-Funktion, noch nicht ausgeführt; `rmm_case` und `rmm_session` sind +die vorher explizit gesetzten Aufgabenvariablen: + +```bash +rmm_cli() { + env npm_config_offline=true \ + XDG_CACHE_HOME="$rmm_case/browser-rw/cache" \ + PLAYWRIGHT_MCP_SECRETS_FILE="$rmm_case/login.env" \ + bash /home/kevin/.codex/skills/playwright/scripts/playwright_cli.sh \ + --session "$rmm_session" --config "$rmm_case/cli.json" "$@" +} +rmm_cli open https://localhost:18443/ +rmm_cli snapshot +``` + +Keine Zuweisung an `HOME`, `home` oder `CODEX_HOME`. Traces, Videos und vollständige +Netzwerk-/Credentialaufzeichnungen bleiben aus. Artefakte sind private Belege. + +## Fester Antrag über MCP, Genehmigung ausschließlich durch UI-Klick + +Geplante Jobbytes, **nicht lokal ausführen**: + +```sh +set -eu +/usr/bin/id -u +/usr/bin/sleep 12 +printf '%s\n' 'RMM_FULL_CONSOLE_LINUX_V1' +printf '%s\n' 'RMM_FULL_CONSOLE_STDERR_V1' >&2 +``` + +Das sind130UTF-8-Bytes ohne BOM mit SHA256 +`c878ba5b5c37fa3f1b9485c6994d6c57f6f37d01d99d4239c64d264d4ed95336`. +Der begrenzte12-Sekunden-Warteaufruf lässt Zeit, den gespeicherten Runningstatus +über das bestehende4-Sekunden-Polling zu beobachten. Keine Installation, +Dateischreibwirkung, Dienständerung, Downloads oder Neustarts sind enthalten. + +Die Vorlage bindet ausschließlich das bestätigte Cloud-Linux-Asset, +`execution_identity:root`, `privileged_script_profile:full_maintenance_v1`, +`posix_sh`, `arguments:[]`,30Sekunden Laufzeit,4096Ausgabebytes, Parallelität1 und +Stopp nach1Fehler. UTC-Start/Frist werden kurz vor Planung festgelegt und müssen +innerhalb der konkret geprüften Policygültigkeit liegen. Erwartete stdout- +Nachbedingung ist exakt `0\nRMM_FULL_CONSOLE_LINUX_V1\n`; stderr wird anschließend +separat auf `RMM_FULL_CONSOLE_STDERR_V1\n` geprüft. Kein erfundenes +`expected_stderr`-Wirefeld wird hinzugefügt. + +Nach sichtbarer simulierter Anmeldung und separat geprüftem temporärem +Policy-Opt-in ruft Root über die vorhandene autorisierte MCP-Automation nur +`operations.plan(tenant_id,input)` und +`operations.submit(tenant_id,plan_id,idempotency_key)` auf. Einmaliger privater +Checkpoint erhält tatsächliche Planbytes, SHA256, alle Job-/Versuchs-/Ziel-IDs, +Skriptbytes, Zeitfenster und die Submitantwort. Kein Approvaltool oder Browser- +Token darf der MCP-Automation bereitgestellt werden. + +**Vor dem Klick:** `pending_approval`, `job_count:0`, `execution_state:null` sowie +für genau dieses neue Job-/Versuchspaar Jobs0, Outbox0, Permits0 und +Authorizations0 unabhängig lesend nachweisen. Alte Gesamtzähler sind kein +Ersatz. Eine Plan-Zielpreview ist kein bereits ausführbarer Job. Kein Retry. + +## Konkreter UI-Ref-Ablauf + +Alle folgenden `e…` sind ausdrücklich **Platzhalter aus dem unmittelbar vorher +gelesenen Snapshot**, keine erfundenen tatsächlichen Refs. Nach Navigation oder +geändertem DOM erneut `snapshot` und aktuelle Refs benutzen. + +1. Bei frischem Snapshot Benutzername/Passwort-Felder nach ihren tatsächlichen + Labels identifizieren. `rmm_cli fill eUSER RMM_LOGIN_USER`, + `rmm_cli fill ePASSWORD RMM_LOGIN_PASSWORD`, dann tatsächlichen Button + „Anmelden“ klicken. Danach neuer Snapshot: `SIMULIERT`, + `simulated-testprincipal-a` und „kein menschlicher Produktions-Freigabenachweis“ + müssen sichtbar sein. Richtigen Mandanten bestätigen. Kein Loginscreenshot + mit gefüllten Feldern, keine Session-/CSRF-Geheimnisse ausgeben. +2. Nach MCP-Submit und unabhängigem Pending0-Nachweis die **exakte neue + Operation-ID** in „Anträge und Ausführungen“ klicken. Neuer Snapshot: + „Antrag: pending_approval“, Jobanzahl0 und kein Ausführungszustand. Dann + „Unveränderlichen Plan zur Prüfung öffnen“ klicken; erneut Snapshot. +3. Alle festen Ziel-/Agent-/Job-/Versuchs-IDs, `root`, Interpreter, Fullprofil, + Script-/Job-/Planhashes, komplettes Skript, stdout-Nachbedingung, Budgets und + Fristen mit dem MCP-Checkpoint vergleichen. Vollwartungswarnung muss explizit + volle Hostautorität einschließlich Agent/PKI/Rebootmöglichkeiten erklären. + Keine Sandbox- oder No-Reboot-Zusage daraus ableiten. +4. Den tatsächlichen gespeicherten JSON-Block + `pre[aria-label^="Alle festen Zielpreviews"]` verwenden, **nicht `pre.first()`**: + die Konsole enthält zusätzliche Skript-`pre`. Falls der Snapshot dafür keine + Ref liefert, ist ein ausschließlich lesendes + `run-code "async page => ({plan: JSON.parse(await page.locator('pre[aria-label^=\"Alle festen Zielpreviews\"]').innerText())})"` + möglich. Kein `fetch`, `page.request`, Routing, Datenmutation oder künstliches + DOM-/React-State-Umschalten. Exakte zurückgelesene Planbytes unabhängig hashen + und byteweise mit dem MCP-Checkpoint vergleichen; Script- und Jobhash ebenfalls. +5. Der Button **„SIMULIERT: Diesen festen Plan ausdrücklich genehmigen“** muss + zunächst deaktiviert sein. Erst nach den bytegenauen Prüfungen die echte + Checkbox „Ich habe sämtliche festen Ziele, Aktionen, Bytes/Hashes … geprüft“ + per `rmm_cli check eCONFIRM` setzen. Neuer Snapshot, dann exakt diesen jetzt + freigegebenen Button einmal per `rmm_cli click eAPPROVE` klicken. Keine direkte + POST-/DB-Genehmigung, keine erneute Wirkung bei verlorener Antwort. +6. Sofort Operation und „Job “ öffnen. Neuer Snapshot soll während + der begrenzten Wartezeit den tatsächlichen gespeicherten Runningstatus zeigen. + Danach über normale Snapshots/Polling bis zum endgültigen Ergebnis beobachten. + Ein verpasster Running-Snapshot wird ehrlich als nicht beobachtet dokumentiert; + er wird nicht durch einen neuen Job nur für ein Bild ersetzt. +7. „Konsolenergebnis“ muss Zustand, feste Attempt-ID, Revision, Exitcode0, + Trunkierungfalse und getrennte stdout-/stderr-Textansichten zeigen. Es gibt + keinen Live-Ausgabestream. Die vollständigen Originaldaten bleiben darunter. + Optional können die beiden echten Rohbyte-Downloadbuttons mit der vorbereiteten + privaten Downloadablage geprüft und deren Hashes mit dem Checkpoint verglichen + werden. Der endgültige Erfolgsbeleg umfasst immer die gespeicherten Rohbytes. +8. Über den tatsächlichen Button „Abmelden“ ausloggen und nur die eigene + CLI-Session schließen. Keine Browser-/Server-/Agentenprozesse pauschal stoppen. + +## Ergebnis-, Audit- und Schließungsbelege + +Read-only-MCP `jobs.get` muss genau das ursprüngliche Job-/Versuchspaar melden: +`succeeded`, Exit0, keine Trunkierung, `postconditions_passed:true`, +`execution_uid:0`, `privileged_script_profile:full_maintenance_v1` und exakt den +Skripthash. stdout und stderr müssen bytegenau stimmen. Zustände `unknown`, +Timeout, Cancel/Fence oder fehlende Ausgabe sind kein Erfolg und kein Retrygrund. +Die Helper-/Agentjournale müssen denselben genehmigten Versuch und genau eine +Consumption/Wirkung belegen; bestehende History und Identitäten bleiben erhalten. + +Die unabhängige lesende Auditprobe verlangt genau eine passende Authorization, +`approval_origin:dev_test_browser_simulation`, `testsimulation:true`, +`principal:simulated-testprincipal-a` und den exakten Planhash. Für dieses +Job-/Versuchspaar werden Jobs1, Outbox1 und Permits1 erwartet. Der UI-Klick ist ein +Entwicklungsnachweis und keine menschliche Produktionsgenehmigung. Belegstage +„geplant“, „pending“, „UI-simuliert genehmigt“, „native Wirkung“ und +„Ergebnis/Audit geprüft“ getrennt dokumentieren und nach dem Abnahmeschritt pushen. + +Der vorbereitete Policyplan verlangt exakt alten `cf15…`-CAS, unverändertes +Rootflag, ein neues Create-once-Historyverzeichnis, feste Kandidatbytes/hash, +maximal15Minuten, genau ein Cloudziel/Generationen, Fullpolicy- und laufenden +Helpercodehash und ausschließlich den simulierten Principal. Servicesliste leer, +Rebootfalse, keine separaten typisierten APT-/Logfreigaben. Diese Parameter +begrenzen typisierte Aktionen; ein ausdrücklich genehmigtes Fullskript behält +die in der UI angekündigte volle Hostautorität. Originalbytes werden vor der einen atomaren +Ersetzung erhalten; Antwortverlust erlaubt nur Readback desselben Cases. Die +geschützte Policy erhält weiterhin Eigentümer10001/0600. Keine Rollen-/Flag-/ +Ingressänderung, kein Service-Neustart, kein SQL- oder API-Approval ist Teil dieses +Scopewechsels. Das später separat beauftragte MCP-Actor-Provisioning ergänzt +höchstens dessen Root-Planungsrecht; siehe den getrennten Opsvertrag unten. +Nach eindeutig geschlossenem Ergebnis wird über einen separat geprüften +Kandidathash-CAS genau die ursprüngliche abgelaufene `cf15…`-Policy wiederhergestellt +und die Schließung belegt. Bis dahin begrenzt die feste Ablaufzeit neue Starts; +niemals still verlängern. Die Vorlage wurde inzwischen als getrenntes +[Policy-/Actor-Opswerkzeug](script-console-policy-scope.md) umgesetzt, vor jeglicher +Zielaktion vom Hauptagenten zu prüfen. Dadurch wird weder eine tatsächlich +geöffnete Policy noch ein MCP-/UI-Aufruf oder Jobnachweis behauptet. + +## Quellenprüfung und nach dem MVP vorgemerkte Grenze + +Das feste `Action::RunScript.privileged_script_profile` ist Teil der gehashten +Job-/Planbytes. Ein Entfernen/Umdeuten verändert den genehmigten Plan. Policy- und +Codehash sind zusätzliche Qualifikations-/Startgates, keine erfundenen weiteren +Jobpayloadfelder. `agent/src/helper_sync.rs` wählt mit +`general(binding,job.action.full_maintenance())` ausschließlich den richtigen +Fullpin/Profilweg; `agent/src/apt.rs::socket_for` und `invoke_with_control` +erzwingen den Fullsocket und die erneute Fullprobe ohne General-/APT-Fallback. +`privileged-helper/src/control.rs::general_probe` bindet Schema2, Identität, +Policysha, Profil und Binarysha. Der Helper verweigert Fulljobs auf General sowie +nicht passende Jobs auf Full; die gehaltene tatsächliche Codeidentität wird vor +Consume erneut geprüft. Beim Lesen dieser Quellen wurde keine konkrete Umgehung +der Job-/Helperpinbindung festgestellt; das ersetzt keinen nativen Nachweis. + +Die zentrale `RootScope::permits`-Semantik ist derzeit additiv: ein Schema2-Scope +mit `allowed_script_profiles:[full_maintenance_v1]` ermöglicht Full, schließt bei +`allow_root_scripts:true` aber nicht automatisch jedes begrenzte Legacy-Rootskript +aus. Daher keine allgemeine Full-only-Ausschlusszusage. Der konkrete genehmigte +Testplan ist ausdrücklich Full; General und APT bleiben lokal unverändert +gesperrt/gebunden. Strengere zentrale Profil-Ausschlusssemantik ist transparent +für nach dem MVP vorgemerkt; die eingefrorenen158Dateien werden dafür jetzt nicht +verändert. Falls eine tatsächliche Job-/Helperpinumgehung entdeckt wird, ist sie +als Blocker gesondert zu behandeln. + +## Tatsächlich lokal geprüft + +`bwrap --ro-bind / / -- /usr/bin/true` sowie eine separate öffentliche +Marker-/Pipefixture liefen erfolgreich. Der nur im Namespace gebundene private +NSS-Pfad funktioniert, `HOME` bleibt `/home/kevin`, geerbte Pipe-FDs bleiben offen +und die globalen `.pki`-Verzeichnismetadaten bleiben identisch. Dafür wurde kein +Browser gestartet und kein tatsächlicher Trust-/Login-/Serverinhalt gelesen. +Config-, Wrapper- und JSONsyntax sowie die geplanten Script-/Ausgabebytes werden +lokal geprüft. Browserkompatibilität, NSS-/TLS-Verhalten im echten Chromium, +Authentifizierung, Ref-Klick, Fulljob, Audit und Schließung sind **noch offen**. + +### Anschließender tatsächlicher Harnessbefund des Hauptagenten + +Der Hauptagent hat später den privaten Browsercase +`output/playwright/51c274c9-9ddc-42db-8684-5fec7877977d` vorbereitet. Er meldete +tatsächlichen geprüften öffentlichen API-CA-Bezug, Devlogintrue/OIDCfalse, +NSS-Erfolg und den privaten Loopback-SSH-Tunnel. Es wurden keine Secrets ausgegeben. +Diese Befunde stammen vom Hauptagenten, nicht aus einem Browserlauf des +vorbereitenden Subagenten. + +Erster Chromiumstart: Crashpad scheiterte vor Datenbank-/RMM-Wirkung. Ein privates +zusätzliches `XDG_CONFIG_HOME` im bereits vorbereiteten `browser-rw`-Schreibbaum +behebt dessen fehlenden Schreibpfad, ohne HOME zu ändern. + +Zweiter Start: Die Chromium-Sandbox verweigerte verschachtelte Usernamespaces. +Der tatsächliche Grund war `/proc/self/uid_map: Read-only file system` im +Bubblewrap-Namespace; außerhalb funktionierte die schmale `unshare -Ur true`- +Probe. Der Hauptagent ergänzte im **eigenen materialisierten Casewrapper** +`--unshare-pid --proc /proc`. Die entsprechende verschachtelte Namespaceprobe +bestand danach. Der dritte Browserstart wurde mit aktiviertem Chromium-Sandbox- +und TLS-Verifikationsschutz begonnen; daraus folgt noch kein Login-, +Genehmigungs- oder Joberfolg. + +Die vorbereiteten Vorlagendateien wurden während dieses laufenden Root-Cases +bewusst nicht verändert oder nachträglich als dessen tatsächlich verwendete +Wrapperbytes ausgegeben. Dessen konkrete Config-/Wrapperhashes und Ergebnisse +sind im tatsächlichen Case separat zu erhalten. Bei einem neuen Harnesscase ist +die eng belegte `/proc`-/private-XDG-Korrektur ausdrücklich einzubeziehen. Keine +Zertifikats-, Browser-Sandbox-, Root-/Job- oder Helpergrenze wurde dafür +abgeschaltet. Bis zu diesem gemeldeten Harnessstand war keine Policy geöffnet +und kein RMM-Job ausgeführt. diff --git a/docs/script-console-policy-scope.md b/docs/script-console-policy-scope.md new file mode 100644 index 0000000..77fb9e4 --- /dev/null +++ b/docs/script-console-policy-scope.md @@ -0,0 +1,256 @@ +# Begrenzter Policy- und MCP-Root-Bootstrap für die Linux-Skriptkonsole + +`deploy/script_console_policy_scope.py` ist eine getrennte Opsquelle. Sie verändert +keine158Frozen-Produktdateien, Migrationen, Agenten, Units, Serverflags, Images, +Tokens oder Sitzungen. **Aktueller korrigierter Quellstand lokal geprüft, noch +nicht auf dem Server ausgeführt; früherer Vorwirkungsabbruch unten dokumentiert.** +Kein tatsächlicher Scope oder Actor wurde durch den Subagenten +geändert; Native-Attestation und Zielbelege werden nicht erfunden. + +## Konkrete Autorisierungsentscheidung + +Der User hat AI/MCP-Skriptplanung mit ausdrücklich erlaubten Rootrechten und +separater menschlicher WebUI-Genehmigung beauftragt. Der Hauptagent stellte +öffentlich und rein lesend fest: Der bestehende Actor +`automation:11111111-1111-4111-8111-111111111111` besitzt sieben Standardrechte, +jedoch kein `root:execute`. Der simulierte UI-Actor besitzt Root- und +Genehmigungsrechte. `jobs::plan` verlangt Rootberechtigung und passenden Rootscope +bereits vom Planersteller; spätere Prüfungen beziehen sowohl ursprünglichen +Planersteller als auch UI-Genehmiger ein. Ein ausschließlich auf den simulierten +Principal begrenzter Scope kann deshalb den beauftragten MCP-Rootablauf nicht +tragen. + +Der Hauptagent hat auf Grundlage dieses Userauftrags den separaten, konkreten +Bootstrap zur Ergänzung ausschließlich `root:execute` für genau diesen bestehenden +Dev/Test-Automation-Actor angeordnet. Dies ist MVP-Konfiguration und keine +Jobgenehmigung. Kein allgemeines Rollenupdate und kein Defaultwechsel anderer +Tenants wird implementiert. Der Token bleibt derselbe; `plans:approve`, +`plans:revoke`, `system:execute`, Sessions und Tokens werden nicht hinzugefügt. +Die interaktive Genehmigungsgrenze bleibt auch bei vorhandener Root-Planungs- +berechtigung bestehen. + +## Zwei bewusst getrennte Vorgänge + +1. `prepare-mcp-root-local` und `provision-mcp-root`: einmalige Ergänzung genau + eines Rechts, ausschließlich bei geschlossenem bekannten Rootpolicybestand. + Kein automatisches Öffnen eines Scopes. +2. `prepare-local`, `open`, `read`, `close`: separat geprüftes15-Minuten-Fenster + für genau ein tatsächlich qualifiziertes Cloud-Linuxziel, beide bestehenden + Actor-IDs und exakt den Fullpolicy-/Helpercodepin. `open` verändert keine + Memberships. `close` restauriert ausschließlich die eigenen gesicherten alten + Policybytes. + +Jeder Vorgang hat eigenen unveränderlichen lokalen/entfernten Intent, UUID, +Source-/Supporthashes, lokalen Aufrufmarker vor SSH und entfernte Einmalmarker +vor Wirkung. Antwortverlust oder Fehler nach einem Aufruf erlaubt ausschließlich +`read` desselben Cases, keine Wiederholung, keine neue Frist und keinen neuen +Case als automatische Reparatur. + +## Separates MCP-Recht: genaue Transaktion + +Die feste Vorbedingung ist exakt der vorhandene Actor mit Kind `automation`, +`revoked_at:null` und dieser unveränderten geordneten Rechtefolge: + +```text +inventory:read, logs:read, operations:read, operations:plan, +operations:submit, jobs:cancel, scripts:execute +``` + +Der Bootstrap verlangt das explizit von Root überprüfte tatsächliche Runtimeimage +auf beiden Rollen, Development-/Devlogin-Konfiguration, unveränderte Rootflags +und das bekannte Read-only-Policymount. `/auth/config` wird privat über korrekt +verifiziertes API-TLS mit `api-pki/ca.pem` und Name `localhost` gelesen. Die +Rootpolicy muss exakt Hash +`cf15cbb68b590475df6def28e7dcffb7d88e0ca2d2555a06174fb654eeff05f4`, +Schema1/Development und bereits abgelaufen sein. Der Tenant hat genau30Jobs, +30Outboxzeilen,26Permits und keinen offenen/unklaren Job. + +Ein neues rootprivates Historyverzeichnis erhält Intent und vollständigen +öffentlichen Vorherbeleg. Der entfernte `provision-entered`-Marker wird vor SQL +fsync-gesichert. Danach läuft genau eine feste Transaktion: + +- `BEGIN ISOLATION LEVEL SERIALIZABLE`, expliziter Tenantkontext. +- `UPDATE memberships SET permissions=array_append(permissions,'root:execute')` + ausschließlich mit festem Tenant/Actor, Kind, Revocation-NULL und exaktem + Array-CAS sowie erneutem30/30/26-/Closed-Prädikat im Statement. +- `RETURNING` liefert nur öffentliche Actorfelder. Ein Count0 führt über den + tatsächlichen Countassert zu einem Transaktionsfehler vor `COMMIT`; + `ON_ERROR_STOP` beendet psql, die Verbindung rollt zurück. Genau eine Zeile ist + aufgrund des vorhandenen Tenant-/Principal-Primärschlüssels möglich. +- Nach Commit müssen ausschließlich die fest erwarteten acht Actorrechte + vorliegen. Alle anderen Membershipzeilen werden über einen konsistenten + SHA256-Fingerprint verglichen; Job-/Outbox-/Permitzähler und geschlossene + Policybytes/Inode sowie Rollen/Flags bleiben erhalten. + +SQL-/Vorher-/Nachher-/Ergebnisbelege sind privat und create-once. Eine verlorene +Commitantwort wird niemals als fehlender Commit interpretiert; `read` zeigt +tatsächlichen Actorzustand und erhaltene Marker. Es gibt keinen Schreibpfad zu +Authorizations, Jobs, Outbox, Grants oder Auditgenehmigungen. + +## Temporärer Fullscope und seine Belege + +`prepare-local` verlangt den Pfad zu einer tatsächlichen `attested.json` und den +vom Hauptagenten ausdrücklich akzeptierten vollständigen SHA256. Der Loader +verlangt die bestehende Post-Attestation-Form mit drei Originalsamples samt +Hashbindung, bestätigter Erhaltung, normalem signiertem Sync, zwei gespeicherten +Heartbeatfortschritten, Queuekonvergenz und Tenant-RLS-Verweigerung. Tatsächliche +Rootprozesse, Fullpin und Codehash in den Samples müssen zusammenpassen. Ohne +diesen fertigen akzeptierten Beleg entsteht kein lokaler Scopeintent. + +Die Policy hat genau einen Schema2-Scope: konkreter Tenant/Asset/Agent und +Generationen aus dem nativen Fullpin, die zwei festen Principal-IDs, tatsächlicher +Fullpolicyhash und laufender Helpercodehash, `allow_root_scripts:true`, +`allowed_script_profiles:[full_maintenance_v1]`, leere Servicesliste, +`allow_reboot:false`, keine APT-/Rootlogfelder. Die Frist wird bei lokaler +Vorbereitung unveränderlich auf900Sekunden festgelegt und beim Öffnen nochmals +gegen die Serverzeit geprüft. Vergangene, künftig beginnende oder längere +Freigaben sowie Scope0 werden verweigert. + +`open` verlangt zusätzlich frisch gespeicherte authentifizierte Online-/Sync- +Zustände, den gleichen Boot und passende Generationen, beide Fullcap-Pins, +Migrationen1–14 und keine ungeschlossenen Jobs. Beide tatsächlichen Memberships +werden erneut geprüft. Automation muss exakt die separat bereitgestellten acht +Rechte haben; der simulierte Genehmiger braucht seine bestehenden Plan-, Skript-, +Root- und UI-Genehmigungsrechte. Es werden keine Rechte erzeugt, wenn sie fehlen. + +Vor dem Öffnen wird der alte geschützte Policybestand erneut auf genauen +`cf15…`-Hash und abgelaufenes Schema1 verglichen. Rootprivate Originalbytes und +vollständige Dateimetadaten werden erhalten, anschließend der Einmalmarker +geschrieben. Die unveränderlichen Kandidatbytes werden mit Eigentümer10001 und +Modus0600 auf demselben Dateisystem vorbereitet; unmittelbar vor einer einzigen +atomaren Ersetzung werden alte Bytes und Inode nochmals verglichen. Danach +werden tatsächliche neue Bytes und unveränderte Rollen/Flags belegt. Keine +Dienstaktion und keine Datenbankschreiboperation ist Teil von `open`. + +`close` benötigt keinen noch online erreichbaren Client und keine frischen Caps: +eine Schließung darf auch nach Ablauf oder bei Offlinezustand erfolgen. Es +akzeptiert nur den eigenen unveränderten Remoteintent, den erhaltenen `open`- +Marker, exakte eigene aktuelle Kandidatbytes und den eigenen originalen +`cf15…`-Backupbestand. Fremde oder nachträglich geänderte Policies werden niemals +pauschal ersetzt. Der Close-Marker wird vor Wirkung gesichert; ein weiterer +Bytes-/Inode-CAS erfolgt vor der atomaren Restaurierung. Alte Policybytes, +Eigentümer, Gruppe, Modus und mtime werden wiederhergestellt und ihre abgelaufene +Grenze geprüft. Die atomare Ersatzdatei hat nachvollziehbar einen neuen Inode; +historische Inode-/ctimewerte bleiben im unveränderten Beleg, nicht als behauptete +Wiederherstellung. Alle Historydateien und Runtime-Tags bleiben erhalten. + +`read` erstellt weder Casepfad noch Lock und führt keine Reparatur aus. Auch ein +fehlender Case oder Policy-Lesefehler erlaubt Readback anderer erhaltener Felder. +Ein gleichnamiger fremder Intent wird verweigert. Die Worker dieser Quelle +serialisieren Policy-/Membership-Änderungen über einen geschützten Lock; parallele +ältere Root-Policyschreiber müssen durch den Hauptagenten ausgeschlossen werden. +Der Lock behauptet keine Kontrolle über andere Rootprogramme. + +## Geplante Bedienung, nicht ausgeführt + +Erst nach Rootreview der eingefrorenen Quelle und des konkreten Intents: + +```text +python3 deploy/script_console_policy_scope.py prepare-mcp-root-local --expected-server-image sha256:ROOT_REVIEWED_ACTUAL_IMAGE +python3 deploy/script_console_policy_scope.py provision-mcp-root --id ACTOR_CASE --execute-mcp-root-provision +python3 deploy/script_console_policy_scope.py read --id ACTOR_CASE + +python3 deploy/script_console_policy_scope.py prepare-local --attestation /path/to/actual/attested.json --accepted-attestation-sha ROOT_ACCEPTED_SHA256 --expected-server-image sha256:ROOT_REVIEWED_ACTUAL_IMAGE +python3 deploy/script_console_policy_scope.py open --id SCOPE_CASE --execute-policy-open +python3 deploy/script_console_policy_scope.py read --id SCOPE_CASE +# Danach separat: MCP-Antrag → pending0 → tatsächlicher UI-SIM-Klick → Ergebnis. +python3 deploy/script_console_policy_scope.py close --id SCOPE_CASE --execute-policy-close +python3 deploy/script_console_policy_scope.py read --id SCOPE_CASE +``` + +Platzhalter sind absichtlich nicht ausführbar. Der bestehende Hauptcheckout mit +geschützter `credentials/server.conf` ist der Standard-SSH-Zugangsroot; es gibt +keinen Linux-VM-Aufrufpfad. Ausschließlich der bereits unabhängig vertraute +Cloudserver88.99.80.202 bzw. dessen fester Name ist zulässig. SSH ist +Bootstraptransport, keine Job- oder Approvalautorität. + +## Semantikgrenzen + +Ein Scope begrenzt/verweigert, genehmigt aber niemals einen Job. Die zentrale +Profilzulassung bleibt additiv und wird nicht als allgemeiner Ausschluss aller +Legacy-Rootskripte dargestellt; dies ist nach dem MVP vorgemerkt. General/APT +bleiben lokal unverändert gebunden/gesperrt. Leere typisierte Service-/Reboot-/ +APT-Rechte sind keine Sandbox eines ausdrücklich genehmigten Fullskripts. Der +konkrete später genehmigte Plan bindet vollständige Skriptbytes, Fullprofil, +Identität, Ziel/Versuch, Budgets und Fristen. Root-/Helperpins, Uhr, Peer, +Consumption, Startgrant und WebUI-Genehmigung werden weiterhin unabhängig geprüft. + +## Tatsächliche lokale Prüfungen + +- Python-Syntax und beide getrennten Intentformen geprüft, nur temporäre + synthetische Attestationsfixtures. Unbekannter akzeptierter Hash und geänderte + Originalsamplebytes werden verweigert. Kein tatsächlicher Nativebeleg wurde + dadurch erzeugt oder als akzeptiert markiert. +- Acht Kandidatenabweichungen, vergangene/künftige/zu lange Öffnungsfenster, + fremde Close-Policy, Wiederholungsmarker und rein lesendes Verhalten bei + fehlendem Case geprüft. Frozen158 und Deployment-v2 bleiben byteidentisch. +- Die **tatsächliche aus der Quelle extrahierte** SQL-Transaktion wurde auf einer + frischen isolierten PostgreSQL-Fixture mit `--network none`, ohne Ports oder + reale Zugangsdaten ausgeführt: exakt ein7→8-Rechte-Commit erfolgreich; zweiter + Aufruf, abweichende Ausgangsrechte und offener Job abortieren vor Commit ohne + Überschreiben. Anderer Tenantactor unverändert. Die Fixture bildet nur das + benötigte Schemasubset ab und ist kein RLS-/Produktionsnachweis; der eigene + Testcontainer samt Testvolume wurde anschließend entfernt. + +Belege stehen unter `devstate/script-console-policy-scope-local-review/`. +Reale Native-Attestation, Serverrollen, Membership-CAS, Policyöffnung/-schließung, +UI-Genehmigung und Jobwirkung sind erst durch den Hauptagenten auszuführen und +getrennt nachzuweisen. Die lokalen Tests geben keine Serverfreigabe vorweg. + +### Tatsächlicher erster Provisionierungsversuch und Parserkorrektur + +Der Hauptagent führte den ersten expliziten Provisionierungsversuch +`6ba73b0b-b42f-42d6-966a-62d523315ee8` mit Source +`cb7f0984a0f98065018e8f190bedba1454bf53347c3280751e4d0ccf39a21624` +aus. Er brach vor entferntem Case und vor SQL ab. Der unabhängige Rootreadback +meldete Casefehlend, Actor weiterhin exakt sieben Rechte, Policy unverändert +`cf15…` mit Inode649002 und Zähler30/30/26/0; Rollenprobe meldete ValueError. +Allenfalls der eigene Serialisierungslock wurde angelegt. Keine Scopeöffnung, +Membership-, Policy-, Job- oder Kernelwirkung wird daraus behauptet. + +Die Ursache wurde anschließend lokal am unveränderten alten Parser reproduziert: +Docker fügt nach dem ausgewählten Go-Template eine zusätzliche Leerzeile hinzu. +Dies wurde tatsächlich mit demselben Template gegen ein öffentliches lokales +Toolimage ohne ausgewählte RMM-Werte beobachtet; keine Zielumgebung oder Secrets +wurden dafür gelesen. Der bisherige dict-Generator verweigerte diese Zeile mit +ValueError. + +Die enge Korrektur ignoriert ausschließlich leere Zeilen. Jede nichtleere Zeile +muss weiterhin ein Gleichheitszeichen, einen ausdrücklich erlaubten Schlüssel +und einen noch nicht vorhandenen Schlüssel enthalten; unbekannte, doppelte, +fehlformatierte und bloß aus Leerzeichen bestehende Zeilen werden verweigert. +Werte werden nicht getrimmt oder normalisiert. Alle Flags, Valuechecks, +Zählergates, Rechte-CAS und Mutationspfade bleiben unverändert. + +Vor der Änderung wurden alte Sourcebytes und sämtliche fünf vorhandenen lokalen +Case-Dateien create-only unter +`devstate/script-console-policy-scope-source-history/` erhalten. Der alte Case +wird nicht wiederholt oder mit dem neuen Sourcehash umgedeutet. Ein neuer Case +ist erst nach Rootreview zulässig. Bei Bedarf kann Root den unveränderten alten +Reader anhand des archivierten Hashes unter deploy rekonstruieren; ein +Readbackfehler wird nicht als fehlende oder erfolgreiche Mutation ausgelegt. + + +## Tatsächlich provisioniertes MCP-Planungsrecht + +Nach Rootreview der Quelle11b4450a wurde der separate neue Fall +`0daffbc0-64df-486c-8df1-8ae5e0a0215c` genau einmal ausgeführt und zusätzlich +lesend geprüft: der bestehende Automation-Testprincipal von DevelopmentA hat +nun genau seine bisherigen sieben Rechte plus `root:execute`. Andere +Mitgliedschaften blieben bytegleich; der Ausdruck erlaubt keine Genehmigung. +Keine Approval-/SYSTEM-/Token-/Sessionrechte wurden ergänzt, kein Job oder +Startgrant erzeugt. Zentrale Rootpolicy bleibt exaktcf15 und abgelaufen, +gleicher Inode; alle drei Zähler30/30/26 und ungeklärt0 blieben erhalten. + +Der frühere Fall6ba73b0b bleibt ein unveränderter Vorwirkungsfehler: tatsächliche +Docker-Ausgabe enthält nach den sieben ausgewählten öffentlichen Envzeilen eine +Leerzeile. Der alte dict-Parser verweigerte davor mitValueError; Remote-Case +fehlte, Actor hatte nachweislich weiterhin sieben Rechte. Die neue Quelle +überspringt ausschließlich leere Zeilen und verweigert unzulässige, doppelte oder +unbekannte nichtleere Felder. Kein Wiederholen des alten Mutationsfalls. + +Ein temporärer Full-Ausführungsscope wurde damit noch nicht geöffnet. Der erste +Root-MCP-Auftrag benötigt weiterhin den akzeptierten aktuellen Nativebeleg, +separate begrenzte Policyöffnung und die tatsächliche interaktive WebUI-Freigabe +seines unveränderlichen Plans. Der gesonderte Provisionierungsschritt folgt dem +expliziten Userauftrag für AI/MCP-Rootwartung und ist keine Jobgenehmigung.