Provision explicit MCP root planning right without approval authority
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 18:48:48 +01:00
parent 5b2f07b9c8
commit afccf95e89
3 changed files with 1140 additions and 0 deletions
+552
View File
@@ -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
+332
View File
@@ -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:<FULLHASH>` und
`helper.binary.sha256:<CODEHASH>` 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/<REVIEWED_CASE_UUID>/`, 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 <exakte Job-ID>“ ö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.
+256
View File
@@ -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.