完善:同月多文件导入与当前用户离线迁移更新
This commit is contained in:
@@ -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()
|
||||
Reference in New Issue
Block a user