Files

176 lines
8.7 KiB
Python

"""Offline tests for the signed Windows update publisher."""
import base64
import hashlib
import json
from pathlib import Path
import tempfile
import sys
import unittest
import zipfile
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
sys.path.insert(0, str(Path(__file__).resolve().parent))
import publish_update
import update_manager
class PublishUpdateTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.base = Path(self.temp.name)
self.root = self.base / 'windows-bundle'
self.root.mkdir()
self.output = self.base / 'published'
self.key_path = self.base / 'release-private-key.pem'
self.private = Ed25519PrivateKey.generate()
self.key_path.write_bytes(self.private.private_bytes(
serialization.Encoding.PEM,
serialization.PrivateFormat.PKCS8,
serialization.NoEncryption(),
))
public_key_path = self.root / update_manager.KEY
public_key_path.parent.mkdir(parents=True, exist_ok=True)
public_key_path.write_bytes(self.private.public_key().public_bytes(
serialization.Encoding.PEM,
serialization.PublicFormat.SubjectPublicKeyInfo,
))
self.data = {
'app/backend.jar': b'backend program',
'app/web/index.html': b'<html>program</html>',
'deploy/offline/control.py': b'control program',
'deploy/offline/update_manager.py': b'update manager program',
'deploy/offline/publish_update.py': b'publisher program',
'deploy/offline/windows-start.ps1': b'start script',
'deploy/offline/README.md': b'package instructions',
'backend/src/main/resources/analysis-runtime-policy.json': b'{"enabled":false}',
'scripts/runtime.py': b'helper program',
'ai/nao-quality/app.py': b'ai program',
'runtimes/python/python.exe': b'local runtime must not ship in an update',
'migration/manifest.json': b'private migration data',
'deploy/bootstrap/update-recovery.py': b'immutable bootstrap',
'.runtime/deployment.json': b'{"mysqlPassword":"private"}',
'runtimedata/archive/source.xlsx': b'user business data',
update_manager.KEY: public_key_path.read_bytes(),
}
for name, value in self.data.items():
target = self.root.joinpath(*name.split('/'))
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(value)
self.manifest = {
'platform': 'windows',
'architecture': 'x86_64',
'updateVersion': '2026.11.04.1',
'updateSequence': 1,
'runtimes': [{'name': 'python', 'version': '3.11.15'}],
'pythonWheels': [{'file': 'cryptography.whl', 'sha256': 'a' * 64}],
'files': [
{'path': name, 'sha256': hashlib.sha256(value).hexdigest()}
for name, value in self.data.items()
],
}
(self.root / 'manifest.json').write_text(json.dumps(self.manifest), encoding='utf-8')
def build(self, **changes):
args = {
'root': self.root,
'version': '2026.11.04.2',
'sequence': 2,
'private_key_path': self.key_path,
'output_dir': self.output,
}
args.update(changes)
return publish_update.publish(**args)
def test_release_is_signed_program_snapshot_with_runtime_fingerprint(self):
artifacts = self.build()
self.assertTrue(artifacts.archive.is_file())
self.assertTrue(artifacts.latest.is_file())
envelope = update_manager.read(artifacts.latest)
release = update_manager.validate_release(envelope, self.root)
raw = base64.b64decode(envelope['payload'], validate=True)
self.private.public_key().verify(base64.b64decode(envelope['signature'], validate=True), raw)
self.assertEqual('2026.11.04.2', release['version'])
self.assertEqual(2, release['sequence'])
self.assertEqual(update_manager.runtime_fingerprint(self.manifest), release['runtimeFingerprint'])
self.assertNotIn('bundleManifest', release)
included = {entry['path'] for entry in release['files']}
self.assertEqual({name for name in self.data if update_manager.program_path(name)}, included)
self.assertFalse(included & {
'runtimes/python/python.exe',
'migration/manifest.json',
'deploy/bootstrap/update-recovery.py',
'.runtime/deployment.json',
'runtimedata/archive/source.xlsx',
update_manager.KEY,
})
with zipfile.ZipFile(artifacts.archive) as archive:
self.assertEqual(included, set(archive.namelist()))
self.assertEqual(self.data['app/backend.jar'], archive.read('app/backend.jar'))
self.assertEqual(hashlib.sha256(artifacts.archive.read_bytes()).hexdigest(), release['archive']['sha256'])
def test_rejects_wrong_key_stale_sequence_and_package_mutation(self):
with self.assertRaisesRegex(publish_update.PublishError, '不匹配'):
wrong_path = self.base / 'wrong-private-key.pem'
wrong_path.write_bytes(Ed25519PrivateKey.generate().private_bytes(
serialization.Encoding.PEM,
serialization.PrivateFormat.PKCS8,
serialization.NoEncryption(),
))
self.build(private_key_path=wrong_path)
with self.assertRaisesRegex(publish_update.PublishError, '大于部署包当前序号'):
self.build(sequence=1)
(self.root / 'app/backend.jar').write_bytes(b'changed after manifest')
with self.assertRaisesRegex(publish_update.PublishError, '摘要不一致'):
self.build()
self.assertFalse(self.output.exists())
def test_allows_only_explicit_exact_baseline_and_still_rejects_lower_sequence(self):
with self.assertRaisesRegex(publish_update.PublishError, '大于部署包当前序号'):
self.build(version='2026.11.04.1', sequence=1)
with self.assertRaisesRegex(publish_update.PublishError, '完全一致'):
self.build(version='2026.11.04.2', sequence=1, allow_baseline=True)
baseline = self.build(version='2026.11.04.1', sequence=1, allow_baseline=True)
release = update_manager.validate_release(update_manager.read(baseline.latest), self.root)
self.assertEqual('2026.11.04.1', release['version'])
self.assertEqual(1, release['sequence'])
self.manifest['updateVersion'] = '2026.11.04.1'
self.manifest['updateSequence'] = 2
(self.root / 'manifest.json').write_text(json.dumps(self.manifest), encoding='utf-8')
self.output = self.base / 'lower-sequence-output'
with self.assertRaisesRegex(publish_update.PublishError, '不能低于'):
self.build(version='2026.11.04.1', sequence=1, allow_baseline=True)
def test_rejects_sensitive_program_path_and_missing_program_inventory(self):
sensitive_name = 'ai/nao-quality/private/model.json'
sensitive_path = self.root.joinpath(*sensitive_name.split('/'))
sensitive_path.parent.mkdir(parents=True, exist_ok=True)
sensitive_path.write_bytes(b'private model config')
self.manifest['files'].append({'path': sensitive_name, 'sha256': hashlib.sha256(sensitive_path.read_bytes()).hexdigest()})
(self.root / 'manifest.json').write_text(json.dumps(self.manifest), encoding='utf-8')
with self.assertRaisesRegex(publish_update.PublishError, '受保护'):
self.build()
self.manifest['files'].pop()
self.manifest['files'] = [entry for entry in self.manifest['files'] if entry['path'] != 'scripts/runtime.py']
(self.root / 'manifest.json').write_text(json.dumps(self.manifest), encoding='utf-8')
with self.assertRaisesRegex(publish_update.PublishError, '完整程序文件清单'):
self.build()
def test_refuses_key_inside_source_or_output_and_refuses_overwrite(self):
with self.assertRaisesRegex(publish_update.PublishError, '部署包和更新产物目录之外'):
self.build(private_key_path=self.root / 'manifest.json')
with self.assertRaisesRegex(publish_update.PublishError, '部署包目录之外'):
self.build(output_dir=self.root / 'updates')
self.build()
original_latest = (self.output / 'latest.json').read_bytes()
with self.assertRaisesRegex(publish_update.PublishError, '同名发布文件'):
self.build()
self.assertEqual(original_latest, (self.output / 'latest.json').read_bytes())
if __name__ == '__main__':
unittest.main()