完善:同月多文件导入与当前用户离线迁移更新

This commit is contained in:
2026-11-04 11:35:24 +08:00
parent 147b56d0fd
commit f04d4e96e3
89 changed files with 6634 additions and 201 deletions
+303
View File
@@ -0,0 +1,303 @@
"""Offline security and rollback tests. No network, production DB or services."""
import base64
import copy
import hashlib
import importlib.util
import json
from pathlib import Path
import shutil
import stat
import sys
import tempfile
import types
import unittest
from unittest.mock import patch
import zipfile
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives import serialization
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
import update_manager as update
class UpdateTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name) / 'bundle'
self.root.mkdir()
self.private = Ed25519PrivateKey.generate()
self.files = {
'app/backend.jar': b'old backend',
'app/web/index.html': b'old web',
'app/web/obsolete.js': b'old asset',
'deploy/offline/control.py': b'old supervisor',
'deploy/offline/update_manager.py': b'old updater',
'backend/src/main/resources/analysis-runtime-policy.json': b'{}',
update.KEY: self.private.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo),
'runtimes/python/python.exe': b'unchanged runtime',
'migration/snapshot.sql': b'private migration data',
}
for name, data in self.files.items():
self.write(name, data)
self.manifest = {
'platform': 'windows', 'architecture': 'x86_64',
'runtimes': [{'name': 'python', 'version': '3.11.15'}],
'pythonWheels': [{'file': 'cryptography.whl', 'sha256': 'a' * 64}],
'files': [{'path': k, 'sha256': hashlib.sha256(v).hexdigest()} for k, v in self.files.items()],
'updateSequence': 5, 'updateVersion': '2026.11.03',
}
update.atomic(self.root / 'manifest.json', self.manifest)
self.config = {'mysqlDatabase': 'quality_restore_' + 'a' * 24, 'archiveDirectory': 'runtimedata/archive/restore-old',
'mysqlPort': 53306, 'rootPassword': 'privateRootPasswordValue', 'mysqlPassword': 'privateAppPasswordValue'}
update.atomic(self.root / '.runtime/deployment.json', self.config)
self.write('.runtime/analysis-api-settings.json', b'{"apiKey":"keep-private"}')
self.program = {k: b'new ' + v for k, v in self.files.items() if update.program_path(k) and k != 'app/web/obsolete.js'}
self.release = {'schema': 1, 'version': '2026.11.04', 'sequence': 6, 'platform': 'windows-x64',
'runtimeFingerprint': update.runtime_fingerprint(self.manifest),
'archive': {'file': 'quality-update-2026.11.04.zip', 'size': 123, 'sha256': 'a' * 64},
'files': [{'path': k, 'size': len(v), 'sha256': hashlib.sha256(v).hexdigest()} for k, v in self.program.items()]}
def write(self, name, data):
path = self.root / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data)
def envelope(self, release=None, private=None):
raw = update.canonical(release or self.release)
return {'payload': base64.b64encode(raw).decode(), 'signature': base64.b64encode((private or self.private).sign(raw)).decode()}
def validate(self, release=None):
return update.validate_release(self.envelope(release), self.root)
def archive(self, entries=None):
archive = Path(self.temp.name) / 'update.zip'
with zipfile.ZipFile(archive, 'w') as out:
for name, data in (entries or self.program).items():
out.writestr(name, data)
return archive
def test_valid_signature_and_runtime_identity(self):
self.assertEqual('2026.11.04', self.validate()['version'])
self.assertEqual(update.runtime_fingerprint(self.manifest), update.runtime_fingerprint(copy.deepcopy(self.manifest)))
def test_wrong_signature_key_and_modified_payload_are_rejected(self):
with self.assertRaises(update.UpdateError):
update.validate_release(self.envelope(private=Ed25519PrivateKey.generate()), self.root)
envelope = self.envelope()
envelope['payload'] = base64.b64encode(update.canonical({**self.release, 'sequence': 999})).decode()
with self.assertRaises(update.UpdateError):
update.validate_release(envelope, self.root)
def test_immutable_trust_anchor_checked_against_local_manifest(self):
self.write(update.KEY, Ed25519PrivateKey.generate().public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo))
with self.assertRaises(update.UpdateError):
self.validate()
def test_runtime_mismatch_requires_full_bundle(self):
release = {**self.release, 'runtimeFingerprint': 'b' * 64}
with self.assertRaisesRegex(update.UpdateError, '完整安装包'):
self.validate(release)
def test_forbidden_destinations_and_trust_key_are_never_update_files(self):
for name in ['.runtime/deployment.json', 'runtimedata/mysql/table.ibd', 'migration/snapshot.sql',
'runtimes/python/python.exe', update.KEY, 'manifest.json', 'backend/src/private.key']:
with self.subTest(name=name):
release = copy.deepcopy(self.release)
release['files'].append({'path': name, 'size': 0, 'sha256': 'a' * 64})
with self.assertRaises(update.UpdateError):
self.validate(release)
def test_windows_aliases_traversal_and_case_collisions_rejected(self):
for name in ['../evil', 'app/web/../evil', 'app/web/C:evil', 'app\\web\\evil', '/absolute',
'app/web/NUL.txt', 'app/web/trailing.', 'app/web/double//slash', 'app/web/control\x01']:
with self.subTest(name=name), self.assertRaises(update.UpdateError):
update.safe_path(name)
release = copy.deepcopy(self.release)
release['files'].append({**release['files'][0], 'path': release['files'][0]['path'].upper()})
with self.assertRaises(update.UpdateError):
self.validate(release)
def test_destination_symlink_rejected(self):
target = self.root / 'app/web/link'
target.symlink_to(Path(self.temp.name), target_is_directory=True)
with self.assertRaises(update.UpdateError):
update.destination(self.root, 'app/web/link/escape.html')
def test_missing_required_program_or_deployment_manifest_rejected(self):
release = copy.deepcopy(self.release)
release['files'] = [e for e in release['files'] if e['path'] != 'backend/src/main/resources/analysis-runtime-policy.json']
with self.assertRaises(update.UpdateError):
self.validate(release)
with self.assertRaisesRegex(update.UpdateError, '部署数据'):
self.validate({**self.release, 'bundleManifest': self.manifest})
def test_zip_inventory_and_hash_enforced(self):
stage = Path(self.temp.name) / 'good'
update.unpack(self.archive(), stage, self.release)
self.assertEqual(self.program['app/backend.jar'], (stage / 'app/backend.jar').read_bytes())
bad = dict(self.program)
bad['../evil'] = b'escape'
with self.assertRaises(update.UpdateError):
update.unpack(self.archive(bad), Path(self.temp.name) / 'escape', self.release)
bad = dict(self.program)
bad['app/backend.jar'] = b'x' * len(bad['app/backend.jar'])
with self.assertRaisesRegex(update.UpdateError, '校验失败'):
update.unpack(self.archive(bad), Path(self.temp.name) / 'hash', self.release)
def test_zip_symlink_rejected(self):
archive = Path(self.temp.name) / 'symlink.zip'
info = zipfile.ZipInfo('app/backend.jar')
info.external_attr = (stat.S_IFLNK | 0o777) << 16
with zipfile.ZipFile(archive, 'w') as out:
out.writestr(info, self.program['app/backend.jar'])
with self.assertRaises(update.UpdateError):
update.unpack(archive, Path(self.temp.name) / 'links', self.release)
def test_snapshot_replace_preserves_local_data_and_manifest_entries(self):
backup = self.root / '.runtime/update/backup-test'
backup.mkdir(parents=True)
stage = Path(self.temp.name) / 'stage'
update.unpack(self.archive(), stage, self.release)
update.backup_program(self.root, backup, self.release)
update.replace_program(self.root, stage, backup, self.release)
result = update.read(self.root / 'manifest.json')
self.assertEqual(6, result['updateSequence'])
self.assertEqual(self.config, update.read(self.root / '.runtime/deployment.json'))
self.assertFalse((self.root / 'app/web/obsolete.js').exists())
for name in (update.KEY, 'runtimes/python/python.exe', 'migration/snapshot.sql'):
self.assertEqual(self.files[name], (self.root / name).read_bytes())
self.assertIn(next(e for e in self.manifest['files'] if e['path'] == name), result['files'])
update.restore_program(self.root, backup)
self.assertEqual(self.manifest, update.read(self.root / 'manifest.json'))
self.assertEqual(self.files['app/web/obsolete.js'], (self.root / 'app/web/obsolete.js').read_bytes())
def worker_harness(self, fail_verify=False):
directory = self.root / '.runtime/update'
update.atomic(directory / 'request.json', {'token': 'a' * 32})
archive = self.archive()
envelope = self.envelope()
original_download = update.download
calls, restores, queries = [], [], []
def fake_download(url, target=None, *args):
if target:
shutil.copyfile(archive, target)
return b''
return json.dumps(envelope).encode()
def fake_control(root, action, database_only=False, timeout=0):
calls.append((action, database_only))
if action == 'verify' and fail_verify:
raise update.UpdateError('模拟新版启动校验失败。')
return types.SimpleNamespace(pid=1234)
def fake_mysql(root, config, binary='mysql', database=None, stdin=None, stdout=None):
if binary == 'mysqldump':
stdout.write(b'-- database snapshot\n' + b'SELECT 1;\n' * 30)
else:
restores.append((database, stdin.read()))
process = types.SimpleNamespace(parents=lambda: [], create_time=lambda: 1,
is_running=lambda: True, status=lambda: 'running')
with patch.object(update.psutil, 'pid_exists', return_value=False), \
patch.object(update.psutil, 'Process', return_value=process), \
patch.object(update, 'download', side_effect=fake_download), \
patch.object(update, 'controller', side_effect=fake_control), \
patch.object(update, 'wait_ready'), \
patch.object(update, 'mysql', side_effect=fake_mysql), \
patch.object(update, 'sql', side_effect=lambda root, config, query: queries.append(query)):
update.worker(987654, 'a' * 32, self.root)
return calls, restores, queries
def test_complete_update_orchestration_with_isolated_database_backup(self):
calls, restores, queries = self.worker_harness()
self.assertEqual([('stop', False), ('serve', True), ('stop', False), ('verify', False), ('serve', False)], calls)
self.assertFalse(restores)
self.assertEqual('completed', update.read(self.root / '.runtime/update/status.json')['state'])
self.assertEqual('complete', update.read(self.root / '.runtime/update/journal.json')['phase'])
self.assertEqual(6, update.read(self.root / 'manifest.json')['updateSequence'])
def test_failed_update_restores_old_program_and_new_rollback_database(self):
self.config['restoredFromMigration'] = 'isolated-test-migration'
update.atomic(self.root / '.runtime/deployment.json', self.config)
update.atomic(self.root / '.runtime/migration-receipt.json', {'migrationId': 'isolated-test-migration',
'database': self.config['mysqlDatabase'], 'migrationManifestSha256': 'b' * 64})
calls, restores, queries = self.worker_harness(fail_verify=True)
self.assertEqual(self.manifest, update.read(self.root / 'manifest.json'))
config = update.read(self.root / '.runtime/deployment.json')
self.assertRegex(config['mysqlDatabase'], r'^quality_restore_[a-f0-9]{24}$')
self.assertNotEqual(self.config['mysqlDatabase'], config['mysqlDatabase'])
self.assertEqual(self.config['archiveDirectory'], config['archiveDirectory'])
self.assertEqual(config['mysqlDatabase'], restores[0][0])
self.assertEqual(config['mysqlDatabase'], update.read(self.root / '.runtime/migration-receipt.json')['database'])
self.assertTrue(any('CREATE DATABASE' in q for q in queries))
self.assertFalse(any('DROP' in q for q in queries))
self.assertEqual('failed', update.read(self.root / '.runtime/update/status.json')['state'])
self.assertIn('已恢复原版本', update.read(self.root / '.runtime/update/status.json')['message'])
self.assertEqual('rolledBack', update.read(self.root / '.runtime/update/journal.json')['phase'])
def test_recovery_blocks_live_worker_and_rejects_untrusted_backup_path(self):
directory = self.root / '.runtime/update'
update.atomic(directory / 'journal.json', {'phase': 'installing', 'backup': '../../escape'})
with patch.object(update, 'live', return_value=False), self.assertRaises(update.UpdateError):
update.recover(self.root)
with patch.object(update, 'live', return_value=True), self.assertRaisesRegex(update.UpdateError, '正在进行'):
update.recover(self.root)
def test_arbitrary_download_url_is_rejected_before_network(self):
for url in ['http://quality.lyunlab.me/quality-updates/windows-x64/latest.json', 'https://evil.example/update.zip',
update.BASE + '../private.zip', update.BASE + 'quality-update-x.zip?token=x']:
with self.subTest(url=url), self.assertRaises(update.UpdateError):
update.download(url)
def test_source_is_disabled_and_status_never_exposes_private_fields(self):
update.atomic(self.root / '.runtime/update/status.json', {'state': 'idle', 'rootPassword': 'secret', 'backupPath': '/private'})
with patch.object(update.os, 'name', 'posix'):
self.assertFalse(update.enabled(self.root))
result = update.status(self.root)
self.assertNotIn('rootPassword', result)
self.assertNotIn('backupPath', result)
def test_recovery_and_worker_share_lock_and_live_identity(self):
with update.exclusive_update(self.root):
self.assertTrue(update.live(update.read(self.root / '.runtime/update/worker.json')))
with self.assertRaises(update.BusyUpdate):
update.recover(self.root)
# The lock remains authoritative if the identity file disappears.
(self.root / '.runtime/update/worker.json').unlink()
with self.assertRaises(update.BusyUpdate):
with update.exclusive_update(self.root):
self.fail('Concurrent update lock was acquired')
def test_atomic_copy_failure_preserves_existing_control_and_configuration(self):
source = Path(self.temp.name) / 'new-content'
source.write_bytes(b'new file content')
for name in ('deploy/offline/control.py', '.runtime/deployment.json', 'manifest.json'):
target = self.root / name
previous = target.read_bytes()
with self.subTest(name=name), patch.object(update.os, 'replace', side_effect=OSError('simulated interruption')):
with self.assertRaises(OSError):
update.copy_atomic(source, target)
self.assertEqual(previous, target.read_bytes())
self.assertFalse(list(target.parent.glob(target.name + '.update-*')))
def test_mysqldump_does_not_receive_mysql_only_connect_timeout_option(self):
with patch.object(update.subprocess, 'run', return_value=types.SimpleNamespace(returncode=0)) as run:
update.mysql(self.root, self.config, 'mysqldump', stdout=update.subprocess.DEVNULL)
self.assertFalse(any(arg.startswith('--connect-timeout') for arg in run.call_args.args[0]))
update.mysql(self.root, self.config, 'mysql')
self.assertIn('--connect-timeout=10', run.call_args.args[0])
def test_actual_dump_is_followed_by_a_second_recovery_space_check(self):
with patch.object(update.shutil, 'disk_usage', side_effect=[types.SimpleNamespace(free=10**15), types.SimpleNamespace(free=0)]):
calls, _, _ = self.worker_harness()
self.assertNotIn(('verify', False), calls)
self.assertEqual(self.manifest, update.read(self.root / 'manifest.json'))
self.assertIn('剩余磁盘空间不足', update.read(self.root / '.runtime/update/status.json')['message'])
if __name__ == '__main__':
unittest.main()