#!/usr/bin/env python3 """Verify lab2 levels 3/4 on an isolated Compose project; retain its volumes. Uses Python stdlib, Docker Compose and OpenSSL. Existing public tests are run unchanged. Credentials stay in ignored secrets/; evidence contains no tokens. """ import argparse import base64 import concurrent.futures as futures import contextlib import csv import datetime as dt import hashlib import http.client import json import os from pathlib import Path import platform import re import secrets import select import socket import subprocess import threading import time import uuid from urllib.parse import quote ROOT = Path(__file__).resolve().parents[1] def utc(): return dt.datetime.now(dt.timezone.utc).isoformat().replace('+00:00', 'Z') def require(condition, message): if not condition: raise RuntimeError(message) class Verification: def __init__(self, port, output): self.port = port with socket.socket() as probe: probe.bind(('127.0.0.1', port)) self.run_id = dt.datetime.now(dt.timezone.utc).strftime('%Y%m%dT%H%M%SZ') + '-' + uuid.uuid4().hex[:6] self.project = 'lab2-verify-' + self.run_id.lower() self.private = ROOT / 'secrets' / 'levels-3-4' / self.run_id self.private.mkdir(parents=True, mode=0o700) self.out = ROOT / output self.out.mkdir(parents=True, exist_ok=True) self.envfile, self.override = self.private / '.env', self.private / 'compose.json' self.env = {k: v for k, v in os.environ.items() if not k.startswith( ('COMPOSE_', 'POSTGRES_', 'REDIS_', 'JWT_', 'SESSION_', 'APP_', 'APPLICATION_')) and k != 'HOST_PORT'} self.env.update(COMPOSE_PROJECT_NAME=self.project, COMPOSE_ENV_FILE=str(self.envfile), COMPOSE_OVERRIDE_FILE=str(self.override)) self.cmd = ['docker', 'compose', '--project-name', self.project, '--env-file', str(self.envfile), '-f', str(ROOT / 'docker-compose.yml'), '-f', str(self.override)] self.image = 'mtusi-messenger:' + self.project self.passwords = [secrets.token_urlsafe(32), secrets.token_urlsafe(32)] self.tokens = [] self.http_rows, self.checks, self.transcript = [], [], [] self.summary = dict(run_id=self.run_id, started_utc=utc(), project=self.project, port=port, commit=self.run(['git','rev-parse','HEAD']), dirty=True, checks=self.checks, scope='isolated Compose; original stack is not restarted') self.api_env = {'SESSION_TTL_SECONDS': '3600'} self.started = False def safe(self, text): for value in self.passwords + self.tokens: text = text.replace(value, '') return re.sub(r'eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+', '', text) def run(self, args, data=None, timeout=180, record=None): result = subprocess.run(args, input=data, capture_output=True, text=True, cwd=ROOT, env=self.env, timeout=timeout) if record: self.transcript.append(f'\n$ {record}\n' + self.safe(result.stdout + result.stderr) + f'\nexit_code={result.returncode}\n') self.flush() require(result.returncode == 0, 'Command failed: ' + (record or ' '.join(args[:3]))) return result.stdout.strip() def compose(self, *args, record=None): return self.run(self.cmd + list(args), record=record) def sql(self, statement): return self.compose_sql(statement) def compose_sql(self, statement): return self.run(self.cmd + ['exec','-T','postgres','sh','-c', 'exec psql -X -q -At -v ON_ERROR_STOP=1 -U "$POSTGRES_USER" -d "$POSTGRES_DB"'], data=statement) def redis(self, *args): return self.run(self.cmd + ['exec','-T','redis','sh','-c', 'REDISCLI_AUTH="$REDIS_PASSWORD" exec redis-cli --no-auth-warning -n 0 "$@"', 'redis-cli'] + list(args)) def flush(self): (self.out/'summary.json').write_text(json.dumps(self.summary, ensure_ascii=False, indent=2)+'\n') (self.out/'checks.txt').write_text(''.join(self.transcript)) if self.http_rows: with (self.out/'http.csv').open('w', newline='') as stream: writer = csv.DictWriter(stream, fieldnames=list(self.http_rows[0]), lineterminator="\n") writer.writeheader() writer.writerows(self.http_rows) def check(self, name, function): started = time.monotonic() try: details = function() or {} except Exception as error: self.checks.append(dict(name=name, status='FAIL', duration_seconds=round(time.monotonic()-started,3), reason=self.safe(str(error)))) self.flush() raise self.checks.append(dict(name=name, status='PASS', duration_seconds=round(time.monotonic()-started,3), details=details)) self.flush() print('PASS: ' + name, flush=True) def call(self, method, path, expected=200, actor=None, body=None, basic=None, headers=None, record=True, raw=None): conn = http.client.HTTPConnection('127.0.0.1', self.port, timeout=5) h = dict(headers or {}) if actor: h['Authorization'] = 'Bearer ' + actor['token'] if basic: h['Authorization'] = 'Basic ' + base64.b64encode(basic.encode()).decode() if body is not None: h['Content-Type'] = 'application/json' started, stamp = time.monotonic(), utc() try: conn.request(method,path,body=raw if raw is not None else (None if body is None else json.dumps(body)),headers=h) response = conn.getresponse() raw = response.read() data = json.loads(raw) if raw else None elapsed = round((time.monotonic()-started)*1000,3) rid = response.getheader('X-Request-Id','') if record: self.http_rows.append(dict(timestamp_utc=stamp, method=method, path=path, status=response.status, duration_ms=elapsed, request_id=rid)) if expected is not None: allowed = [expected] if isinstance(expected,int) else expected require(response.status in allowed, f'{method} {path}: expected {allowed}, received {response.status}') require(bool(rid),'missing request ID') if response.status >= 400: require(data['error']['request_id']==rid,'error request ID mismatch') require(not any(v in json.dumps(data) for v in self.passwords+self.tokens),'credential leak in error') if response.status==401: scheme='Basic' if path=='/api/v1/auth/sessions' else 'Bearer' require(response.getheader('WWW-Authenticate','').startswith(scheme),'missing auth challenge') return dict(status=response.status, data=data, duration_ms=elapsed, request_id=rid) finally: conn.close() def wait_ready(self): deadline=time.monotonic()+45 while time.monotonic()('{cursor[0]}'::timestamptz,'{cursor[1]}'::uuid)")]: query=f"SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id='{chat}'{condition} ORDER BY created_at,id LIMIT 101" plan=json.loads(self.sql('EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) '+query+';')) (self.out/('explain-'+label+'.json')).write_text(json.dumps(plan,indent=2)+'\n') (self.out/('explain-'+label+'.txt')).write_text(self.sql('EXPLAIN (ANALYZE, BUFFERS) '+query+';')+'\n') nodes=[] def walk(node): nodes.append(node) for child in node.get('Plans',[]): walk(child) walk(plan[0]['Plan']) require(any(n.get('Index Name')=='idx_messages_chat_id_created_at_id' for n in nodes),'history index not selected') require(not any(n.get('Node Type')=='Seq Scan' and n.get('Relation Name')=='messages' for n in nodes),'history full scan') plans[label]=dict(execution_ms=plan[0]['Execution Time'],returned=plan[0]['Plan']['Actual Rows'],nodes=[n['Node Type'] for n in nodes]) expected=self.sql(f"SELECT string_agg(id::text,',' ORDER BY created_at,id) FROM messages WHERE chat_id='{chat}';").split(',') ids=[]; path=self.path+'/messages?limit=100' for _ in range(205): page=self.call('GET',path,actor=self.bob)['data'] ids.extend(x['id'] for x in page['items']) if page['next_cursor'] is None: break path=self.path+'/messages?limit=100&cursor='+quote(page['next_cursor'],safe='') require(ids==expected and len(set(ids))==20001,'history traversal lost, duplicated or reordered rows') return dict(messages=len(ids),page_size=100,plans=plans) def expiry(self): self.api_env['SESSION_TTL_SECONDS']='2' self.recreate_api() try: actor=self.actor('expiry') self.call('GET','/api/v1/users/me',actor=actor) expires=dt.datetime.fromisoformat(actor['expires_at'].replace('Z','+00:00')) wait=max(0,(expires-dt.datetime.now(dt.timezone.utc)).total_seconds())+.25 time.sleep(wait) self.call('GET','/api/v1/users/me',401,actor=actor) return dict(session_ttl_seconds=2,legacy_jwt_refresh='24h',before=200,after=401,wait_seconds=round(wait,3)) finally: self.api_env['SESSION_TTL_SECONDS']='3600' self.recreate_api() def redis_failure(self): since=utc() self.redis('DEL',self.key) self.call('GET',self.path,actor=self.alice) self.call('GET',self.path,actor=self.alice) self.call('GET',self.path,404,actor=self.eve) raw=self.compose('logs','--no-color','--since',since,'api') require(raw.count('chat_db_lookup')==1 and 'chat_cache_hit' in raw,'cache miss/hit behavior mismatch') try: self.compose('stop','redis') response=self.call('GET',self.path,actor=self.alice) require(response['duration_ms']<1000,'Redis failure delayed request >=1s') self.call('GET',self.path,401) self.recreate_api() self.call('GET',self.path,actor=self.alice) finally: self.compose('start','redis') deadline=time.monotonic()+30 while True: try: if self.redis('PING')=='PONG': break except RuntimeError: pass require(time.monotonic()