Проверка и завершение требований уровней «3» и «4»

This commit is contained in:
Grbisba
2026-11-06 13:58:50 +03:00
parent 711754bbcd
commit 08ee3fe0b8
30 changed files with 1752 additions and 92 deletions
+6 -5
View File
@@ -4,12 +4,13 @@ set -eu
project_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
cd "$project_root"
if [ ! -d certs ]; then
make key-gen
fi
# Keys and environment must already exist; never rotate keys during restart.
compose() {
docker compose --env-file "${COMPOSE_ENV_FILE:-.env}" -f docker-compose.yml "$@"
if [ -n "${COMPOSE_OVERRIDE_FILE:-}" ]; then
docker compose --env-file "${COMPOSE_ENV_FILE:-.env}" -f docker-compose.yml -f "$COMPOSE_OVERRIDE_FILE" "$@"
else
docker compose --env-file "${COMPOSE_ENV_FILE:-.env}" -f docker-compose.yml "$@"
fi
}
# Validate and build before stopping the API. Recreate containers to apply
+557
View File
@@ -0,0 +1,557 @@
#!/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, '<redacted>')
return re.sub(r'eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+', '<redacted-jwt>', 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()<deadline:
try:
if self.call('GET','/health/ready',expected=None,record=False)['status']==200:
return
except (OSError,http.client.HTTPException):
pass
time.sleep(.25)
raise RuntimeError('API readiness timeout')
def wait_db(self):
deadline=time.monotonic()+45
while time.monotonic()<deadline:
try:
if self.sql('SELECT 1;')=='1':
return
except RuntimeError:
pass
time.sleep(.25)
raise RuntimeError('PostgreSQL readiness timeout')
def write_override(self):
self.override.write_text(json.dumps({'services':{'api':{
'container_name':self.project+'-api', 'image':self.image,
'environment':self.api_env,
'volumes':[{'type':'bind','source':str(self.private/'certs'),'target':'/run/certs','read_only':True}]}}}))
def recreate_api(self):
self.write_override()
self.compose('up','-d','--no-build','--no-deps','--force-recreate','api')
self.wait_ready()
def prepare(self):
certs=self.private/'certs'
certs.mkdir(mode=0o700)
self.run(['openssl','genrsa','-out',str(certs/'private_key.pem'),'2048'])
self.run(['openssl','rsa','-in',str(certs/'private_key.pem'),'-pubout','-out',str(certs/'public_key.pem')])
(certs/'private_key.pem').chmod(0o600)
(certs/'public_key.pem').chmod(0o644)
if platform.system()=='Linux':
self.run(['setfacl','-m','u:65532:rx',str(certs)])
self.run(['setfacl','-m','u:65532:r',str(certs/'private_key.pem'),str(certs/'public_key.pem')])
content=(ROOT/'.env.example').read_text()
values={'HOST_PORT':str(self.port),'POSTGRES_USER':'acceptance','POSTGRES_DATABASE':'acceptance',
'POSTGRES_PASSWORD':self.passwords[0],'REDIS_PASSWORD':self.passwords[1],
'POSTGRES_RUN_MIGRATIONS':'true','POSTGRES_MAX_CONNECTIONS':'10','SESSION_TTL_SECONDS':'3600',
'POSTGRES_CONNECT_TIMEOUT':'500ms','POSTGRES_QUERY_TIMEOUT':'2s'}
for key,value in values.items():
content=re.sub(r'^'+key+r'=.*$',key+'='+value,content,flags=re.MULTILINE)
fd=os.open(self.envfile,os.O_CREAT|os.O_EXCL|os.O_WRONLY,0o600)
with os.fdopen(fd,'w') as stream:
stream.write(content)
self.write_override()
self.summary['docker']=self.run(['docker','version','--format','{{.Server.Version}}'])
self.summary['resources']=self.run(['docker','info','--format','{{.OSType}}/{{.Architecture}} CPUs={{.NCPU}} memory_bytes={{.MemTotal}}'])
self.compose('config','--quiet',record='docker compose [isolated project] config --quiet')
self.compose('build','api',record='docker compose [isolated project] build api')
self.summary['image']=self.run(['docker','image','inspect','--format','{{.Id}}',self.image])
source_files=sorted((ROOT/'service').rglob('*.go'))+sorted((ROOT/'service/migrations').glob('*.sql'))
digest=hashlib.sha256()
for p in source_files:
digest.update(str(p.relative_to(ROOT)).encode()+b'\0'+p.read_bytes())
self.summary['service_source_sha256']=digest.hexdigest()
self.started=True
self.compose('up','-d','--no-build','--wait','--wait-timeout','120',record='docker compose [isolated project] up -d --no-build --wait --wait-timeout 120')
self.wait_ready()
return {'new_project':self.project,'initial_volumes':self.volumes()}
def ids(self):
return {name:self.compose('ps','-q',name) for name in ('api','postgres','redis')}
def volumes(self):
return self.run(['docker','volume','ls','--filter','label=com.docker.compose.project='+self.project,'--format','{{.Name}}']).splitlines()
def public_checks(self):
self.run(['make','check'],record='make check')
self.run(['make','test','BASE_URL=http://127.0.0.1:'+str(self.port)],record='make test BASE_URL=http://127.0.0.1:'+str(self.port))
return {'check_exit':0,'smoke_exit':0,'covers':['wrong password','Basic rejected on private API','X-User-Id rejected/ignored','logout and revoked token','chat access and pagination']}
def actor(self,label):
username='verify_'+uuid.uuid4().hex[:16]
password=secrets.token_urlsafe(24)
user=self.call('POST','/api/v1/users',201,body=dict(username=username,display_name='Verify '+label,password=password))['data']
session=self.call('POST','/api/v1/auth/sessions',201,basic=username+':'+password)['data']
self.tokens.append(session['token'])
return dict(label=label,id=user['id'],token=session['token'],username=username,password=password,expires_at=session['expires_at'])
def schema(self):
names=self.sql("SELECT string_agg(tablename, ',' ORDER BY tablename) FROM pg_tables WHERE schemaname='public';")
require(set(names.split(','))=={'users','chats','chat_members','messages','refresh_tokens','versions'},'unexpected schema tables')
version=self.sql('SELECT version FROM versions;')
require(version=='5','migration version not 5')
constraints=self.sql("SELECT conrelid::regclass::text || '|' || conname || '|' || contype::text || '|' || pg_get_constraintdef(oid) FROM pg_constraint WHERE connamespace='public'::regnamespace ORDER BY 1;")
(self.out/'schema.txt').write_text('tables='+names+'\nversion='+version+'\n'+constraints+'\n')
require('users_username_unique|u|' in constraints,'username uniqueness missing')
require(len([line for line in constraints.splitlines() if '|f|' in line])==4,'expected four FK constraints')
self.alice,self.bob,self.eve=[self.actor(label) for label in ('alice','bob','eve')]
self.chat=self.call('POST','/api/v1/chats',201,actor=self.alice,
body={'title':'Verification chat','member_ids':[self.alice['id'],self.bob['id']]})['data']
self.path='/api/v1/chats/'+self.chat['id']
self.key='chat:'+self.chat['id']
self.call('POST',self.path+'/messages',201,actor=self.alice,body={'text':'Persistent verification message'})
algorithm=self.sql(f"SELECT split_part(password_hash,'$',2) FROM users WHERE id='{self.alice['id']}';")
profile=self.sql(f"SELECT split_part(password_hash,'$',4) FROM users WHERE id='{self.alice['id']}';")
require(algorithm=='argon2id' and profile=='m=65536,t=3,p=4','unexpected password KDF')
# Do not export claims or nonce values; verify the entropy source's output size.
payload=json.loads(base64.urlsafe_b64decode(self.alice['token'].split('.')[1]+'=='))
nonce=base64.urlsafe_b64decode(payload['nonce']+'==')
require(len(nonce)==32,'expected 32 random nonce bytes')
return dict(version=int(version),fk_count=4,password_kdf=algorithm,password_profile=profile,nonce_bytes=len(nonce))
def counts(self):
return json.loads(self.sql("SELECT json_build_object('users',(SELECT count(*) FROM users),'chats',(SELECT count(*) FROM chats),'members',(SELECT count(*) FROM chat_members),'messages',(SELECT count(*) FROM messages),'sessions',(SELECT count(*) FROM refresh_tokens),'version',(SELECT version FROM versions));"))
def migration_repeat(self):
before=self.counts()
self.recreate_api()
after=self.counts()
require(before==after,'re-running migrations changed counts or version')
return dict(before=before,after=after)
def persistence(self):
before,volumes=self.ids(),self.volumes()
self.run(['make','test-persistence','ACTION_SCRIPT=scripts/restart.sh',
'BASE_URL=http://127.0.0.1:'+str(self.port)],record='make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:'+str(self.port))
after=self.ids()
require(all(before[n]!=after[n] for n in before),'a dependency was not recreated')
require(volumes==self.volumes(),'volumes changed during restart')
me=self.call('GET','/api/v1/users/me',actor=self.alice)['data']
require(me['id']==self.alice['id'],'own previous session lost')
history=self.call('GET',self.path+'/messages?limit=100',actor=self.bob)['data']
require(any(x['text']=='Persistent verification message' for x in history['items']),'own message lost')
return dict(before=before,after=after,volumes_preserved=volumes,previous_session_valid=True)
def registration_race(self):
username='race_'+uuid.uuid4().hex[:16]
barrier=threading.Barrier(8)
body={'username':username,'display_name':'Concurrent registration','password':secrets.token_urlsafe(24)}
def worker(_):
barrier.wait(timeout=10)
return self.call('POST','/api/v1/users',expected=[201,409],body=body)['status']
with futures.ThreadPoolExecutor(max_workers=8) as pool:
statuses=list(pool.map(worker,range(8)))
count=int(self.sql(f"SELECT count(*) FROM users WHERE username='{username}';"))
require(statuses.count(201)==1 and statuses.count(409)==7 and count==1,'registration race mismatch')
return dict(concurrency=8,created=1,conflicts=7,rows=count)
def rollback(self):
title='rollback_'+uuid.uuid4().hex
before=self.counts()
self.call('POST','/api/v1/chats',400,actor=self.alice,
body={'title':title,'member_ids':[self.alice['id'],str(uuid.uuid4())]})
after=self.counts()
require(before==after,'partial chat or member data survived rollback')
require(self.sql(f"SELECT count(*) FROM chats WHERE title='{title}';")=='0','partial chat persisted')
return dict(before=before,after=after,failed_step='member INSERT FK after chat INSERT',http_status=400)
def history(self):
chat=self.chat['id']; user=self.alice['id']
self.sql(f"INSERT INTO messages(id,chat_id,sender_id,text,created_at) SELECT gen_random_uuid(),'{chat}','{user}','History fixture '||i, '2020-01-01'::timestamptz+i*interval '1 microsecond' FROM generate_series(1,20000) i; ANALYZE messages;")
require(self.sql(f"SELECT count(*) FROM messages WHERE chat_id='{chat}';")=='20001','history fixture size mismatch')
cursor=self.sql(f"SELECT created_at::text || '|' || id::text FROM messages WHERE chat_id='{chat}' ORDER BY created_at,id OFFSET 10000 LIMIT 1;").split('|')
plans={}
for label,condition in [('first',''),('deep',f" AND (created_at,id)>('{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()<deadline,'Redis recovery timed out')
time.sleep(.2)
self.redis('DEL',self.key)
self.call('GET',self.path,actor=self.bob)
self.call('GET',self.path,actor=self.bob)
return dict(cold_sql=1,warm_cache=True,outsider_status=404,outage_ms=response['duration_ms'],startup_without_redis=True,recovered=True)
def postgres_failure(self):
self.call('GET',self.path,actor=self.alice)
try:
self.compose('stop','postgres')
response=self.call('GET',self.path,503,actor=self.alice)
require(response['data']['error']['code']=='unavailable','wrong database outage error code')
require(response['duration_ms']<3000,'PostgreSQL failure exceeded bounded response')
self.call('GET',self.path,401)
self.call('GET',self.path,401,headers={'Authorization':'Bearer invalid-token'})
readiness=self.call('GET','/health/ready',503)
self.call('GET','/health/live',200)
finally:
self.compose('start','postgres')
self.wait_db()
self.wait_ready()
self.call('GET',self.path,actor=self.alice)
return dict(valid_session_status=503,anonymous_status=401,invalid_token_status=401,ready=503,live=200,
outage_ms=response['duration_ms'],readiness_ms=readiness['duration_ms'],previous_session_recovered=True)
@contextlib.contextmanager
def table_lock(self):
proc=subprocess.Popen(self.cmd+['exec','-T','postgres','sh','-c',
'exec psql -X -q -At -v ON_ERROR_STOP=1 -U "$POSTGRES_USER" -d "$POSTGRES_DB"'],
stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True,cwd=ROOT,env=self.env)
try:
proc.stdin.write("SET statement_timeout='5s'; SET idle_in_transaction_session_timeout='5s'; BEGIN; LOCK TABLE chats IN ACCESS EXCLUSIVE MODE;\n\\echo LOCKED\n")
proc.stdin.flush()
require(bool(select.select([proc.stdout],[],[],8)[0]) and proc.stdout.readline().strip()=='LOCKED','could not acquire table lock')
yield
finally:
if proc.poll() is None:
try: proc.communicate('ROLLBACK;\n\\q\n',timeout=8)
except (subprocess.TimeoutExpired,BrokenPipeError):
proc.kill(); proc.communicate()
def pool_and_deadline(self):
self.api_env['POSTGRES_MAX_CONNECTIONS']='2'
self.recreate_api()
self.redis('DEL',self.key)
peak=0
with self.table_lock():
with futures.ThreadPoolExecutor(max_workers=8) as pool:
barrier=threading.Barrier(8)
def worker(_):
barrier.wait(timeout=10)
return self.call('GET',self.path,503,actor=self.alice)
jobs=[pool.submit(worker,i) for i in range(8)]
while not all(job.done() for job in jobs):
count=int(self.sql("SELECT count(*) FROM pg_stat_activity WHERE application_name='mtusi-api';"))
peak=max(peak,count)
time.sleep(.05)
results=[job.result() for job in jobs]
require(peak==2,'pool maximum not applied/observed')
require(all(1500<r['duration_ms']<3000 for r in results),'request budget not enforced')
self.api_env['POSTGRES_MAX_CONNECTIONS']='10'
self.recreate_api()
self.call('GET',self.path,actor=self.alice)
raw=self.compose('logs','--no-color','api')
require('max_conns=10' in raw and 'statement_timeout_ms=2000' in raw and 'connect_timeout=500ms' in raw,'pool startup configuration missing')
return dict(test_limit=2,observed_peak=peak,requests=8,status=503,durations_ms=[r['duration_ms'] for r in results],
restored_limit=10,query_timeout_ms=2000,connect_timeout_ms=500)
def configuration(self):
observed={}
try:
for label,session,legacy,expected in [('default','','',3600),('legacy','','24h',86400),('primary','2','invalid-legacy',2)]:
self.api_env.update(SESSION_TTL_SECONDS=session,JWT_REFRESH_TOKEN_LIFETIME=legacy)
self.recreate_api()
result=self.call('POST','/api/v1/auth/sessions',201,basic=self.alice['username']+':'+self.alice['password'])['data']
self.tokens.append(result['token'])
claims=json.loads(base64.urlsafe_b64decode(result['token'].split('.')[1]+'=='))
require(claims['exp']-claims['iat']==expected,'session lifetime precedence mismatch')
observed[label]=expected
invalid=[('SESSION_TTL_SECONDS','0'),('SESSION_TTL_SECONDS','abc'),
('POSTGRES_MAX_CONNECTIONS','0'),('POSTGRES_CONNECT_TIMEOUT','0s'),('POSTGRES_QUERY_TIMEOUT','0s')]
self.api_env={'SESSION_TTL_SECONDS':'3600'}
self.write_override()
for name,value in invalid:
proc=subprocess.run(self.cmd+['run','--rm','--no-deps','-e',name+'='+value,'api'],capture_output=True,text=True,cwd=ROOT,env=self.env,timeout=15)
require(proc.returncode!=0 and 'load server config' in proc.stderr,'invalid config was not rejected')
return dict(lifetime_seconds=observed,invalid_configurations_rejected=len(invalid))
finally:
self.api_env={'SESSION_TTL_SECONDS':'3600'}
self.recreate_api()
def contract_edges(self):
before=len(self.http_rows)
self.call('GET','/api/v1/chats/not-a-uuid',400,actor=self.alice)
self.call('GET','/api/v1/chats?limit=101',400,actor=self.alice)
self.call('GET',self.path+'/messages?cursor=invalid',400,actor=self.alice)
self.call('GET',self.path+'/messages?limit=1&limit=2',400,actor=self.alice)
for members,title in [([self.alice['id']],' '),([self.bob['id']],'No creator'),([self.alice['id']]*2,'Duplicates')]:
self.call('POST','/api/v1/chats',400,actor=self.alice,body={'title':title,'member_ids':members})
self.call('POST',self.path+'/messages',400,actor=self.alice,body={'text':'Spoofed','sender_id':self.bob['id']})
for fields in [dict(username='UPPER',display_name='Valid',password='Valid-password-123'),
dict(username='valid_name',display_name=' ',password='Valid-password-123'),
dict(username='valid_name',display_name='Valid',password='short'),
dict(username='valid_name',display_name='Valid',password='Valid-password-123',extra=True)]:
self.call('POST','/api/v1/users',400,body=fields)
self.call('POST','/api/v1/users',400,headers={'Content-Type':'application/json'},raw='{')
self.call('POST','/api/v1/users',415,headers={'Content-Type':'text/plain'},raw='{}')
return dict(cases=len(self.http_rows)-before,invalid_uuid_status=400,unknown_fields_status=400,malformed_json_status=400,unsupported_media_status=415)
def auth_additional(self):
# Explicit checks beyond the public smoke: forged signatures and unknown user.
bad=self.alice['token'][:-8]+('A' if self.alice['token'][-8]!='A' else 'B')+self.alice['token'][-7:]
self.call('GET','/api/v1/users/me',401,headers={'Authorization':'Bearer '+bad})
self.call('POST','/api/v1/auth/sessions',401,basic='unknown_'+uuid.uuid4().hex+':wrong-password')
return dict(forged_signature=401,unknown_username=401)
def audit(self):
tracked=self.run(['git','ls-files','-z']).split('\0')
dangerous=[name for name in tracked if name and (name=='.env' or name.startswith(('certs/','secrets/','volumes/')) or name.endswith(('.pem','.key','.p12','.pfx')))]
require(not dangerous,'private state tracked in Git')
self.run(['git','diff','--exit-code','upstream/master','--','README.md','contracts','tests'])
findings=[]
for name in tracked:
path=ROOT/name
if not name or not path.is_file(): continue
try: content=path.read_text()
except (UnicodeError,OSError): continue
if re.search(r'-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+',content):
findings.append(name)
require(not findings,'credential-like material tracked: '+', '.join(findings))
return dict(private_paths_tracked=0,jwt_or_private_key_findings=0,readme_contract_tests_unchanged=True,
scope='current tracked tree; complete Git history is not certified')
def finish(self):
if not self.started: return
# Restore temporary API overrides, ensure dependencies recover, then stop only our project.
self.api_env={'SESSION_TTL_SECONDS':'3600'}
self.write_override()
self.compose('start','postgres','redis')
self.wait_db()
self.recreate_api()
self.compose('up','-d','--no-build','--wait','--wait-timeout','60')
self.transcript.append('\nFinal isolated state before shutdown:\n'+self.compose('ps','-a')+'\n')
raw=self.compose('logs','--no-color','--timestamps','api')
selected=[line for line in raw.splitlines() if any(marker in line for marker in
('postgres_pool_config','HTTP server started','redis unavailable at startup'))]
(self.out/'startup.txt').write_text(self.safe('\n'.join(selected))+'\n')
volumes=self.volumes()
self.compose('down')
require(volumes==self.volumes(),'cleanup deleted volumes')
self.summary['retained_volumes']=volumes
self.summary['isolated_stack_stopped']=True
self.summary['ended_utc']=utc()
self.flush()
def execute(self):
try:
for name,action in [('fresh_build_and_start',self.prepare),('public_check_and_smoke',self.public_checks),
('schema_kdf_and_session_randomness',self.schema),('configuration_compatibility',self.configuration),
('contract_validation_edges',self.contract_edges),('repeat_migrations',self.migration_repeat),
('full_persistence',self.persistence),('username_registration_race',self.registration_race),
('chat_creation_rollback',self.rollback),('history_20000_and_explain',self.history),
('session_expiry_seconds',self.expiry),('additional_authentication',self.auth_additional),
('redis_cache_and_failure',self.redis_failure),('postgres_failure_and_recovery',self.postgres_failure),
('pool_limit_and_sql_deadline',self.pool_and_deadline),('tracked_secrets_and_contract_audit',self.audit)]:
self.check(name,action)
self.summary['success']=True
finally:
self.finish()
self.flush()
def main():
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument('--port',type=int,default=18084)
parser.add_argument('--output',default='evidence/levels-3-4')
args=parser.parse_args()
Verification(args.port,args.output).execute()
print('PASS: levels 3/4 verification finished; isolated volumes retained; original stack unchanged.',flush=True)
if __name__=='__main__':
main()