修复:加固 Windows 更新预检、提交点和可恢复的数据库回退流程
This commit is contained in:
@@ -1,127 +1,253 @@
|
||||
import hashlib
|
||||
import ctypes
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
import repair_windows_update_check as fix
|
||||
ORIGINAL_SHA = fix.OLD_SHA
|
||||
|
||||
|
||||
class UpdateCheckRepairTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory(prefix='quality source path repair ')
|
||||
self.temp = tempfile.TemporaryDirectory(prefix='quality firstaid repair ')
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.root = Path(self.temp.name) / '中文 QualityCenter & files'
|
||||
self.root.mkdir()
|
||||
self.original = b'original source fixture\n'
|
||||
self.old_sha = hashlib.sha256(self.original).hexdigest()
|
||||
self.guard = patch.object(fix, 'OLD_SHA', self.old_sha)
|
||||
self.guard.start()
|
||||
self.addCleanup(self.guard.stop)
|
||||
for name, value in {fix.SCRIPT: self.original,
|
||||
'deploy/bootstrap/windows-start.ps1': b'original bootstrap',
|
||||
'migration/database.sql.gz': b'existing migration payload',
|
||||
'.runtime/deployment.json': b'original private configuration',
|
||||
'runtimedata/mysql/retained-database': b'imported database data'}.items():
|
||||
self.old_manager = b'known old updater fixture\n'
|
||||
self.old_control = b'known old controller fixture\n'
|
||||
self.old_manager_sha = hashlib.sha256(self.old_manager).hexdigest()
|
||||
self.old_control_sha = hashlib.sha256(self.old_control).hexdigest()
|
||||
self.reviewed_manager_hashes = fix.OLD_MANAGER_SHA256
|
||||
self.reviewed_control_hashes = fix.OLD_CONTROL_SHA256
|
||||
self.manager_guard = patch.object(fix, 'OLD_MANAGER_SHA256', frozenset({self.old_manager_sha}))
|
||||
self.control_guard = patch.object(fix, 'OLD_CONTROL_SHA256', frozenset({self.old_control_sha}))
|
||||
self.manager_guard.start()
|
||||
self.control_guard.start()
|
||||
self.addCleanup(self.manager_guard.stop)
|
||||
self.addCleanup(self.control_guard.stop)
|
||||
self.manager_payload, self.control_payload = fix.read_hardened_sources()
|
||||
for name, value in {
|
||||
fix.MANAGER: self.old_manager,
|
||||
fix.CONTROL: self.old_control,
|
||||
'deploy/bootstrap/windows-start.ps1': b'original bootstrap',
|
||||
'migration/database.sql.gz': b'existing migration payload',
|
||||
'.runtime/deployment.json': b'original private configuration',
|
||||
'runtimedata/mysql/retained-database': b'imported database data',
|
||||
}.items():
|
||||
target = self.root / name
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
target.write_bytes(value)
|
||||
self.manifest = {'platform': 'windows', 'updateVersion': '2026.11.04.1', 'updateSequence': 1,
|
||||
'runtimeFingerprint': 'unchanged', 'otherMetadata': {'keep': True},
|
||||
'files': [{'path': fix.SCRIPT, 'sha256': self.old_sha},
|
||||
{'path': 'deploy/bootstrap/windows-start.ps1', 'sha256': 'unchanged'}]}
|
||||
self.manifest = {
|
||||
'platform': 'windows', 'updateVersion': '2026.11.04.1', 'updateSequence': 1,
|
||||
'runtimeFingerprint': 'unchanged', 'otherMetadata': {'keep': True},
|
||||
'files': [
|
||||
{'path': fix.MANAGER, 'sha256': self.old_manager_sha},
|
||||
{'path': fix.CONTROL, 'sha256': self.old_control_sha},
|
||||
{'path': 'deploy/bootstrap/windows-start.ps1', 'sha256': 'unchanged'},
|
||||
],
|
||||
}
|
||||
self.manifest_path = self.root / 'manifest.json'
|
||||
self.manifest_path.write_text(json.dumps(self.manifest), encoding='utf-8')
|
||||
|
||||
def test_backup_manifest_and_script_only_preserving_database_and_configuration(self):
|
||||
def test_backups_both_programs_and_manifest_and_preserves_private_data(self):
|
||||
private = {name: (self.root / name).read_bytes() for name in
|
||||
['migration/database.sql.gz', '.runtime/deployment.json', 'runtimedata/mysql/retained-database']}
|
||||
result = fix.repair(self.root)
|
||||
['migration/database.sql.gz', '.runtime/deployment.json',
|
||||
'runtimedata/mysql/retained-database']}
|
||||
result = fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
self.assertTrue(result['updateCheckRepaired'])
|
||||
self.assertEqual((self.root / fix.SCRIPT).read_bytes(), fix.PATCHED_SCRIPT)
|
||||
self.assertTrue(result['controlRecoveryRepaired'])
|
||||
self.assertEqual(result['changedFiles'], 3)
|
||||
self.assertEqual((self.root / fix.MANAGER).read_bytes(), self.manager_payload)
|
||||
self.assertEqual((self.root / fix.CONTROL).read_bytes(), self.control_payload)
|
||||
expected = json.loads(json.dumps(self.manifest))
|
||||
expected['files'][0]['sha256'] = fix.NEW_SHA
|
||||
expected['files'][0]['sha256'] = hashlib.sha256(self.manager_payload).hexdigest()
|
||||
expected['files'][1]['sha256'] = hashlib.sha256(self.control_payload).hexdigest()
|
||||
self.assertEqual(json.loads(self.manifest_path.read_text()), expected)
|
||||
backup = self.root / result['backup']
|
||||
self.assertEqual((backup / 'update_manager.py').read_bytes(), self.original)
|
||||
self.assertEqual((backup / 'update_manager.py').read_bytes(), self.old_manager)
|
||||
self.assertEqual((backup / 'control.py').read_bytes(), self.old_control)
|
||||
self.assertEqual(json.loads((backup / 'manifest.json').read_text()), self.manifest)
|
||||
for name, value in private.items():
|
||||
self.assertEqual((self.root / name).read_bytes(), value)
|
||||
self.assertTrue(fix.repair(self.root)['alreadyRepaired'])
|
||||
self.assertTrue(fix.repair(self.root, self.manager_payload, self.control_payload)['alreadyRepaired'])
|
||||
|
||||
def test_modified_script_or_manifest_is_not_approved_as_a_repair(self):
|
||||
before = self.manifest_path.read_bytes()
|
||||
(self.root / fix.SCRIPT).write_bytes(b'unrecognized source')
|
||||
def test_unknown_program_or_manifest_digest_is_never_overwritten(self):
|
||||
original_manifest = self.manifest_path.read_bytes()
|
||||
(self.root / fix.MANAGER).write_bytes(b'unrecognized updater')
|
||||
with self.assertRaisesRegex(RuntimeError, '版本'):
|
||||
fix.repair(self.root)
|
||||
self.assertEqual(self.manifest_path.read_bytes(), before)
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
self.assertEqual(self.manifest_path.read_bytes(), original_manifest)
|
||||
(self.root / fix.MANAGER).write_bytes(self.old_manager)
|
||||
value = json.loads(original_manifest)
|
||||
value['files'][0]['sha256'] = '0' * 64
|
||||
self.manifest_path.write_text(json.dumps(value), encoding='utf-8')
|
||||
with self.assertRaisesRegex(RuntimeError, '版本'):
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
self.assertEqual((self.root / fix.MANAGER).read_bytes(), self.old_manager)
|
||||
|
||||
def test_failed_second_write_restores_original_program_and_manifest(self):
|
||||
before = self.manifest_path.read_bytes()
|
||||
def test_failed_manifest_write_rolls_back_both_programs_and_manifest(self):
|
||||
before = {fix.MANAGER: (self.root / fix.MANAGER).read_bytes(),
|
||||
fix.CONTROL: (self.root / fix.CONTROL).read_bytes(),
|
||||
'manifest.json': self.manifest_path.read_bytes()}
|
||||
original_atomic = fix.atomic
|
||||
calls = []
|
||||
|
||||
def failing(path, data):
|
||||
calls.append(path)
|
||||
if len(calls) == 2:
|
||||
if len(calls) == 3:
|
||||
raise OSError('simulated manifest write failure')
|
||||
original_atomic(path, data)
|
||||
|
||||
with patch.object(fix, 'atomic', side_effect=failing), self.assertRaises(OSError):
|
||||
fix.repair(self.root)
|
||||
self.assertEqual((self.root / fix.SCRIPT).read_bytes(), self.original)
|
||||
self.assertEqual(self.manifest_path.read_bytes(), before)
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
self.assertEqual((self.root / fix.MANAGER).read_bytes(), before[fix.MANAGER])
|
||||
self.assertEqual((self.root / fix.CONTROL).read_bytes(), before[fix.CONTROL])
|
||||
self.assertEqual(self.manifest_path.read_bytes(), before['manifest.json'])
|
||||
self.assertEqual(len(list((self.root / '.runtime/update-check-repair-backups').iterdir())), 1)
|
||||
|
||||
def test_retry_completes_an_interrupted_script_manifest_pair(self):
|
||||
(self.root / fix.SCRIPT).write_bytes(fix.PATCHED_SCRIPT)
|
||||
fix.repair(self.root)
|
||||
self.assertEqual(json.loads(self.manifest_path.read_text())['files'][0]['sha256'], fix.NEW_SHA)
|
||||
def test_retry_completes_old_new_mix_and_accepts_rolled_back_journal(self):
|
||||
(self.root / fix.MANAGER).write_bytes(self.manager_payload)
|
||||
journal = self.root / '.runtime/update/journal.json'
|
||||
journal.parent.mkdir(parents=True)
|
||||
journal.write_text(json.dumps({'phase': 'rolledBack'}), encoding='utf-8')
|
||||
result = fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
self.assertTrue(result['updateCheckRepaired'])
|
||||
self.assertEqual((self.root / fix.CONTROL).read_bytes(), self.control_payload)
|
||||
manifest = json.loads(self.manifest_path.read_text())
|
||||
self.assertEqual(manifest['files'][0]['sha256'], hashlib.sha256(self.manager_payload).hexdigest())
|
||||
self.assertEqual(manifest['files'][1]['sha256'], hashlib.sha256(self.control_payload).hexdigest())
|
||||
|
||||
def test_cmd_payload_runs_with_bundled_standard_library_without_service_restart(self):
|
||||
# 真实原包脚本由交付包集成验证;此单元测试使用受控旧源码摘要。
|
||||
command = self.root / '修复更新检查.cmd'
|
||||
body = fix.command_file().decode('utf-8').replace(ORIGINAL_SHA, self.old_sha)
|
||||
command.write_bytes(body.encode('utf-8'))
|
||||
code = body.split(' -c "', 1)[1].split('" "%~f0"', 1)[0]
|
||||
result = subprocess.run([sys.executable, '-I', '-S', '-B', '-X', 'utf8', '-c', code, str(command)], capture_output=True, text=True)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual((self.root / fix.SCRIPT).read_bytes(), fix.PATCHED_SCRIPT)
|
||||
self.assertNotIn('powershell.exe', body)
|
||||
self.assertIn('无需停止服务或重新导入数据库', body)
|
||||
|
||||
def test_active_update_lock_blocks_patching(self):
|
||||
before = self.manifest_path.read_bytes()
|
||||
with fix.update_lock(self.root), self.assertRaisesRegex(RuntimeError, '仍在运行'):
|
||||
fix.repair(self.root)
|
||||
self.assertEqual(self.manifest_path.read_bytes(), before)
|
||||
|
||||
def test_worker_or_unfinished_journal_blocks_repair(self):
|
||||
for name, data in [('worker.json', {}), ('journal.json', {'phase': 'installing'})]:
|
||||
path = self.root / '.runtime/update' / name
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(json.dumps(data))
|
||||
def test_active_worker_and_unknown_or_unfinished_journal_block_repair(self):
|
||||
worker = self.root / '.runtime/update/worker.json'
|
||||
worker.parent.mkdir(parents=True)
|
||||
worker.write_text(json.dumps({'pid': __import__('os').getpid()}), encoding='utf-8')
|
||||
with self.assertRaisesRegex(RuntimeError, '进程'):
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
worker.unlink()
|
||||
journal = worker.parent / 'journal.json'
|
||||
for value in ({'phase': 'installing'}, {'phase': 'futurePhase'}, {'unknown': True}):
|
||||
journal.write_text(json.dumps(value), encoding='utf-8')
|
||||
with self.assertRaises(RuntimeError):
|
||||
fix.repair(self.root)
|
||||
self.assertEqual((self.root / fix.SCRIPT).read_bytes(), self.original)
|
||||
path.unlink()
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
self.assertEqual((self.root / fix.MANAGER).read_bytes(), self.old_manager)
|
||||
journal.unlink()
|
||||
|
||||
def test_previous_check_repair_version_can_upgrade_without_losing_manifest_fields(self):
|
||||
prior = b'previous optimized checker fixture'
|
||||
digest = hashlib.sha256(prior).hexdigest()
|
||||
(self.root / fix.SCRIPT).write_bytes(prior)
|
||||
def test_windows_worker_probe_is_read_only_for_missing_and_live_pids(self):
|
||||
worker = self.root / '.runtime/update/worker.json'
|
||||
worker.parent.mkdir(parents=True)
|
||||
worker.write_text(json.dumps({'pid': 424242}), encoding='utf-8')
|
||||
|
||||
missing_kernel = Mock()
|
||||
missing_kernel.OpenProcess = Mock(return_value=None)
|
||||
missing_kernel.GetExitCodeProcess = Mock()
|
||||
missing_kernel.CloseHandle = Mock()
|
||||
with (patch.object(fix.os, 'name', 'nt'),
|
||||
patch.object(fix.os, 'kill', side_effect=AssertionError('os.kill must not run')) as kill,
|
||||
patch('ctypes.WinDLL', return_value=missing_kernel, create=True),
|
||||
patch('ctypes.get_last_error', return_value=87, create=True)):
|
||||
self.assertFalse(fix.worker_active(self.root.resolve()))
|
||||
kill.assert_not_called()
|
||||
missing_kernel.GetExitCodeProcess.assert_not_called()
|
||||
missing_kernel.CloseHandle.assert_not_called()
|
||||
missing_kernel.TerminateProcess.assert_not_called()
|
||||
missing_kernel.OpenProcess.assert_called_once_with(0x1000, False, 424242)
|
||||
|
||||
denied_kernel = Mock()
|
||||
denied_kernel.OpenProcess = Mock(return_value=None)
|
||||
denied_kernel.GetExitCodeProcess = Mock()
|
||||
denied_kernel.CloseHandle = Mock()
|
||||
with (patch.object(fix.os, 'name', 'nt'),
|
||||
patch.object(fix.os, 'kill', side_effect=AssertionError('os.kill must not run')) as kill,
|
||||
patch('ctypes.WinDLL', return_value=denied_kernel, create=True),
|
||||
patch('ctypes.get_last_error', return_value=5, create=True)):
|
||||
with self.assertRaisesRegex(RuntimeError, '无法只读确认'):
|
||||
fix.worker_active(self.root.resolve())
|
||||
kill.assert_not_called()
|
||||
denied_kernel.TerminateProcess.assert_not_called()
|
||||
|
||||
live_kernel = Mock()
|
||||
live_kernel.OpenProcess = Mock(return_value=123)
|
||||
live_kernel.CloseHandle = Mock(return_value=1)
|
||||
|
||||
def set_still_active(_handle, output):
|
||||
ctypes.cast(output, ctypes.POINTER(ctypes.c_ulong)).contents.value = 259
|
||||
return 1
|
||||
|
||||
live_kernel.GetExitCodeProcess = Mock(side_effect=set_still_active)
|
||||
with (patch.object(fix.os, 'name', 'nt'),
|
||||
patch.object(fix.os, 'kill', side_effect=AssertionError('os.kill must not run')) as kill,
|
||||
patch('ctypes.WinDLL', return_value=live_kernel, create=True)):
|
||||
self.assertTrue(fix.worker_active(self.root.resolve()))
|
||||
kill.assert_not_called()
|
||||
live_kernel.CloseHandle.assert_called_once_with(123)
|
||||
live_kernel.TerminateProcess.assert_not_called()
|
||||
|
||||
def test_stale_worker_pid_allows_repair_and_live_reused_pid_fails_closed(self):
|
||||
worker = self.root / '.runtime/update/worker.json'
|
||||
worker.parent.mkdir(parents=True)
|
||||
worker.write_text(json.dumps({'pid': 424242}), encoding='utf-8')
|
||||
with patch.object(fix.os, 'kill', side_effect=ProcessLookupError):
|
||||
self.assertTrue(fix.repair(self.root, self.manager_payload, self.control_payload)['updateCheckRepaired'])
|
||||
|
||||
# A live process with a stale/reused PID is treated as active; no identity match is required.
|
||||
(self.root / fix.MANAGER).write_bytes(self.old_manager)
|
||||
(self.root / fix.CONTROL).write_bytes(self.old_control)
|
||||
self.manifest_path.write_text(json.dumps(self.manifest), encoding='utf-8')
|
||||
with patch.object(fix.os, 'kill', return_value=None):
|
||||
with self.assertRaisesRegex(RuntimeError, '仍在运行'):
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
|
||||
def test_update_lock_blocks_firstaid(self):
|
||||
with fix.update_lock(self.root), self.assertRaisesRegex(RuntimeError, '仍在运行'):
|
||||
fix.repair(self.root, self.manager_payload, self.control_payload)
|
||||
|
||||
def test_self_contained_cmd_uses_bundled_python_and_latest_source_bytes(self):
|
||||
manager, control = fix.read_hardened_sources()
|
||||
# This models a crash after source replacement but before manifest update.
|
||||
(self.root / fix.MANAGER).write_bytes(manager)
|
||||
(self.root / fix.CONTROL).write_bytes(control)
|
||||
value = json.loads(self.manifest_path.read_text())
|
||||
value['files'][0]['sha256'] = digest
|
||||
self.manifest_path.write_text(json.dumps(value))
|
||||
with patch.object(fix, 'PREVIOUS_SHA', digest):
|
||||
self.assertTrue(fix.repair(self.root)['updateCheckRepaired'])
|
||||
self.assertEqual(fix.PATCHED_SCRIPT, (self.root / fix.SCRIPT).read_bytes())
|
||||
value['files'][0]['sha256'] = '29512f15a9ee329bc7c7777454bdd79aa7ffd11c3cffa9400b8a4585bdabf35b'
|
||||
value['files'][1]['sha256'] = 'd98fa24d17e9bdd90ff37f9886df280451eceabac0df35d2eeecf4fe615bc6f1'
|
||||
self.manifest_path.write_text(json.dumps(value), encoding='utf-8')
|
||||
command = self.root / '兼容旧安装修复.cmd'
|
||||
body = fix.command_file()
|
||||
command.write_bytes(body)
|
||||
module, payload = body.rsplit(fix.MODULE_MARKER, 1)[1].rsplit(fix.PAYLOAD_MARKER, 1)
|
||||
embedded = {}
|
||||
exec(compile(payload.decode('ascii'), str(command), 'exec'), embedded)
|
||||
self.assertEqual(embedded['PATCHED_MANAGER'], manager)
|
||||
self.assertEqual(embedded['PATCHED_CONTROL'], control)
|
||||
code = body.decode('utf-8').split(' -c "', 1)[1].split('" "%~f0"', 1)[0]
|
||||
result = subprocess.run([sys.executable, '-I', '-S', '-B', '-X', 'utf8', '-c', code, str(command)],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual((self.root / fix.MANAGER).read_bytes(), manager)
|
||||
self.assertEqual((self.root / fix.CONTROL).read_bytes(), control)
|
||||
manifest = json.loads(self.manifest_path.read_text())
|
||||
self.assertEqual(manifest['files'][0]['sha256'], hashlib.sha256(manager).hexdigest())
|
||||
self.assertEqual(manifest['files'][1]['sha256'], hashlib.sha256(control).hexdigest())
|
||||
command_header = body.split(fix.MODULE_MARKER, 1)[0].decode('utf-8')
|
||||
self.assertNotIn('powershell.exe', command_header)
|
||||
self.assertNotIn('windows-start.ps1', command_header)
|
||||
self.assertIn(' -I -S -B ', command_header)
|
||||
|
||||
def test_embedded_program_matches_reviewed_source(self):
|
||||
self.assertEqual(fix.PATCHED_SCRIPT, (HERE / 'update_manager.py').read_bytes())
|
||||
def test_historical_allowlist_matches_known_release_inputs(self):
|
||||
self.assertEqual(self.reviewed_manager_hashes, frozenset({
|
||||
'29512f15a9ee329bc7c7777454bdd79aa7ffd11c3cffa9400b8a4585bdabf35b',
|
||||
'b91cb7fec10e183d2904d86f032ff0ffcf7f19f7cb27aecd2d803d3448685482',
|
||||
'a4bd05789f559fede0bed083ce61123307d6b5cf52fa638b6bde1fa112a0348a',
|
||||
}))
|
||||
self.assertEqual(self.reviewed_control_hashes, frozenset({
|
||||
'd98fa24d17e9bdd90ff37f9886df280451eceabac0df35d2eeecf4fe615bc6f1',
|
||||
}))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
Reference in New Issue
Block a user