Files
rust-discovery/tools/agent_release.py
T

386 lines
19 KiB
Python
Executable File

#!/usr/bin/env python3
"""Prepare an Ed25519 agent release on the signing host and publish through the catalog API."""
import argparse
import base64
import fcntl
import getpass
import hashlib
import http.client
from http.cookies import SimpleCookie
import json
import os
from pathlib import Path
import re
import ssl
import subprocess
import tempfile
import time
from urllib.parse import urlencode, urlsplit
import uuid
LINUX = 'x86_64-unknown-linux-gnu'
WINDOWS = 'x86_64-pc-windows-msvc'
FILES = {LINUX: ('rmm-agent', 'rmm-privileged-helper', 'rmm-agent-updater'),
WINDOWS: ('rmm-agent-windows.exe', 'rmm-helper-windows.exe', 'rmm-updater-windows.exe')}
WINDOWS_GNU = 'x86_64-pc-windows-gnu'
FILES[WINDOWS_GNU] = FILES[WINDOWS]
LIMIT = 256 * 1024 * 1024
PREFIX = b'rmm.agent-release.v1\0'
def check(test, message):
if not test:
raise ValueError(message)
def encoded(value):
return json.dumps(value, separators=(',', ':'), ensure_ascii=False).encode()
def b64(data):
return base64.urlsafe_b64encode(data).rstrip(b'=').decode()
def fingerprint(path):
digest = hashlib.sha256()
size = path.stat().st_size
check(path.is_file() and 0 < size <= LIMIT, 'invalid release binary size')
with path.open('rb') as f:
for block in iter(lambda: f.read(1024 * 1024), b''):
digest.update(block)
return digest.hexdigest(), size
def verify_native_image(path, target, size):
with path.open('rb') as binary:
header = binary.read(64)
check(len(header) == 64, 'truncated binary header: ' + path.name)
if target == LINUX:
check(header[:6] == b'\x7fELF\x02\x01' and header[16:18] in (b'\x02\x00', b'\x03\x00')
and header[18:20] == b'\x3e\x00', 'Linux x86-64 ELF image required: ' + path.name)
else:
pe = int.from_bytes(header[60:64], 'little')
check(header[:2] == b'MZ' and 64 <= pe <= size - 26, 'Windows PE image required: ' + path.name)
binary.seek(pe)
coff = binary.read(26)
check(coff[:6] == b'PE\0\0\x64\x86' and coff[24:26] == b'\x0b\x02',
'Windows x86-64 PE32+ image required: ' + path.name)
def binaries(folder, receipt, worker_only=False):
record = json.loads(receipt.read_text(encoding='utf-8-sig'))
if 'target' in record and 'sha256' in record:
target, hashes = record['target'], record['sha256']
else:
check(record.get('completed') is True and record['stage'] == 'built_not_deployed', 'completed MSVC receipt required')
target = WINDOWS
entries = record['artifacts']
names = FILES[target][2:] if worker_only else FILES[target]
check(all(entries[name[:-4]]['build_target'] == target for name in names), 'incorrect build target')
hashes = {name: entries[name[:-4]]['sha256'] for name in names}
check(target in FILES, 'unknown release target')
result = []
for name in FILES[target][2:] if worker_only else FILES[target]:
path = folder / name
digest, size = fingerprint(path)
verify_native_image(path, target, size)
check(digest == hashes[name], 'file differs from build receipt: ' + name)
result.append({'artifact_id': str(uuid.uuid5(uuid.NAMESPACE_OID, target + '/' + name + '/' + digest)),
'sha256': digest, 'bytes': size})
return target, result
def openssl(*args):
return subprocess.check_output(['openssl', *map(str, args)], stderr=subprocess.DEVNULL, timeout=20)
def save_once(path, raw, uid=None):
if path.exists():
check(path.read_bytes() == raw, 'existing configuration differs: ' + path.name)
return
with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as f:
try:
f.write(raw)
os.fchmod(f.fileno(), 0o600)
if uid is not None:
os.fchown(f.fileno(), uid, uid)
f.flush()
os.fsync(f.fileno())
os.link(f.name, path)
finally:
os.unlink(f.name)
def provision_folder(path, uid=None):
path.mkdir(mode=0o700, parents=True, exist_ok=True)
check(path.is_dir() and not path.is_symlink(), 'release state directory required')
if uid is not None and path.stat().st_uid != uid:
os.chown(path, uid, uid)
os.chmod(path, 0o700)
def https(value):
url = urlsplit(value)
check(url.scheme == 'https' and url.hostname and not url.username and not url.password
and url.path in ('', '/') and not url.query and not url.fragment, 'HTTPS origin required')
return url
def release_label(platform, official_windows):
if official_windows:
check(platform == WINDOWS_GNU, 'official Windows releases require a GNU x64 build receipt')
return 'windows-gnu-official'
return {LINUX: 'linux', WINDOWS: 'windows', WINDOWS_GNU: 'windows-gnu'}[platform]
def prepare(args):
provision_folder(args.state)
provision_folder(args.state/'private')
with (args.state/'private'/'signing.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
prepare_locked(args)
def prepare_locked(args):
https(args.gateway)
check(0 < args.sequence < 2**63 and re.fullmatch('[A-Za-z0-9.+_-]{1,64}', args.version), 'invalid release version/sequence')
minimum = getattr(args, 'minimum_updater_version', 1)
check(minimum in (1,2), 'unknown minimum updater version')
check(0 < args.days <= 3650, 'invalid validity in days')
platform, blobs = binaries(args.artifacts, args.build_receipt)
label = release_label(platform, getattr(args, 'official_windows', False))
check(minimum == 1 or platform == WINDOWS_GNU, 'version 2 currently applies to the GNU Windows worker')
provision_folder(args.state)
config, private = args.state / 'config', args.state / 'private'
provision_folder(config, args.service_uid)
provision_folder(args.state / 'objects', args.service_uid)
provision_folder(private)
key = private / (label + '.pem')
if not key.exists():
save_once(key, openssl('genpkey', '-algorithm', 'ED25519'))
check(not key.is_symlink() and key.stat().st_mode & 0o077 == 0, 'private release key permissions')
public = openssl('pkey', '-in', key, '-pubout', '-outform', 'DER')
check(len(public) == 44 and public[:12] == bytes.fromhex('302a300506032b6570032100'), 'Ed25519 key required')
pub = public[12:]
ring = {'schema_version': 1, 'generation': 1, 'keys': [{'public_key_hex': pub.hex(), 'platform': platform,
'first_sequence': 1, 'last_sequence': 2**63-1, 'revoked': False}]}
save_once(config / (label + '-keyring.json'), encoded(ring), args.service_uid)
boot = {'gateway_origin': args.gateway.rstrip('/'), 'updater_sha256': blobs[2]['sha256'], 'updater_bytes': blobs[2]['bytes']}
boot_path = config / (label + '-bootstrap.json')
# Keep the original verified worker available for publication into additional
# tenants, even if a newer build also generated a different worker.
stable = args.state / 'bootstrap-workers' / label
provision_folder(stable.parent)
if not boot_path.exists():
save_once(boot_path, encoded(boot), args.service_uid)
existing = json.loads(boot_path.read_bytes())
check(existing['gateway_origin'] == boot['gateway_origin'], 'existing gateway origin differs')
if not stable.exists() and boot == existing:
save_once(stable, (args.artifacts / FILES[platform][2]).read_bytes())
if stable.exists():
check(fingerprint(stable) == (existing['updater_sha256'], existing['updater_bytes']),
'stored bootstrap worker differs from protected configuration')
prepared = args.state / 'prepared' / label / str(args.sequence)
provision_folder(prepared.parent)
if prepared.exists():
prior = json.loads((prepared / 'inputs.json').read_bytes())
check(prior.get('version') == args.version and prior.get('blobs') == blobs
and prior.get('minimum_updater_version', 1) == minimum, 'sequence already bound')
print(prepared / 'envelope.json')
return
now = int(time.time())
manifest = {'schema_version': 1, 'release_id': str(uuid.uuid4()), 'release_sequence': args.sequence,
'version': args.version, 'platform': platform, 'published_at': now, 'expires_at': now + args.days * 86400,
'protocol_major': 1, 'state_schema': 1, 'minimum_updater_version': minimum,
'artifacts': [dict(role=role, **blob) for role, blob in zip(('agent', 'helper'), blobs[:2])]}
raw = encoded(manifest)
with tempfile.TemporaryDirectory(dir=prepared.parent) as tmpdir:
work = Path(tmpdir)
msg = work / 'message'
msg.write_bytes(PREFIX + raw)
sig = openssl('pkeyutl', '-sign', '-rawin', '-inkey', key, '-in', msg)
(work / 'public.der').write_bytes(public)
(work / 'signature').write_bytes(sig)
openssl('pkeyutl', '-verify', '-rawin', '-pubin', '-keyform', 'DER', '-inkey', work / 'public.der',
'-in', msg, '-sigfile', work / 'signature')
output = work / 'release'
output.mkdir()
env = {'schema_version': 1, 'key_id': hashlib.sha256(pub).hexdigest(), 'payload_bytes': b64(raw), 'signature': b64(sig)}
save_once(output / 'envelope.json', encoded(env))
save_once(output / 'inputs.json', encoded({'version': args.version, 'blobs': blobs, 'minimum_updater_version': minimum}))
output.rename(prepared)
print(prepared / 'envelope.json')
class Publisher:
def __init__(self, address, ca):
self.origin = address.rstrip('/')
self.url = https(self.origin)
self.ctx = ssl.create_default_context(cafile=ca)
self.headers = {'Origin': self.origin}
def request(self, method, route, body=None, headers=None):
conn = http.client.HTTPSConnection(self.url.hostname, self.url.port or 443, context=self.ctx, timeout=180)
try:
conn.request(method, route, body=body, headers={**self.headers, **(headers or {})})
reply = conn.getresponse()
data = reply.read(1048577)
check(200 <= reply.status < 300, f'{method} {route.split("?")[0]} returned HTTP {reply.status}')
check(len(data) <= 1048576, 'response exceeds limit')
if reply.getheader('Set-Cookie'):
cookie = SimpleCookie(reply.getheader('Set-Cookie'))
token = cookie['__Host-rmm_session'].value
self.headers['Cookie'] = '__Host-rmm_session=' + token
return json.loads(data) if data else None
finally:
conn.close()
def rotate_pin(state, label, tenant, expected, new_pin):
tenant = str(uuid.UUID(tenant))
check(re.fullmatch('[0-9a-f]{64}', expected), 'expected predecessor SHA-256 required')
directory = state/'config'
default = directory/(label + '-bootstrap.json')
path = default.with_suffix('.' + tenant + '.json')
# The already completed upload attests the API read and stored the object.
# Independently reopen the actual tenant object before changing the pin.
sha, size = fingerprint(state/'objects'/tenant/new_pin['sha256'])
check(new_pin == {'sha256':sha,'bytes':size}, 'uploaded stable updater differs')
with (state/'private'/'bootstrap-rotation.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
if path.exists():
pins = json.loads(path.read_bytes())
else:
baseline = json.loads(default.read_bytes())
pins = {'current':{'sha256':baseline['updater_sha256'],'bytes':baseline['updater_bytes']},'previous':[]}
now = int(time.time())
if pins['current'] == new_pin:
prior = pins['previous'][-1]['pin']['sha256'] if pins['previous'] else None
check(expected in (prior, new_pin['sha256']), 'bootstrap predecessor changed')
return
check(pins['current']['sha256'] == expected, 'bootstrap predecessor changed')
previous = [item for item in pins['previous'] if item['expires_at'] > now
and item['pin'] not in (new_pin,pins['current'])]
previous.append({'pin':pins['current'],'expires_at':now+900})
raw = encoded({'current':new_pin,'previous':previous})
check(len(raw) <= 32768, 'too many concurrent bootstrap rotations')
with tempfile.NamedTemporaryFile(dir=directory,delete=False) as f:
try:
f.write(raw)
os.fchmod(f.fileno(),0o600)
os.fchown(f.fileno(),default.stat().st_uid,default.stat().st_gid)
f.flush()
os.fsync(f.fileno())
os.replace(f.name,path)
finally:
Path(f.name).unlink(missing_ok=True)
fd = os.open(directory,os.O_DIRECTORY)
try:
os.fsync(fd)
finally:
os.close(fd)
def publish(args):
worker_only = args.rotate_worker_only
platform, blobs = binaries(args.artifacts, args.build_receipt, worker_only)
if worker_only:
check(args.envelope is None and args.rotate_bootstrap_from, 'worker rotation requires a predecessor and no release envelope')
else:
check(args.envelope is not None, 'a release envelope is required')
env = json.loads(args.envelope.read_bytes())
manifest = json.loads(base64.urlsafe_b64decode(env['payload_bytes'] + '==='))
check(manifest['platform'] == platform and manifest['artifacts'] == [dict(role=role, **blob)
for role, blob in zip(('agent', 'helper'), blobs[:2])], 'input files differ from release envelope')
check(bool(args.rotate_bootstrap_from) == bool(args.bootstrap_state), 'rotation needs previous SHA and local signing state')
check(not (args.rotate_bootstrap_from and args.bootstrap_worker), 'a rotation uses the new receipt-bound stable worker')
client = Publisher(args.origin, args.ca)
local_username = getattr(args, 'local_username', None)
if local_username:
login = {'username': local_username, 'password': getpass.getpass('WebUI password: '),
'totp_code': getpass.getpass('Authenticator code: ')}
elif args.dev_login_file:
path = args.dev_login_file
check(path.stat().st_mode & 0o077 == 0, 'dev login file requires private permissions')
credentials = json.loads(path.read_bytes())
login = {k: credentials[k] for k in ('username','password')}
else:
login = {'username': args.dev_username, 'password': getpass.getpass('Development WebUI password: ')}
route = '/auth/local/login' if local_username else '/auth/dev/login'
client.request('POST', route, encoded(login), {'Content-Type': 'application/json'})
client.headers['X-RMM-Tenant'] = str(uuid.UUID(args.tenant))
session = client.request('GET', '/auth/session')
client.headers['X-CSRF-Token'] = session['csrf_token']
try:
tenant = str(uuid.UUID(args.tenant))
check(session['tenant_id'] == tenant and 'catalog:write' in session['permissions'], 'tenant catalog write permission required')
path = '/api/v1/tenants/' + tenant
names = FILES[platform][2:] if worker_only else FILES[platform]
paths = [args.artifacts / name for name in names]
if args.bootstrap_worker:
paths[2] = args.bootstrap_worker
sha, size = fingerprint(paths[2])
verify_native_image(paths[2], platform, size)
name = FILES[platform][2]
blobs[2] = {'artifact_id': str(uuid.uuid5(uuid.NAMESPACE_OID, platform + '/' + name + '/' + sha)),
'sha256': sha, 'bytes': size}
for file, blob in zip(paths, blobs):
query = urlencode(dict(artifact_id=blob['artifact_id'], sha256=blob['sha256'], size_bytes=blob['bytes']))
with file.open('rb') as data:
result = client.request('POST', path + '/agent-update-artifacts?' + query, data,
{'Content-Type': 'application/octet-stream', 'Content-Length': str(blob['bytes'])})
check(result['sha256'] == blob['sha256'] and result['size_bytes'] == blob['bytes'], 'artifact receipt differs')
if args.rotate_bootstrap_from:
stable = blobs[-1]
label = release_label(platform, getattr(args, 'official_windows', False))
rotate_pin(args.bootstrap_state,label,tenant,args.rotate_bootstrap_from,
{'sha256':stable['sha256'],'bytes':stable['bytes']})
if worker_only:
print(json.dumps({'tenant_id':tenant,'platform':platform,'updater_sha256':stable['sha256'],
'updater_bytes':stable['bytes']}))
return
result = client.request('POST', path + '/agent-releases', encoded(env), {'Content-Type': 'application/json'})
check(result['release_envelope'] == env, 'published envelope changed')
print(json.dumps({'release_id': result['release_id'], 'version': manifest['version'], 'platform': platform,
'manifest_sha256': result['manifest_sha256']}))
finally:
client.request('POST', '/auth/logout', b'{}', {'Content-Type':'application/json'})
def main():
parser = argparse.ArgumentParser(description=__doc__)
sub = parser.add_subparsers(required=True)
for name, fn in (('prepare', prepare), ('publish', publish)):
cmd = sub.add_parser(name)
cmd.set_defaults(run=fn)
cmd.add_argument('--official-windows', action='store_true', help='Use the dedicated Windows GNU production signing key and bootstrap state')
cmd.add_argument('--artifacts', type=Path, required=True)
cmd.add_argument('--build-receipt', type=Path, required=True)
if name == 'prepare':
cmd.add_argument('--state', type=Path, required=True)
cmd.add_argument('--gateway', required=True)
cmd.add_argument('--sequence', type=int, required=True)
cmd.add_argument('--version', required=True)
cmd.add_argument('--days', type=int, default=90)
cmd.add_argument('--minimum-updater-version',type=int,default=1)
cmd.add_argument('--service-uid', type=int, default=os.getuid())
else:
cmd.add_argument('--origin', required=True)
cmd.add_argument('--bootstrap-state',type=Path,help='Local signing host state for an explicit stable updater rotation')
cmd.add_argument('--rotate-bootstrap-from',help='Compare-and-swap the tenant pin from this SHA-256 after verified upload')
cmd.add_argument('--bootstrap-worker', type=Path, help='Pinned initial stable updater when publishing subsequent code pairs')
cmd.add_argument('--ca', type=Path)
cmd.add_argument('--tenant', required=True)
cmd.add_argument('--envelope', type=Path, help='Prepared agent and helper release')
cmd.add_argument('--rotate-worker-only', action='store_true', help='Rotate the stable worker independently of a code-pair release')
auth = cmd.add_mutually_exclusive_group(required=True)
auth.add_argument('--local-username', help='Sign in with the public WebUI password and a fresh TOTP code')
auth.add_argument('--dev-username')
auth.add_argument('--dev-login-file', type=Path)
args = parser.parse_args()
args.run(args)
if __name__ == '__main__':
main()