137 lines
5.7 KiB
Python
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()
|