Files
canina/scripts/publishers/e4c9b52eb040/test_release_helper.py
T

137 lines
5.7 KiB
Python

"""Offline release security regressions; all writes stay in temporary fixtures.
Acceptance: reviewed old/idempotent bytes install; unknown bytes, wrong digest,
lock contention and changes at either side of the final check fail closed.
These are post-implementation independent tests, not a TDD claim.
"""
import fcntl
import hashlib
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest
from unittest import mock
import release_helper as helper
class ReleaseHelperTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory(prefix='helper-review-')
self.addCleanup(self.tmp.cleanup)
self.target = Path(self.tmp.name) / 'editorial_evidence.py'
self.old = b'# isolated reviewed beforeimage\n'
self.source = b'# isolated reviewed replacement\nvalue = 1\n'
self.target.write_bytes(self.old)
self.target.chmod(0o640)
self.approval = hashlib.sha256(self.source).hexdigest()
self.sha = 'a' * 40
patcher = mock.patch.object(helper, 'OLD', hashlib.sha256(self.old).hexdigest())
patcher.start()
self.addCleanup(patcher.stop)
def install(self, **kw):
return helper.install(self.source, kw.get('sha', self.sha),
kw.get('approval', self.approval), self.target)
def assert_no_temporary_release(self):
self.assertEqual(list(self.target.parent.glob('.editorial-release-*')), [])
def test_reviewed_install_and_idempotency_preserve_mode(self):
for _ in range(2):
result = self.install()
self.assertEqual(result['sha256'], self.approval)
self.assertFalse(result['site_deploy'])
self.assertFalse(result['gateway_restart'])
self.assertEqual(self.target.read_bytes(), self.source)
self.assertEqual(self.target.stat().st_mode & 0o777, 0o640)
self.assert_no_temporary_release()
def test_unknown_beforeimage_rejected(self):
self.target.write_bytes(b'unreviewed')
with self.assertRaisesRegex(ValueError, 'Unreviewed before-image'):
self.install()
self.assertEqual(self.target.read_bytes(), b'unreviewed')
self.assert_no_temporary_release()
def test_approval_mismatch_rejected(self):
with self.assertRaisesRegex(ValueError, 'Reviewed content digest required'):
self.install(approval='0' * 64)
self.assertEqual(self.target.read_bytes(), self.old)
def test_malformed_commit_rejected(self):
with self.assertRaises(ValueError):
self.install(sha='not-a-sha')
self.assertEqual(self.target.read_bytes(), self.old)
def test_contention_from_separate_process_rejected(self):
lock = self.target.parent / '.helper-release.lock'
code = ('import fcntl,sys; f=open(sys.argv[1],"a"); '
'fcntl.flock(f,fcntl.LOCK_EX); print("locked",flush=True); sys.stdin.read()')
process = subprocess.Popen([sys.executable, '-c', code, str(lock)],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
try:
assert process.stdout is not None
self.assertEqual(process.stdout.readline().strip(), 'locked')
with self.assertRaises(BlockingIOError):
self.install()
self.assertEqual(self.target.read_bytes(), self.old)
finally:
process.communicate(input='', timeout=5)
self.assertEqual(process.returncode, 0)
def test_change_during_staging_rejected_before_replace(self):
real_fsync = os.fsync
def mutate(fd):
real_fsync(fd)
self.target.write_bytes(b'concurrent edit')
with mock.patch.object(helper.os, 'fsync', side_effect=mutate):
with self.assertRaisesRegex(ValueError, 'Concurrent before-image change'):
self.install()
self.assertEqual(self.target.read_bytes(), b'concurrent edit')
self.assert_no_temporary_release()
def test_inode_swap_during_staging_rejected(self):
real_fsync = os.fsync
def mutate(fd):
real_fsync(fd)
alternate = self.target.parent / 'alternate'
alternate.write_bytes(self.old)
os.replace(alternate, self.target)
with mock.patch.object(helper.os, 'fsync', side_effect=mutate):
with self.assertRaisesRegex(ValueError, 'Concurrent before-image change'):
self.install()
self.assertEqual(self.target.read_bytes(), self.old)
self.assert_no_temporary_release()
def test_change_after_final_check_before_replace_must_not_be_erased(self):
real_replace = os.replace
def mutate_then_replace(src, dst):
self.target.write_bytes(b'late concurrent edit')
return real_replace(src, dst)
with mock.patch.object(helper.os, 'replace', side_effect=mutate_then_replace):
with self.assertRaisesRegex(ValueError, 'Concurrent before-image change'):
self.install()
self.assertEqual(self.target.read_bytes(), b'late concurrent edit')
self.assert_no_temporary_release()
def test_symlink_rejected(self):
actual = self.target.parent / 'actual'
self.target.rename(actual)
self.target.symlink_to(actual)
with self.assertRaisesRegex(ValueError, 'Symlink refused'):
self.install()
self.assertEqual(actual.read_bytes(), self.old)
def test_hardlink_rejected(self):
os.link(self.target, self.target.parent / 'hardlink')
with self.assertRaisesRegex(ValueError, 'hardlink mismatch'):
self.install()
self.assertEqual(self.target.read_bytes(), self.old)
if __name__ == '__main__':
unittest.main()