176 lines
8.7 KiB
Python
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()
|