Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

feat(update): Windows 应用内更新校验发布摘要的 Ed25519 签名

longmeidao646d3b5f16f3
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index cf13961b8..c9abeee90 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -394,6 +394,8 @@ jobs:
needs: validate
runs-on: ubuntu-latest
timeout-minutes: 10
+ # 发布签名私钥放在这个只允许 `v*` 标签部署的 environment 里(ADR-0134)。
+ environment: release
permissions:
contents: write
actions: read
@@ -402,12 +404,26 @@ jobs:
- uses: actions/setup-python@v7
with:
python-version: '3.14'
+ - uses: astral-sh/[email protected]
+ with:
+ enable-cache: true
+ cache-dependency-glob: uv.lock
- name: 核对并取得同提交演练产物
env:
GH_TOKEN: ${{ github.token }}
run: |
python scripts/github_release_candidate.py desktop --destination release
python scripts/github_release_candidate.py macos --destination macos-candidates
+ - name: 生成并签名发布摘要
+ env:
+ PEACH_RELEASE_SIGNING_KEY: ${{ secrets.PEACH_RELEASE_SIGNING_KEY }}
+ run: |
+ set -euo pipefail
+ uv sync --locked --python python
+ cp macos-candidates/release/*.dmg release/
+ (cd release && sha256sum ./*.zip ./*-setup.exe ./*.dmg > SHA256SUMS.txt)
+ # 源码没有发布公钥且没配私钥时跳过;公钥已随源码发出却缺私钥时失败,不发布未签名的版本。
+ printf '%s' "$PEACH_RELEASE_SIGNING_KEY" | .venv/bin/python scripts/sign_release.py --sums release/SHA256SUMS.txt
- name: 创建预发布
env:
GH_TOKEN: ${{ github.token }}
@@ -415,10 +431,10 @@ jobs:
VERSION: ${{ github.ref_name }}
run: |
cd release
- cp ../macos-candidates/release/*.dmg .
tail -n +4 ../macos-candidates/scripts/MACOS_DOWNLOADS.md >> RELEASE_NOTES.md
- sha256sum ./*.zip ./*-setup.exe ./*.dmg > SHA256SUMS.txt
- gh release create "$GITHUB_REF_NAME" ./*.zip ./*-setup.exe ./*.dmg SHA256SUMS.txt --verify-tag --prerelease --title "Peach ${VERSION#v} · Windows / macOS 测试版" --notes-file RELEASE_NOTES.md
+ files=(./*.zip ./*-setup.exe ./*.dmg SHA256SUMS.txt)
+ if [ -f SHA256SUMS.txt.sig ]; then files+=(SHA256SUMS.txt.sig); fi
+ gh release create "$GITHUB_REF_NAME" "${files[@]}" --verify-tag --prerelease --title "Peach ${VERSION#v} · Windows / macOS 测试版" --notes-file RELEASE_NOTES.md
# Sparkle 更新源(ADR-0130):Release 公开之后才写 appcast,下载地址指向同一 Release 的 DMG。
# 私钥只在这一个仅标签运行的作业里经标准输入交给官方工具;仓库变量未开启时整个作业跳过。
diff --git a/pyproject.toml b/pyproject.toml
index 64573ab92..662386411 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,6 +57,8 @@ dependencies = [
"watchdog==6.0.0",
"zeroconf==0.153.0",
"smbprotocol==1.17.0",
+ # 应用内更新校验发布签名(Ed25519,ADR-0134)。
+ "cryptography==50.0.2",
]
[project.urls]
diff --git a/scripts/sign_release.py b/scripts/sign_release.py
new file mode 100644
index 000000000..be6854706
--- /dev/null
+++ b/scripts/sign_release.py
@@ -0,0 +1,69 @@
+"""给发布目录的 `SHA256SUMS.txt` 写 Ed25519 签名,并用客户端的校验代码核对(ADR-0134)。
+
+私钥从标准输入读,一行一把(32 字节 seed 的 base64);轮换期同时给新旧两把,签名文件各写一行。
+源码的 `PUBLIC_KEYS` 为空且没给私钥时跳过签名;公钥已随源码发出却没给私钥时拒绝发布,
+否则这一版起的客户端再也装不上新版本。`--generate-key` 供维护者生成正式密钥对。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from peach import release_signing # noqa: E402
+
+
+def sign(sums: Path, private_keys: list[str], trusted: tuple[str, ...] | None = None) -> dict:
+ trusted = release_signing.PUBLIC_KEYS if trusted is None else trusted
+ target = sums.with_name(release_signing.SIGNATURE)
+ if not private_keys:
+ if trusted:
+ raise ValueError("源码已带发布公钥,缺少签名私钥时不能发布")
+ return {"signed": False, "reason": "源码没有发布公钥,也没有签名私钥"}
+ content = sums.read_bytes()
+ release_signing.parse(content)
+ public = [release_signing.public_key(key) for key in private_keys]
+ unknown = [key for key in public if trusted and key not in trusted]
+ if unknown:
+ raise ValueError("签名私钥对应的公钥不在源码的 PUBLIC_KEYS 里:" + "、".join(unknown))
+ target.write_bytes("".join(release_signing.sign(content, key) for key in private_keys).encode("ascii"))
+ # 源码还没有公钥时用这次的公钥自验,至少证明签名文件本身读得回来。
+ release_signing.verify(content, target.read_bytes(), trusted or tuple(public))
+ return {"signed": True, "signature": str(target), "public_keys": public, "trusted_by_source": bool(trusted)}
+
+
+def generate_key(path: Path) -> dict:
+ """维护者生成正式密钥对:私钥只写进指定文件(已存在就拒绝覆盖),输出里只有公钥。"""
+ import base64
+ from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+ from cryptography.hazmat.primitives.serialization import Encoding, NoEncryption, PrivateFormat
+ seed = Ed25519PrivateKey.generate().private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())
+ private = base64.b64encode(seed).decode("ascii")
+ try:
+ with path.open("x", encoding="ascii", newline="\n") as output:
+ output.write(private + "\n")
+ except FileExistsError:
+ raise ValueError(f"{path} 已存在,不覆盖已有私钥") from None
+ return {"private_key_file": str(path), "public_key": release_signing.public_key(private)}
+
+
+def main(argv: list[str] | None = None) -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ action = parser.add_mutually_exclusive_group(required=True)
+ action.add_argument("--sums", type=Path, help="发布目录里的 SHA256SUMS.txt;私钥从标准输入读")
+ action.add_argument("--generate-key", type=Path, metavar="PATH", help="生成新密钥对,私钥写进 PATH")
+ args = parser.parse_args(argv)
+ try:
+ result = generate_key(args.generate_key) if args.generate_key else sign(args.sums, sys.stdin.read().split())
+ print(json.dumps(result, ensure_ascii=False))
+ except ValueError as error:
+ print(f"发布签名未完成:{error}")
+ return 1
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/test_runner.py b/scripts/test_runner.py
index 5d08aa6de..6fa859c8c 100644
--- a/scripts/test_runner.py
+++ b/scripts/test_runner.py
@@ -116,7 +116,7 @@ SCOPES: dict[str, tuple[str, ...]] = {
"test_version_bump.py", "test_changelog.py", "test_release_due.py", "test_release_candidate.py", "test_media_build_cache.py", "test_runner_launcher.py",
"test_restart_windows_tray.py", "test_deploy_windows_tray.py", "test_runtime_prepare.py",
"test_buildinfo.py", "test_versioning.py", "test_macos_standalone.py",
- "test_windows_update.py", "test_release_updates.py", "test_automatic_updates.py", "test_standalone_update.py", "test_upgrade_repairs.py", "test_certs.py", "test_config.py",
+ "test_windows_update.py", "test_release_updates.py", "test_release_signing.py", "test_automatic_updates.py", "test_standalone_update.py", "test_upgrade_repairs.py", "test_certs.py", "test_config.py",
"test_fsutil.py", "test_desktop_settings.py", "test_desktop_installer.py", "test_data_storage.py",
"test_job_status.py", "test_jobs.py", "test_task_runs.py", "test_followups.py", "test_update_tasks.py",
"test_task_center_integration.py", "test_task_control.py", "test_task_resources.py", "test_resource_platform.py", "test_reference_updates.py",
@@ -189,6 +189,8 @@ AUTO_SCOPE_FILES: dict[str, tuple[str, ...]] = {
"scripts/fetch_sparkle_macos.py": ("tooling", "packaging"),
"scripts/sparkle-macos.json": ("tooling", "packaging"),
"scripts/sparkle_appcast.py": ("tooling", "packaging"),
+ # 发布签名脚本的用例与客户端校验放在同一份 `test_release_signing.py` 里。
+ "scripts/sign_release.py": ("tooling",),
"scripts/fetch_ffmpeg_sources.py": ("tooling", "packaging"),
"scripts/ffmpeg-sources.json": ("tooling", "packaging"),
"scripts/build_ffmpeg_windows.sh": ("tooling", "packaging"),
diff --git a/src/peach/release_signing.py b/src/peach/release_signing.py
new file mode 100644
index 000000000..64d97037d
--- /dev/null
+++ b/src/peach/release_signing.py
@@ -0,0 +1,76 @@
+"""Windows 独立包更新的发布签名(ADR-0134)。
+
+每个版本的 `SHA256SUMS.txt` 由发布作业用 Ed25519 私钥签名,签名写在同目录的
+`SHA256SUMS.txt.sig`,一行一个签名:`<公钥 base64> <签名 base64>`。更新器只认
+`PUBLIC_KEYS` 里的公钥验过的摘要,不再采信 GitHub API 或 `releases.json` 给的 `digest`。
+"""
+from __future__ import annotations
+
+import base64
+import re
+
+#: 受信任的发布签名公钥(base64,32 字节 Ed25519)。为空时更新器不要求签名;随某一版发出后,
+#: 这一版起的客户端只装签名验得过的版本,发布作业缺私钥即失败。轮换见 ADR-0134。
+PUBLIC_KEYS: tuple[str, ...] = ()
+SUMS = "SHA256SUMS.txt"
+SIGNATURE = SUMS + ".sig"
+#: 签名内容的前缀:同一把私钥签出的别的东西不会被当成发布摘要。
+CONTEXT = b"peach-release-sha256sums-v1\n"
+MAX_BYTES = 1024 * 1024
+_LINE = re.compile(r"([0-9a-f]{64}) [ *](?:\./)?([A-Za-z0-9_.-]+)")
+
+
+def _key_bytes(text: str) -> bytes:
+ raw = base64.b64decode(text, validate=True)
+ if len(raw) != 32:
+ raise ValueError("Ed25519 密钥必须是 32 字节")
+ return raw
+
+
+def public_key(private_key: str) -> str:
+ """私钥(32 字节 seed 的 base64,与 Sparkle 的 `--ed-key-file` 同一格式)对应的公钥。"""
+ from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+ from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+ key = Ed25519PrivateKey.from_private_bytes(_key_bytes(private_key))
+ return base64.b64encode(key.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)).decode("ascii")
+
+
+def sign(sums: bytes, private_key: str) -> str:
+ """签名文件里的一行。"""
+ from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+ signature = Ed25519PrivateKey.from_private_bytes(_key_bytes(private_key)).sign(CONTEXT + sums)
+ return f"{public_key(private_key)} {base64.b64encode(signature).decode('ascii')}\n"
+
+
+def parse(sums: bytes) -> dict[str, str]:
+ """`sha256sum` 的输出:文件名到摘要;同名出现两次视为无效。"""
+ digests: dict[str, str] = {}
+ for line in sums.decode("utf-8").splitlines():
+ match = _LINE.fullmatch(line)
+ if match is None or match[2] in digests:
+ raise ValueError("发布摘要格式无效")
+ digests[match[2]] = match[1]
+ if not digests:
+ raise ValueError("发布摘要为空")
+ return digests
+
+
+def verify(sums: bytes, signature: bytes, keys: tuple[str, ...] | None = None) -> dict[str, str]:
+ """有一行签名能被受信任公钥验过,才解析并返回摘要;否则抛 ValueError。"""
+ from cryptography.exceptions import InvalidSignature
+ from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+ trusted = PUBLIC_KEYS if keys is None else keys
+ if len(sums) > MAX_BYTES or len(signature) > MAX_BYTES:
+ raise ValueError("发布签名文件过大")
+ for line in signature.decode("ascii", "replace").splitlines():
+ fields = line.split()
+ # 不认得的行(受信任集合之外的公钥、以后的新格式)跳过,轮换期新旧签名可以并列。
+ if len(fields) != 2 or fields[0] not in trusted:
+ continue
+ try:
+ Ed25519PublicKey.from_public_bytes(_key_bytes(fields[0])).verify(
+ base64.b64decode(fields[1], validate=True), CONTEXT + sums)
+ except (InvalidSignature, ValueError):
+ continue
+ return parse(sums)
+ raise ValueError("发布签名校验未通过")
diff --git a/src/peach/standalone_update.py b/src/peach/standalone_update.py
index 317f6ab06..8226e0659 100644
--- a/src/peach/standalone_update.py
+++ b/src/peach/standalone_update.py
@@ -18,7 +18,7 @@ import zipfile
import httpx
from filelock import FileLock, Timeout
-from . import __version__, desktop_installer, distribution, release_updates, settings_file, update_packages
+from . import __version__, desktop_installer, distribution, release_signing, release_updates, settings_file, update_packages
from .fsutil import atomic_write_text
from .windows_update import replace_with_retry
from . import update_tasks
@@ -179,6 +179,43 @@ def prepare_tools(stage: Path, target: Path, transaction: Path, release: dict, d
raise ValueError(f"{tool} 工具复用校验失败")
+def _fetch_small(client, url: str) -> bytes:
+ body = bytearray()
+ with client.stream("GET", url) as response:
+ response.raise_for_status()
+ for chunk in response.iter_bytes(64 * 1024):
+ body += chunk
+ if len(body) > release_signing.MAX_BYTES:
+ raise ValueError("发布签名文件过大")
+ return bytes(body)
+
+
+def signed_release(release: dict) -> dict:
+ """源码带发布公钥时,更新包与完整包的摘要只取签名验过的 `SHA256SUMS.txt`(ADR-0134)。
+
+ 两个公开源依次尝试;都验不过就不升级,已装版本原样保留。
+ """
+ if not release_signing.PUBLIC_KEYS:
+ return release
+ from .peach_proxy import http_client
+ directory, name = release["asset_url"].rsplit("/", 1)
+ digests = {}
+ for url in release_updates.download_sources(f"{directory}/{release_signing.SUMS}"):
+ try:
+ with http_client(follow_redirects=True, timeout=30) as client:
+ sums = _fetch_small(client, url)
+ signature = _fetch_small(client, url + ".sig")
+ digests = release_signing.verify(sums, signature)
+ break
+ except (httpx.HTTPError, ValueError):
+ continue
+ if name not in digests:
+ raise ValueError("发布签名校验未通过,已停止更新;请到发布页手动下载新版本")
+ full = release.get("full_url")
+ full = digests.get(full.rsplit("/", 1)[1]) if isinstance(full, str) else None
+ return dict(release, asset_digest="sha256:" + digests[name], full_digest=full and "sha256:" + full)
+
+
def checked_asset(digest: object, size: object, label: str) -> tuple[str, int]:
if not isinstance(digest, str) or not digest.startswith("sha256:") or len(digest) != 71:
raise ValueError(f"{label}缺少 SHA-256 校验信息")
@@ -208,6 +245,7 @@ def prepare(data: dict, lock: FileLock) -> None:
release = release_updates.check()
if release["state"] != "available":
raise ValueError(release["message"])
+ release = signed_release(release)
digest, total = checked_asset(release.get("asset_digest"), release.get("asset_size", 0), "更新包")
target = Path(sys.executable).resolve().parent
if state_path().resolve().is_relative_to(target):
diff --git a/tests/test_dependency_policy.py b/tests/test_dependency_policy.py
index f962f84f5..ab5e4b277 100644
--- a/tests/test_dependency_policy.py
+++ b/tests/test_dependency_policy.py
@@ -197,6 +197,7 @@ class DependencyPolicyTests(unittest.TestCase):
"browserexport": "browserexport",
"ahocorasick": "pyahocorasick",
"bs4": "beautifulsoup4",
+ "cryptography": "cryptography",
"curl_cffi": "curl_cffi",
"cv2": "opencv-python-headless",
"dmgbuild": "dmgbuild",
diff --git a/tests/test_release_signing.py b/tests/test_release_signing.py
new file mode 100644
index 000000000..a77cbf2a9
--- /dev/null
+++ b/tests/test_release_signing.py
@@ -0,0 +1,160 @@
+"""发布摘要签名:客户端校验与发布脚本,密钥都在测试里临时生成(ADR-0134)。"""
+import base64
+import contextlib
+import io
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+from cryptography.hazmat.primitives.serialization import Encoding, NoEncryption, PrivateFormat
+
+from peach import release_signing
+from scripts import sign_release
+
+SUMS = (b"%s ./Peach-1.0.0-windows-x64.zip\n%s ./Peach-1.0.0-windows-x64-update.zip\n"
+ % (b"a" * 64, b"b" * 64))
+
+
+def keypair() -> tuple[str, str]:
+ seed = Ed25519PrivateKey.generate().private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())
+ private = base64.b64encode(seed).decode("ascii")
+ return private, release_signing.public_key(private)
+
+
+class VerifyTests(unittest.TestCase):
+ def setUp(self):
+ self.private, self.public = keypair()
+
+ def test_signed_sums_yield_the_listed_digests(self):
+ signature = release_signing.sign(SUMS, self.private).encode()
+ self.assertEqual(release_signing.verify(SUMS, signature, (self.public,)),
+ {"Peach-1.0.0-windows-x64.zip": "a" * 64, "Peach-1.0.0-windows-x64-update.zip": "b" * 64})
+
+ def test_one_changed_byte_is_rejected(self):
+ signature = release_signing.sign(SUMS, self.private).encode()
+ tampered = SUMS.replace(b"a" * 64, b"c" + b"a" * 63, 1)
+ with self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(tampered, signature, (self.public,))
+ broken = bytearray(signature)
+ broken[50] ^= 1
+ with self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(SUMS, bytes(broken), (self.public,))
+
+ def test_a_key_the_client_does_not_trust_is_rejected(self):
+ other, other_public = keypair()
+ signature = release_signing.sign(SUMS, other).encode()
+ with self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(SUMS, signature, (self.public,))
+ # 把信任的公钥写进签名行、签名却出自另一把私钥,同样过不了。
+ forged = signature.replace(other_public.encode(), self.public.encode())
+ with self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(SUMS, forged, (self.public,))
+
+ def test_missing_or_empty_signature_is_rejected(self):
+ for signature in (b"", b"\n", b"not a signature\n"):
+ with self.subTest(signature=signature), self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(SUMS, signature, (self.public,))
+
+ def test_rotation_accepts_either_trusted_key(self):
+ new, new_public = keypair()
+ both = (release_signing.sign(SUMS, self.private) + release_signing.sign(SUMS, new)).encode()
+ for trusted in ((self.public,), (new_public,), (self.public, new_public)):
+ with self.subTest(trusted=trusted):
+ self.assertIn("Peach-1.0.0-windows-x64.zip", release_signing.verify(SUMS, both, trusted))
+ # 换签名私钥之后,新旧公钥并存的客户端照样认。
+ only_new = release_signing.sign(SUMS, new).encode()
+ self.assertTrue(release_signing.verify(SUMS, only_new, (self.public, new_public)))
+ with self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(SUMS, only_new, (self.public,))
+
+ def test_sums_must_be_well_formed_once_the_signature_holds(self):
+ for sums in (b"", b"%s Peach.zip\n%s Peach.zip\n" % (b"a" * 64, b"b" * 64), b"zz ../Peach.zip\n"):
+ with self.subTest(sums=sums), self.assertRaises(ValueError):
+ release_signing.verify(sums, release_signing.sign(sums, self.private).encode(), (self.public,))
+
+ def test_published_public_keys_are_well_formed(self):
+ # 写入正式公钥时多了空格或截断,在这里红,而不是让每次在线更新都验不过。
+ for key in release_signing.PUBLIC_KEYS:
+ with self.subTest(key=key):
+ self.assertEqual(len(release_signing._key_bytes(key)), 32)
+
+ def test_an_empty_trust_set_never_verifies(self):
+ with self.assertRaisesRegex(ValueError, "签名校验未通过"):
+ release_signing.verify(SUMS, release_signing.sign(SUMS, self.private).encode(), ())
+
+
+class SignScriptTests(unittest.TestCase):
+ def setUp(self):
+ folder = tempfile.TemporaryDirectory()
+ self.addCleanup(folder.cleanup)
+ self.sums = Path(folder.name) / release_signing.SUMS
+ self.sums.write_bytes(SUMS)
+ self.signature = self.sums.with_name(release_signing.SIGNATURE)
+ self.private, self.public = keypair()
+
+ def test_release_rehearsal_signs_with_a_test_key_the_client_accepts(self):
+ result = sign_release.sign(self.sums, [self.private], (self.public,))
+ self.assertTrue(result["signed"] and result["trusted_by_source"], result)
+ self.assertNotIn(b"\r", self.signature.read_bytes())
+ with patch.object(release_signing, "PUBLIC_KEYS", (self.public,)):
+ self.assertEqual(len(release_signing.verify(SUMS, self.signature.read_bytes())), 2)
+
+ def test_without_source_keys_or_private_key_signing_is_skipped(self):
+ self.assertFalse(sign_release.sign(self.sums, [], ())["signed"])
+ self.assertFalse(self.signature.exists())
+
+ def test_published_public_keys_require_a_private_key(self):
+ with self.assertRaisesRegex(ValueError, "缺少签名私钥"):
+ sign_release.sign(self.sums, [], (self.public,))
+ self.assertFalse(self.signature.exists())
+
+ def test_a_private_key_outside_the_source_keys_is_refused(self):
+ other, _ = keypair()
+ with self.assertRaisesRegex(ValueError, "不在源码的 PUBLIC_KEYS"):
+ sign_release.sign(self.sums, [other], (self.public,))
+ self.assertFalse(self.signature.exists())
+
+ def test_first_signed_release_can_precede_the_source_keys(self):
+ result = sign_release.sign(self.sums, [self.private], ())
+ self.assertEqual((result["signed"], result["trusted_by_source"]), (True, False))
+ self.assertTrue(release_signing.verify(SUMS, self.signature.read_bytes(), (self.public,)))
+
+ def test_rotation_writes_one_line_per_private_key(self):
+ new, new_public = keypair()
+ sign_release.sign(self.sums, [self.private, new], (self.public, new_public))
+ self.assertEqual([line.split()[0] for line in self.signature.read_text().splitlines()],
+ [self.public, new_public])
+
+ def test_generated_key_stays_in_its_file_and_signs_for_the_printed_public_key(self):
+ path = self.sums.with_name("signing.key")
+ output = io.StringIO()
+ with contextlib.redirect_stdout(output):
+ self.assertEqual(sign_release.main(["--generate-key", str(path)]), 0)
+ result = json.loads(output.getvalue())
+ private = path.read_text(encoding="ascii").strip()
+ self.assertNotIn(private, output.getvalue())
+ self.assertEqual(release_signing.public_key(private), result["public_key"])
+ sign_release.sign(self.sums, [private], (result["public_key"],))
+ output = io.StringIO()
+ with contextlib.redirect_stdout(output):
+ self.assertEqual(sign_release.main(["--generate-key", str(path)]), 1)
+ self.assertEqual(path.read_text(encoding="ascii").strip(), private)
+
+ def test_cli_reads_keys_from_stdin_and_reports_failures(self):
+ output = io.StringIO()
+ with patch.object(release_signing, "PUBLIC_KEYS", (self.public,)), patch(
+ "sys.stdin", io.StringIO(self.private + "\n")), contextlib.redirect_stdout(output):
+ self.assertEqual(sign_release.main(["--sums", str(self.sums)]), 0)
+ self.assertTrue(json.loads(output.getvalue())["signed"])
+ output = io.StringIO()
+ with patch.object(release_signing, "PUBLIC_KEYS", (self.public,)), patch(
+ "sys.stdin", io.StringIO("")), contextlib.redirect_stdout(output):
+ self.assertEqual(sign_release.main(["--sums", str(self.sums)]), 1)
+ self.assertIn("缺少签名私钥", output.getvalue())
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_standalone_update.py b/tests/test_standalone_update.py
index d88c546a7..7891928cd 100644
--- a/tests/test_standalone_update.py
+++ b/tests/test_standalone_update.py
@@ -1,4 +1,5 @@
"""独立包更新使用临时目录验证路径、进度、重启确认及回滚。"""
+import base64
import json
import hashlib
import os
@@ -11,9 +12,11 @@ import unittest
from unittest.mock import Mock, patch
import zipfile
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+from cryptography.hazmat.primitives.serialization import Encoding, NoEncryption, PrivateFormat
import httpx
-from peach import settings_file, standalone_update as update
+from peach import release_signing, settings_file, standalone_update as update
from peach import update_packages
from scripts.package_windows_release import package as package_release
from scripts.smoke_split_update import verify as verify_split
@@ -303,6 +306,8 @@ class StandaloneUpdateTests(unittest.TestCase):
def response(request):
name = request.url.path.rsplit("/", 1)[1]
requests.append(name)
+ if not (output / name).is_file():
+ return httpx.Response(404)
content = (output / name).read_bytes()
return httpx.Response(200, content=b"corrupt" if name == corrupt else content)
client_type = update.httpx.Client
@@ -539,6 +544,53 @@ class StandaloneUpdateTests(unittest.TestCase):
self.assertEqual(state["downloaded"], state["total"])
self.assertEqual((target / "Peach.exe").read_bytes(), b"old application")
+ def sign_output(self, output):
+ """像发布作业那样给发布目录写 `sha256sum` 摘要与签名;返回受信任公钥。"""
+ private = base64.b64encode(Ed25519PrivateKey.generate().private_bytes(
+ Encoding.Raw, PrivateFormat.Raw, NoEncryption())).decode("ascii")
+ sums = "".join(f"{update_packages.digest(path)} ./{path.name}\n" for path in sorted(output.glob("*.zip")))
+ (output / release_signing.SUMS).write_bytes(sums.encode())
+ (output / release_signing.SIGNATURE).write_bytes(release_signing.sign(sums.encode(), private).encode())
+ return release_signing.public_key(private)
+
+ def test_signed_release_installs_after_the_sums_signature_verifies(self):
+ source, output, manifest, target, archive, release = self.release_fixture()
+ public = self.sign_output(output)
+ with patch.object(update.release_signing, "PUBLIC_KEYS", (public,)):
+ state, requests = self.prepare_fixture(target, output, release)
+ self.assertEqual(state["state"], "ready", state)
+ self.assertEqual(requests[:3], [release_signing.SUMS, release_signing.SIGNATURE, archive.name])
+
+ def test_a_package_swapped_together_with_its_listed_digest_is_refused(self):
+ source, output, manifest, target, archive, release = self.release_fixture()
+ public = self.sign_output(output)
+ # 渠道被篡改:发布记录里的摘要与大小跟着替换后的包一起改了,只有签过名的摘要还是原来的。
+ release.update(asset_size=len(b"corrupt"), asset_digest="sha256:" + hashlib.sha256(b"corrupt").hexdigest())
+ with patch.object(update.release_signing, "PUBLIC_KEYS", (public,)):
+ state, requests = self.prepare_fixture(target, output, release, corrupt=archive.name)
+ self.assertEqual(state["state"], "error", state)
+ self.assertIn("校验失败", state["message"])
+ self.assertEqual((target / "Peach.exe").read_bytes(), b"old application")
+
+ def test_missing_or_untrusted_signature_stops_before_any_download(self):
+ for case in ("missing", "untrusted"):
+ with self.subTest(case=case):
+ source, output, manifest, target, archive, release = self.release_fixture()
+ public = self.sign_output(output)
+ if case == "missing":
+ (output / release_signing.SIGNATURE).unlink()
+ else:
+ self.sign_output(output) # 换一把客户端不认得的私钥重签
+ with patch.object(update.release_signing, "PUBLIC_KEYS", (public,)):
+ state, requests = self.prepare_fixture(target, output, release)
+ self.assertEqual(state["state"], "error", state)
+ self.assertIn("发布签名校验未通过", state["message"])
+ self.assertNotIn(archive.name, requests)
+ self.assertEqual(list(target.parent.glob(f".{target.name}-update-*")), [])
+ self.assertEqual((target / "Peach.exe").read_bytes(), b"old application")
+ for folder in (self.root / "dist", output, target):
+ shutil.rmtree(folder)
+
def test_supported_older_clients_can_install_this_release(self):
"""旧版本标签里的更新代码原样读这一版的发布条目与更新包(ADR-0120)。"""
from scripts import update_compat
diff --git a/uv.lock b/uv.lock
index 518addd7c..a7139d3ae 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1240,6 +1240,7 @@ dependencies = [
{ name = "beautifulsoup4" },
{ name = "bencode2" },
{ name = "browserexport" },
+ { name = "cryptography" },
{ name = "curl-cffi" },
{ name = "fastapi" },
{ name = "filelock" },
@@ -1298,6 +1299,7 @@ requires-dist = [
{ name = "beautifulsoup4", specifier = "==4.15.0" },
{ name = "bencode2", specifier = "==0.3.38" },
{ name = "browserexport", specifier = "==0.4.4" },
+ { name = "cryptography", specifier = "==50.0.2" },
{ name = "curl-cffi", specifier = "==0.17.0" },
{ name = "dmgbuild", marker = "sys_platform == 'darwin' and extra == 'build'", specifier = "==1.6.7" },
{ name = "fastapi", specifier = "==0.162.0" },