291 lines
15 KiB
Python
291 lines
15 KiB
Python
"""Synthetic media tests prove local review plumbing, never game acceptance."""
|
|
import copy
|
|
import importlib
|
|
import json
|
|
from pathlib import Path
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
import urllib.error
|
|
import urllib.request
|
|
import wave
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(ROOT / 'tools/recon'))
|
|
import fidelity_receipts as receipts
|
|
|
|
try:
|
|
review = importlib.import_module('fidelity_review')
|
|
except ModuleNotFoundError:
|
|
review = None
|
|
|
|
|
|
def fixture(base, side):
|
|
bundle = base / side
|
|
bundle.mkdir()
|
|
for name in ('video.wav', 'audio.wav'):
|
|
with wave.open(str(bundle / name), 'wb') as stream:
|
|
stream.setparams((1, 2, 8000, 0, 'NONE', 'uncompressed'))
|
|
stream.writeframes(b'\0\0' * 16000)
|
|
(bundle / 'trace.json').write_text('{"fixture": true}')
|
|
items = [dict(receipts.identify_file(bundle / name), path=name, role=role,
|
|
synthetic=True, **({'duration_seconds': 2} if role != 'input_events' else {}))
|
|
for name, role in [('video.wav', 'video'), ('audio.wav', 'audio'),
|
|
('trace.json', 'input_events')]]
|
|
value = dict(schema_version=1, receipt_id='test-' + side, session_id='test-session',
|
|
case_id='test-only', evidence_kind='synthetic', status='captured',
|
|
scope='tooling-test', historical=False, identity={},
|
|
platform={'os': 'test', 'execution': 'synthetic'},
|
|
invocation={'argv': ['fixture'], 'cwd': '.'},
|
|
clocks={'wall_start': '2026-01-01T00:00:00Z',
|
|
'wall_end': '2026-01-01T00:00:02Z',
|
|
'monotonic_start': 0, 'monotonic_end': 2},
|
|
artifacts=items, derivatives=[],
|
|
events=[dict(name='landing', artifact='video.wav', media_seconds=0.5,
|
|
elapsed_seconds=0.5, method='procedural', uncertainty_seconds=0.02)],
|
|
limitations=['Synthetic silent audio fixture; no original execution'],
|
|
missing_evidence=[], acceptance={'state': 'open', 'remaining': ['Real capture required']})
|
|
path = bundle / 'receipt.json'
|
|
path.write_text(json.dumps(value))
|
|
imported = receipts.import_receipt(path, bundle, base / 'test-imports')
|
|
return Path(imported['path']), value
|
|
|
|
|
|
class FidelityReview(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory(prefix='fidelity-review-test-')
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.base = Path(self.temp.name)
|
|
self.original, self.value = fixture(self.base, 'original')
|
|
self.port, _ = fixture(self.base, 'port')
|
|
self.output = self.base / 'test-review'
|
|
|
|
def api(self):
|
|
self.assertIsNotNone(review, 'contained review export/server must exist')
|
|
return review
|
|
|
|
def export(self, **kwargs):
|
|
return self.api().export_review(kwargs.pop('original', self.original),
|
|
kwargs.pop('port', self.port), self.output, **kwargs)
|
|
|
|
def server(self):
|
|
server = self.api().make_server(self.output, port=0)
|
|
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
|
thread.start()
|
|
self.addCleanup(server.server_close)
|
|
self.addCleanup(thread.join, 2)
|
|
self.addCleanup(server.shutdown)
|
|
return 'http://127.0.0.1:' + str(server.server_port)
|
|
|
|
def request(self, url, method='GET', headers=None):
|
|
request = urllib.request.Request(url, method=method, headers=headers or {})
|
|
try:
|
|
return urllib.request.urlopen(request, timeout=3)
|
|
except urllib.error.HTTPError as error:
|
|
return error
|
|
|
|
def test_cli_import_export_http_round_trip(self):
|
|
cli = ROOT / 'tools/recon/fidelity_review.py'
|
|
self.assertTrue(cli.is_file(), 'review CLI must export an imported pair')
|
|
result = subprocess.run([sys.executable, str(cli), 'export', '--original', str(self.original),
|
|
'--port', str(self.port), '--output', str(self.output)],
|
|
capture_output=True, text=True, timeout=15)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
url = self.server()
|
|
with self.request(url + '/review.json') as response:
|
|
model = json.load(response)
|
|
self.assertEqual(model['acceptance']['state'], 'open')
|
|
self.assertEqual(model['events'][0]['name'], 'landing')
|
|
for side in ('original', 'port'):
|
|
self.assertEqual(model['sides'][side]['evidence_kind'], 'synthetic')
|
|
with self.request(url + '/' + model['sides'][side]['media']['url']) as response:
|
|
self.assertTrue(response.read().startswith(b'RIFF'))
|
|
|
|
def test_export_keeps_raw_derivatives_and_links(self):
|
|
data = self.export()
|
|
for side in data['sides'].values():
|
|
self.assertEqual({x['role'] for x in side['artifacts']}, {'video', 'audio', 'input_events'})
|
|
self.assertTrue((self.output / side['receipt_url']).is_file())
|
|
self.assertEqual(side['derivatives'], [])
|
|
|
|
def test_missing_original_explicit(self):
|
|
data = self.export(original=None)
|
|
self.assertIn('Missing original', data['sides']['original']['missing'])
|
|
self.assertIsNone(data['sides']['original']['media'])
|
|
|
|
def test_empty_review_is_explicit(self):
|
|
data = self.export(original=None, port=None)
|
|
self.assertEqual(data['events'], [])
|
|
self.assertEqual(data['acceptance']['state'], 'open')
|
|
|
|
def test_tampered_artifact_rejected(self):
|
|
(self.port.parent / 'video.wav').write_bytes(b'changed')
|
|
with self.assertRaises(ValueError): self.export()
|
|
self.assertFalse(self.output.exists())
|
|
|
|
def test_tampered_receipt_sidecar_rejected(self):
|
|
self.port.write_text('{}')
|
|
with self.assertRaises(ValueError): self.export()
|
|
|
|
def test_traversal_absolute_remote_and_symlink_references_rejected(self):
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
for path in ('../secret', '/secret', 'C:/secret', 'https://host/a', 'a\\b'):
|
|
value = copy.deepcopy(self.value)
|
|
value['artifacts'][0]['path'] = path
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
with self.assertRaisesRegex(ValueError, 'reference|Reference'):
|
|
self.api().export_review(raw, None, self.output)
|
|
(self.original.parent / 'video.wav').unlink()
|
|
(self.original.parent / 'video.wav').symlink_to(self.port.parent / 'video.wav')
|
|
with self.assertRaises(ValueError): self.export()
|
|
|
|
def test_labels_are_json_text_never_interpolated_html(self):
|
|
value = copy.deepcopy(self.value)
|
|
hostile = '</script><img src=x onerror=alert(1)>'
|
|
value['limitations'].append(hostile)
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
# A new collector bundle has no import sidecar; do not reuse another
|
|
# receipt's immutable metadata identity for this changed observation.
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
data = self.api().export_review(raw, None, self.output)
|
|
self.assertIn(hostile, data['sides']['original']['limitations'])
|
|
self.assertNotIn(hostile, (self.output / 'index.html').read_text())
|
|
self.assertNotIn('innerHTML', (self.output / 'viewer.mjs').read_text())
|
|
|
|
def test_event_out_of_range_rejected(self):
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
value = copy.deepcopy(self.value)
|
|
value['events'][0]['media_seconds'] = 3
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
with self.assertRaisesRegex(ValueError, 'exceeds'):
|
|
self.api().export_review(raw, None, self.output)
|
|
|
|
def test_duplicate_event_is_ambiguous_not_silently_selected(self):
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
value = copy.deepcopy(self.value)
|
|
value['events'].append(copy.deepcopy(value['events'][0]))
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
with self.assertRaisesRegex(ValueError, 'Ambiguous'):
|
|
self.api().export_review(raw, None, self.output)
|
|
|
|
def test_cross_case_pair_rejected(self):
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
value = copy.deepcopy(self.value)
|
|
value['case_id'] = 'other-case'
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
with self.assertRaisesRegex(ValueError, 'same case'):
|
|
self.api().export_review(raw, self.port, self.output)
|
|
|
|
def test_lossless_stills_and_derivative_ancestry_remain_linked(self):
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
value = copy.deepcopy(self.value)
|
|
# A byte-identified derivative record tests ancestry retention only;
|
|
# browser/PNG validation is separately required before image differences.
|
|
(self.original.parent / 'still.png').write_bytes(b'test-only not a PNG')
|
|
value['artifacts'].append(dict(receipts.identify_file(self.original.parent / 'still.png'),
|
|
path='still.png', role='lossless_still', synthetic=True))
|
|
value['derivatives'].append({'path': 'still.png', 'source': 'video.wav',
|
|
'tool': 'synthetic fixture', 'argv': ['inert']})
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
data = self.api().export_review(raw, None, self.output)
|
|
self.assertEqual(data['sides']['original']['derivatives'], value['derivatives'])
|
|
self.assertTrue((self.output / 'sides/original/still.png').is_file())
|
|
|
|
def test_imported_active_document_served_as_attachment(self):
|
|
(self.original.parent / 'receipt.sha256').unlink()
|
|
value = copy.deepcopy(self.value)
|
|
artifact = self.original.parent / 'untrusted.html'
|
|
artifact.write_text('<script>alert(1)</script>')
|
|
value['artifacts'].append(dict(receipts.identify_file(artifact), path='untrusted.html', role='note'))
|
|
raw = self.original.parent / 'raw.json'
|
|
raw.write_text(json.dumps(value))
|
|
self.api().export_review(raw, None, self.output)
|
|
with self.request(self.server() + '/sides/original/untrusted.html') as response:
|
|
self.assertEqual(response.headers['Content-Type'], 'application/octet-stream')
|
|
self.assertEqual(response.headers['Content-Disposition'], 'attachment')
|
|
|
|
def test_existing_or_overlapping_output_rejected(self):
|
|
with self.assertRaises(ValueError): self.api().export_review(self.original, self.port, self.original.parent)
|
|
self.export()
|
|
with self.assertRaises(ValueError): self.export()
|
|
|
|
def test_head_and_ranges_seek_actual_bytes(self):
|
|
data = self.export()
|
|
url = self.server() + '/' + data['sides']['port']['media']['url']
|
|
for range_value, expected in [('bytes=0-3', b'RIFF'), ('bytes=-4', b'\0' * 4),
|
|
('bytes=4-', (self.port.parent / 'video.wav').read_bytes()[4:])]:
|
|
with self.request(url, headers={'Range': range_value}) as response:
|
|
self.assertEqual(response.status, 206)
|
|
self.assertEqual(response.read(), expected)
|
|
self.assertIn('Content-Range', response.headers)
|
|
with self.request(url, 'HEAD', {'Range': 'bytes=0-3'}) as response:
|
|
self.assertEqual(response.status, 206)
|
|
self.assertEqual(response.headers['Content-Length'], '4')
|
|
self.assertEqual(response.read(), b'')
|
|
|
|
def test_bad_ranges_return_416(self):
|
|
self.export()
|
|
url = self.server() + '/index.html'
|
|
for value in ('bytes=9-2', 'bytes=999999-', 'bytes=0-1,4-5', 'bytes=-0', 'nonsense'):
|
|
with self.request(url, headers={'Range': value}) as response:
|
|
self.assertEqual(response.status, 416)
|
|
|
|
def test_server_rejects_escape_symlink_and_directory(self):
|
|
self.export()
|
|
(self.output / 'escape').symlink_to(self.port.parent / 'video.wav')
|
|
url = self.server()
|
|
for path in ('/%2e%2e/tools.yaml', '/escape', '/sides/', '/%2fetc/passwd'):
|
|
with self.request(url + path) as response:
|
|
self.assertIn(response.status, (400, 403, 404))
|
|
|
|
def test_write_methods_forbidden(self):
|
|
self.export()
|
|
url = self.server()
|
|
for method in ('POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'):
|
|
with self.request(url + '/review.json', method) as response:
|
|
self.assertEqual(response.status, 405)
|
|
|
|
def test_only_generated_root_loopback_and_security_headers(self):
|
|
with self.assertRaises(ValueError): self.api().make_server(ROOT, port=0)
|
|
self.export()
|
|
with self.assertRaises(ValueError): self.api().make_server(self.output, port=0, host='0.0.0.0')
|
|
with self.request(self.server() + '/') as response:
|
|
self.assertEqual(response.status, 200)
|
|
self.assertEqual(response.headers['X-Content-Type-Options'], 'nosniff')
|
|
self.assertIn("default-src 'none'", response.headers['Content-Security-Policy'])
|
|
|
|
def test_ledger_sources_are_validated_copied_and_linked(self):
|
|
ledger = self.base / 'ledger.json'
|
|
ledger.write_text(json.dumps({'schema_version': 1, 'capabilities': [{'id': 'test', 'source_links':
|
|
[{'label': 'Progress', 'path': 'docs/progress.md'}, {'label': 'Missing', 'path': 'docs/absent-fixture.md'}]}]}))
|
|
data = self.export(ledger=ledger)
|
|
links = data['ledger']['capabilities'][0]['source_links']
|
|
self.assertTrue(links[0]['validated_local'])
|
|
self.assertEqual((self.output / links[0]['href']).read_bytes(), (ROOT / 'docs/progress.md').read_bytes())
|
|
self.assertIsNone(links[1]['href'])
|
|
self.assertIn('Missing', links[1]['missing'])
|
|
with self.request(self.server() + '/' + links[0]['href']) as response:
|
|
self.assertEqual(response.headers['Content-Type'], 'text/plain; charset=utf-8')
|
|
self.assertTrue(response.read())
|
|
|
|
def test_ledger_source_paths_and_mismatched_hashes_rejected(self):
|
|
ledger = self.base / 'ledger.json'
|
|
for path in ('../Original/game.exe', 'https://host/a', '.git/config', 'artifacts/test.log'):
|
|
ledger.write_text(json.dumps({'schema_version': 1, 'capabilities': [{'source_links': [{'label': 'bad', 'path': path}]}]}))
|
|
with self.assertRaises(ValueError): self.export(ledger=ledger)
|
|
ledger.write_text(json.dumps({'schema_version': 1, 'capabilities': [{'source_links':
|
|
[{'label': 'bad hash', 'path': 'docs/progress.md', 'sha256': '0' * 64}]}]}))
|
|
with self.assertRaisesRegex(ValueError, 'hash mismatch'): self.export(ledger=ledger)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|