243 lines
13 KiB
Python
243 lines
13 KiB
Python
"""Disposable collector-only cycle. No RouterOS clients or capture are opened."""
|
|
import argparse
|
|
import gzip
|
|
import hashlib
|
|
import io
|
|
import json
|
|
import os
|
|
import re
|
|
import runpy
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import tarfile
|
|
import time
|
|
from pathlib import Path
|
|
|
|
owner = runpy.run_path(str(Path(__file__).with_name('chr-netflow-collector-container.py')))
|
|
require = owner['require']
|
|
MAX_PACKET = 128 * 1024 * 1024
|
|
PACKET_PATH = re.compile(r'(?:dist|drizzle|contracts-dist)/(?:[A-Za-z0-9_.-]+/)*[A-Za-z0-9_.-]+\Z')
|
|
|
|
|
|
def verify_packet(directory, digest, require_root=False):
|
|
require(re.fullmatch(r'[a-f0-9]{64}', digest), 'PACKET_DIGEST_REFUSED')
|
|
require(directory.resolve(strict=True) == directory and directory.is_dir(), 'PACKET_DIRECTORY_REFUSED')
|
|
manifest = directory / 'manifest.json'
|
|
info = manifest.lstat()
|
|
require(stat.S_ISREG(info.st_mode) and 0 < info.st_size <= 1048576, 'PACKET_MANIFEST_REFUSED')
|
|
raw = manifest.read_bytes()
|
|
require(hashlib.sha256(raw).hexdigest() == digest, 'PACKET_MANIFEST_DRIFT')
|
|
value = json.loads(raw)
|
|
require(value.get('format') == 'mmapp-netflow-collector-smoke-v1' and
|
|
value.get('cachedSourceRevision') == 'bf3d50e1ff2ee3b5c9268991a255c3b49ce6378e' and
|
|
type(value.get('files')) is list and 1 <= len(value['files']) <= 4096, 'PACKET_MANIFEST_REFUSED')
|
|
total, listed = 0, {'manifest.json'}
|
|
for row in value['files']:
|
|
relative = row.get('path', '')
|
|
require(PACKET_PATH.fullmatch(relative) and
|
|
not any(part in ('.', '..') for part in relative.split('/')) and relative not in listed and
|
|
type(row.get('size')) is int and 0 < row['size'] <= 2 * 1024 * 1024 and
|
|
re.fullmatch(r'[a-f0-9]{64}', row.get('sha256', '')), 'PACKET_FILE_REFUSED')
|
|
item = directory / relative
|
|
info = item.lstat()
|
|
total += row['size']
|
|
require(total <= MAX_PACKET and stat.S_ISREG(info.st_mode) and item.resolve(strict=True) == item and
|
|
info.st_size == row['size'] and hashlib.sha256(item.read_bytes()).hexdigest() == row['sha256'], 'PACKET_FILE_DRIFT')
|
|
listed.add(relative)
|
|
observed = set()
|
|
for folder, directories, filenames in os.walk(directory, followlinks=False):
|
|
parent = Path(folder)
|
|
for entry in [parent, *(parent / name for name in directories + filenames)]:
|
|
info = entry.lstat()
|
|
require(not stat.S_ISLNK(info.st_mode) and
|
|
(not require_root or info.st_uid == 0 and not info.st_mode & 0o022), 'PACKET_OWNERSHIP_REFUSED')
|
|
observed.update((parent / filename).relative_to(directory).as_posix() for filename in filenames)
|
|
require(observed == listed and 'dist/test/traffic-flow-chr-collector-bootstrap.js' in listed, 'PACKET_FILE_SET_DRIFT')
|
|
return {'files': len(listed) - 1, 'bytes': total, 'manifestSha256': digest}
|
|
|
|
|
|
def pack(directory, digest):
|
|
match = re.fullmatch(r'mcp-netflow-smoke-packet-([a-f0-9]{8})', directory.name)
|
|
require(match is not None, 'PACKET_DIRECTORY_REFUSED')
|
|
verified = verify_packet(directory, digest)
|
|
archive = directory.parent / ('mcp-netflow-collector-smoke-' + match[1] + '.tar.gz')
|
|
manifest = json.loads((directory / 'manifest.json').read_bytes())
|
|
script_root = Path(__file__).resolve().parent
|
|
scripts = ('chr-netflow-collector-smoke.py', 'chr-netflow-collector-container.py')
|
|
with archive.open('xb') as destination, gzip.GzipFile(fileobj=destination, mode='wb', filename='', mtime=0) as compressed:
|
|
with tarfile.open(fileobj=compressed, mode='w|', format=tarfile.USTAR_FORMAT) as tar:
|
|
def add(name, body):
|
|
item = tarfile.TarInfo(name)
|
|
item.mode = 0o644
|
|
item.size = len(body)
|
|
tar.addfile(item, io.BytesIO(body))
|
|
for name in scripts:
|
|
add(name, (script_root / name).read_bytes())
|
|
add('packet/manifest.json', (directory / 'manifest.json').read_bytes())
|
|
for row in manifest['files']:
|
|
add('packet/' + row['path'], (directory / row['path']).read_bytes())
|
|
with archive.open('rb') as stream:
|
|
archive_sha = hashlib.file_digest(stream, 'sha256').hexdigest()
|
|
return {**verified, 'archive': str(archive), 'archiveSha256': archive_sha, 'dockerUsed': False, 'networkUsed': False}
|
|
|
|
|
|
class SmokeNamespace:
|
|
"""Only the C alias and one local dummy address, never the transit topology."""
|
|
def __init__(self, run, ip, namespace, checkpoint):
|
|
self.name, self.device = 'nf' + run + 'nc', 'nf' + run + 'cv'
|
|
self.ip, self.namespace, self.checkpoint = ip, namespace, checkpoint
|
|
self.anchor = None
|
|
|
|
def create(self, read_anchor):
|
|
require(self.anchor is None and self.namespace(self.name) is None, 'SMOKE_NAMESPACE_PRESENT')
|
|
anchor = read_anchor()
|
|
require(anchor['namespace'] != anchor['hostNamespace'] and read_anchor() == anchor, 'SMOKE_ANCHOR_DRIFT')
|
|
self.checkpoint('smoke', 'attach-intent', anchor)
|
|
self.ip('netns', 'attach', self.name, str(anchor['pid']))
|
|
require(self.namespace(self.name) == anchor['namespace'] and read_anchor() == anchor, 'SMOKE_ATTACH_UNCONFIRMED')
|
|
self.checkpoint('smoke', 'attach-verified', anchor)
|
|
self.anchor = anchor
|
|
def current():
|
|
require(self.namespace(self.name) == anchor['namespace'] and read_anchor() == anchor, 'SMOKE_ANCHOR_DRIFT')
|
|
links = json.loads(self.ip('-n', self.name, '-j', 'link', 'show'))
|
|
require([item['ifname'] for item in links] == ['lo'], 'SMOKE_NAMESPACE_NOT_EMPTY')
|
|
self.checkpoint('smoke', 'dummy-intent', self.device)
|
|
current()
|
|
self.ip('-n', self.name, 'link', 'add', self.device, 'type', 'dummy')
|
|
current()
|
|
created = json.loads(self.ip('-n', self.name, '-j', '-d', 'link', 'show', 'dev', self.device))
|
|
require(len(created) == 1 and created[0]['ifname'] == self.device and
|
|
created[0]['linkinfo']['info_kind'] == 'dummy' and created[0]['ifindex'] > 0, 'SMOKE_DUMMY_UNCONFIRMED')
|
|
self.ip('-n', self.name, 'address', 'add', '198.18.242.3/32', 'dev', self.device)
|
|
current()
|
|
self.ip('-n', self.name, 'link', 'set', self.device, 'up')
|
|
rows = json.loads(self.ip('-n', self.name, '-j', '-d', 'address', 'show', 'dev', self.device))
|
|
routes = json.loads(self.ip('-n', self.name, '-j', '-4', 'route', 'show', 'table', 'all'))
|
|
require(len(rows) == 1 and rows[0]['ifname'] == self.device and rows[0]['linkinfo']['info_kind'] == 'dummy' and
|
|
rows[0]['ifindex'] == created[0]['ifindex'] and
|
|
'UP' in rows[0]['flags'] and any(row.get('local') == '198.18.242.3' and row.get('prefixlen') == 32
|
|
for row in rows[0]['addr_info']) and all(row.get('dst') != 'default' for row in routes) and
|
|
self.namespace(self.name) == anchor['namespace'] and read_anchor() == anchor, 'SMOKE_DUMMY_UNCONFIRMED')
|
|
self.checkpoint('smoke', 'dummy-verified', rows[0]['ifindex'])
|
|
return anchor
|
|
|
|
def restore(self, assert_anchor_exited):
|
|
require(self.anchor is not None and self.namespace(self.name) == self.anchor['namespace'],
|
|
'SMOKE_NAMESPACE_DRIFT')
|
|
assert_anchor_exited(self.anchor)
|
|
require(not self.ip('netns', 'pids', self.name).strip(), 'SMOKE_NAMESPACE_BUSY')
|
|
self.checkpoint('smoke', 'delete-intent', self.anchor)
|
|
self.ip('netns', 'delete', self.name)
|
|
require(self.namespace(self.name) is None, 'SMOKE_NAMESPACE_RETIREMENT_UNCONFIRMED')
|
|
self.checkpoint('smoke', 'delete-verified', self.anchor)
|
|
|
|
|
|
def linux_ip():
|
|
binary = next((item.resolve(strict=True) for item in (Path('/usr/sbin/ip'), Path('/usr/bin/ip'), Path('/sbin/ip'))
|
|
if item.is_file()), None)
|
|
require(binary is not None and binary.stat().st_uid == 0 and not binary.stat().st_mode & 0o022, 'IP_BINARY_UNPINNED')
|
|
|
|
def call(*args):
|
|
result = subprocess.run([str(binary), *args], env=owner['ENV'], stdin=subprocess.DEVNULL,
|
|
stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=8)
|
|
require(result.returncode == 0 and len(result.stdout) <= 128 * 1024, 'IP_OUTCOME_UNCONFIRMED')
|
|
return result.stdout.decode('utf-8', 'strict')
|
|
return call
|
|
|
|
|
|
def ns_pin(name):
|
|
try:
|
|
row = Path('/run/netns', name).lstat()
|
|
except FileNotFoundError:
|
|
return None
|
|
require(stat.S_ISREG(row.st_mode) and row.st_uid == 0, 'SMOKE_NAMESPACE_HANDLE_UNSAFE')
|
|
return [row.st_dev, row.st_ino]
|
|
|
|
|
|
def run_smoke(run, uid, gid, port, digest):
|
|
docker, attach = owner['local_docker']()
|
|
base = Path(owner['root'](run))
|
|
packet = base / 'packet'
|
|
verify_packet(packet, digest, require_root=True)
|
|
ip = linux_ip()
|
|
require(ns_pin('nf' + run + 'nc') is None, 'SMOKE_NAMESPACE_PRESENT')
|
|
journal = os.open(base / 'collector-smoke.jsonl', os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
|
|
with os.fdopen(journal, 'w', encoding='utf-8') as report:
|
|
def checkpoint(role, phase, value):
|
|
report.write(json.dumps({'role': role, 'phase': phase, 'value': value}, separators=(',', ':')) + '\n')
|
|
report.flush()
|
|
os.fsync(report.fileno())
|
|
|
|
checkpoint('smoke', 'packet-verified', digest)
|
|
owner['prepare_private_storage'](run, uid, gid)
|
|
runner = owner['CollectorContainerOwner'](run, docker, checkpoint)
|
|
runner.create_anchor(uid, gid)
|
|
runner.start_anchor()
|
|
scope = SmokeNamespace(run, ip, ns_pin, checkpoint)
|
|
# Reuse the container owner's live-C admission and retirement checks.
|
|
class Journal:
|
|
value = {}
|
|
class Backend:
|
|
def namespace(self, name):
|
|
return ns_pin(name)
|
|
def root_baseline(self):
|
|
raw = [ip('-j', '-4', 'route', 'show', 'table', 'all'), ip('-j', '-d', 'link', 'show')]
|
|
# Link counters/traffic are outside root configuration; use exact names and ifindex.
|
|
links = sorted((row['ifname'], row['ifindex']) for row in json.loads(raw[1]))
|
|
return hashlib.sha256(json.dumps([json.loads(raw[0]), links], sort_keys=True).encode()).hexdigest()
|
|
def provision(backend, ledger, _plan, _pins, read_collector_anchor):
|
|
baseline = backend.root_baseline()
|
|
anchor = scope.create(read_collector_anchor)
|
|
require(backend.root_baseline() == baseline, 'ROOT_NETWORK_DRIFT')
|
|
ledger.value.update(collectorAnchor=anchor, rootBaseline=baseline, state='created')
|
|
return anchor
|
|
def cleanup(_backend, ledger, _plan, assert_collector_anchor_exited):
|
|
scope.restore(assert_collector_anchor_exited)
|
|
ledger.value['state'] = 'retired'
|
|
backend, ledger, plan = Backend(), Journal(), {'names': {'C': scope.name}}
|
|
pin = runner.create_linux_topology(provision, backend, ledger, plan, {'nonce': run + '0' * 24})
|
|
wait_until = time.monotonic() + 20
|
|
socket = base / 'pg-socket' / '.s.PGSQL.5432'
|
|
while not socket.exists() and time.monotonic() < wait_until:
|
|
time.sleep(.1)
|
|
require(stat.S_ISSOCK(socket.lstat().st_mode), 'PRIVATE_PG_NOT_READY')
|
|
runner.create_collector(uid, gid, port, pin['namespace'], pin['hostNamespace'], digest,
|
|
lambda: verify_packet(packet, digest, require_root=True))
|
|
runner.start_collector(attach)
|
|
runner.retire_exited('collector')
|
|
runner.stop_anchor(lambda: require(ledger.value['state'] == 'created', 'SMOKE_TOPOLOGY_DRIFT'))
|
|
runner.cleanup_linux_topology(cleanup, backend, ledger, plan)
|
|
runner.retire_exited('postgres')
|
|
checkpoint('smoke', 'complete', None)
|
|
return {'collectorSmokeCompleted': True, 'chrMutations': 0, 'capturePerformed': False, 'nativeAcceptance': False}
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser()
|
|
sub = parser.add_subparsers(dest='mode', required=True)
|
|
check = sub.add_parser('check')
|
|
check.add_argument('packet', type=Path)
|
|
check.add_argument('sha256')
|
|
package = sub.add_parser('pack')
|
|
package.add_argument('packet', type=Path)
|
|
package.add_argument('sha256')
|
|
run = sub.add_parser('run')
|
|
run.add_argument('run_id')
|
|
run.add_argument('uid', type=int)
|
|
run.add_argument('gid', type=int)
|
|
run.add_argument('port', type=int)
|
|
run.add_argument('sha256')
|
|
args = parser.parse_args()
|
|
try:
|
|
if args.mode == 'check':
|
|
result = {**verify_packet(args.packet.resolve(), args.sha256), 'dockerUsed': False, 'networkUsed': False}
|
|
elif args.mode == 'pack':
|
|
result = pack(args.packet.resolve(), args.sha256)
|
|
else:
|
|
result = run_smoke(args.run_id, args.uid, args.gid, args.port, args.sha256)
|
|
print(json.dumps(result))
|
|
except (OSError, ValueError, RuntimeError, subprocess.SubprocessError, KeyError) as error:
|
|
print(json.dumps({'completed': False, 'failureClass': type(error).__name__, 'automaticReplay': False}))
|
|
raise SystemExit(1) from None
|