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