Files
apps/tests/node_release_test.py
waozi 3743714683 Offer each host only node releases it can run, and publish WebAssembly variants
The publisher refuses a payload whose ZX header revision differs from the
ledger's zx_revision. The node's history keeps the newest release of every
payload format, ZX revision, host_api and module_api besides the newest ten,
and every archive stays. The remote catalog asks with its oldest host
interface and ZX revision.

A node app may publish NAME.wasm, lowered from NAME.zx, as a signed variant
of the same release (release-SEQUENCE.wasm.json). The receiver checks that it
signs this release and its exact module, and publication verifies the node
serves it to format=wasm.

Also validate signed package sizes against checked integer ranges and verify
public payloads incrementally (read_bundle, verify_payload), which these
changes build on.
2026-11-16 02:44:29 -03:00

517 lines
31 KiB
Python

"""Sign, publish and offer the releases of apps the node offers, offline."""
from hashlib import sha256
import importlib.util
from io import BytesIO
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
from urllib.error import HTTPError
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
ROOT = Path(__file__).resolve().parent.parent
spec = importlib.util.spec_from_file_location("node_release", ROOT / "scripts/node_release.py")
release = importlib.util.module_from_spec(spec)
spec.loader.exec_module(release)
class NodeAppHistoryTest(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.directory = Path(self.temporary.name)
self.store = self.directory / "packages"
self.key = Ed25519PrivateKey.generate()
public = self.key.public_key().public_bytes(serialization.Encoding.Raw,
serialization.PublicFormat.Raw).hex()
self.publishers = [dict(key_id="test", public_key=public, app_ids=[], app_prefixes=["inbe."])]
def release(self, sequence, key=None, signature=b"ZX\0\0", host_api=2):
data = signature + b"photos-" + str(sequence).encode()
value = dict(app_id="inbe.photos", sequence=sequence, version=f"1.0.{sequence}",
runtime="kryon-app-v1", host_api=host_api, module_api=2, data_schema=0, key_id="test",
artifacts=[dict(variant="module", sha256=sha256(data).hexdigest(), size=len(data))],
dependencies=[])
value["signature"] = (key or self.key).sign(release.signing_message(value)).hex()
value["channel"] = "beta"
return value, data
def publish(self, value, data, suffix=None, wasm=None):
encoded = json.dumps(value).encode()
payload = value["artifacts"][0]["sha256"] + (suffix or release.payload_suffix(data))
entries = {"inbe.photos/latest-v2.json": encoded, f"inbe.photos/{payload}": data,
f"inbe.photos/{payload}.release-v2.json": encoded,
f"inbe.photos/release-{value['sequence']}.json": encoded}
if wasm is not None:
entries.update(self.wasm_entries(value, wasm))
release.import_node_app(entries, self.store, self.publishers, "inbe.photos")
def wasm_entries(self, value, module, key=None):
"""The archive entries of a release's signed WebAssembly variant."""
variant = {field: item for field, item in value.items() if field != "signature"}
variant["artifacts"] = [dict(variant="module", sha256=sha256(module).hexdigest(), size=len(module))]
variant["signature"] = (key or self.key).sign(release.signing_message(variant)).hex()
encoded = json.dumps(variant).encode()
name = "inbe.photos/" + variant["artifacts"][0]["sha256"] + ".wasm"
return {f"inbe.photos/release-{value['sequence']}.wasm.json": encoded, name: module,
name + ".release-v2.json": encoded}
@staticmethod
def revision(number):
return b"ZX\0\0" + number.to_bytes(4, "little")
def history(self):
return json.loads((self.store / "inbe.photos" / "history-v2.json").read_bytes())["versions"]
def test_signed_artifact_sizes_use_checked_integer_range(self):
for size in (64 * 1024 * 1024 + 1, release.PACKAGE_MAXIMUM_BYTES):
value, _ = self.release(1)
value['artifacts'][0]['size'] = size
value['signature'] = self.key.sign(release.signing_message(value)).hex()
release.validate_release(value, 'inbe.photos', self.publishers)
for size in (False, 7, 2**63 - 1, 2**64, 12.5):
value, _ = self.release(1)
value['artifacts'][0]['size'] = size
value['signature'] = self.key.sign(release.signing_message(value)).hex()
with self.subTest(size=size), self.assertRaises(ValueError):
release.validate_release(value, 'inbe.photos', self.publishers)
def test_public_payload_verification_streams_and_rejects_damage(self):
data = b'ZX\0\0' + b'payload' * 20000
descriptor = dict(size=len(data), sha256=sha256(data).hexdigest())
class Chunked(BytesIO):
def read(self, size=-1):
if not 0 < size <= 65536:
raise AssertionError('Unbounded payload read')
return super().read(size)
self.assertTrue(release.verify_payload(Chunked(data), descriptor))
for damaged in (data[:-1], data + b'x', data[:-1] + b'x'):
self.assertFalse(release.verify_payload(Chunked(damaged), descriptor))
for size in (False, 7, 2**63):
self.assertFalse(release.verify_payload(Chunked(data), descriptor | dict(size=size)))
def test_local_payload_reads_require_exact_checked_size(self):
path = self.directory / 'app.zx'
path.write_bytes(b'ZX\0\0payload')
self.assertEqual(release.read_bundle(path), path.read_bytes())
path.write_bytes(b'not an executable')
with self.assertRaises(ValueError):
release.read_bundle(path)
path.write_bytes(b'ZX')
with self.assertRaises(ValueError):
release.read_bundle(path)
def test_node_keeps_the_newest_ten_releases(self):
values = []
for sequence in range(1, 13):
value, data = self.release(sequence)
self.publish(value, data)
values.append(value)
self.assertEqual(self.history(), list(reversed(values))[:10])
# Every release stays archived; only the history is limited to ten.
self.assertEqual(len(list((self.store / "inbe.photos").glob("release-*.json"))), 12)
def test_history_lists_only_trusted_releases_with_their_bundle(self):
for sequence in range(1, 4):
self.publish(*self.release(sequence))
directory = self.store / "inbe.photos"
forged, _ = self.release(9, key=Ed25519PrivateKey.generate())
(directory / "release-9.json").write_text(json.dumps(forged))
(directory / (self.history()[2]["artifacts"][0]["sha256"] + ".zx")).unlink()
pins = self.directory / "publishers.json"
pins.write_text(json.dumps(self.publishers))
release.write_histories(self.store, pins)
self.assertEqual([value["sequence"] for value in self.history()], [3, 2])
def test_hosts_from_before_the_zx_format_keep_their_last_release(self):
legacy, data = self.release(1, signature=b"ZIB\0")
self.publish(legacy, data)
for sequence in range(2, 13):
self.publish(*self.release(sequence))
self.assertEqual([value["sequence"] for value in self.history()], [12, 11, 10, 9, 8, 7, 6, 5, 4, 1])
directory = self.store / "inbe.photos"
self.assertTrue((directory / (legacy["artifacts"][0]["sha256"] + ".zib")).is_file())
latest = json.loads((directory / "latest-v2.json").read_bytes())
self.assertTrue((directory / (latest["artifacts"][0]["sha256"] + ".zx")).is_file())
def test_history_keeps_the_newest_release_of_every_revision_and_interface(self):
# Released hosts run ZX revision 26 on host interface 43; hosts from
# interface 44 run revision 28, and only one release has a web variant.
released, data = self.release(1, signature=self.revision(26), host_api=43)
self.publish(released, data)
web, data = self.release(2, signature=self.revision(28), host_api=44)
self.publish(web, data, wasm=b"\0asm\x01\0\0\0photos-2")
for sequence in range(3, 16):
self.publish(*self.release(sequence, signature=self.revision(28), host_api=44))
self.assertEqual([value["sequence"] for value in self.history()], [15, 14, 13, 12, 11, 10, 9, 8, 2, 1])
directory = self.store / "inbe.photos"
self.assertEqual(len(list(directory.glob("release-*.json"))), 16)
self.assertTrue((directory / "release-2.wasm.json").is_file())
# A release mistakenly built with revision 28 for interface 43 is its
# own group; it never displaces the released hosts' last release.
self.publish(*self.release(16, signature=self.revision(28), host_api=43))
self.assertEqual([value["sequence"] for value in self.history()], [16, 15, 14, 13, 12, 11, 10, 9, 2, 1])
def test_history_never_exceeds_what_the_node_reads(self):
for sequence in range(1, release.HISTORY_LIMIT + 3):
self.publish(*self.release(sequence, signature=self.revision(28), host_api=sequence))
history = self.history()
self.assertEqual(len(history), release.HISTORY_LIMIT)
self.assertEqual(history[0]["sequence"], release.HISTORY_LIMIT + 2)
def test_a_web_variant_must_sign_this_release_and_its_module(self):
value, data = self.release(1, signature=self.revision(28))
module = b"\0asm\x01\0\0\0photos-1"
encoded = json.dumps(value).encode()
payload = value["artifacts"][0]["sha256"] + ".zx"
entries = {"inbe.photos/latest-v2.json": encoded, f"inbe.photos/{payload}": data,
f"inbe.photos/{payload}.release-v2.json": encoded, "inbe.photos/release-1.json": encoded}
other, _ = self.release(1, signature=self.revision(28), host_api=3)
damaged = self.wasm_entries(value, module)
name = next(name for name in damaged if name.endswith(".wasm"))
damaged[name] = b"\0asm\x01\0\0\0photos-X"
for variant in (self.wasm_entries(value, module, key=Ed25519PrivateKey.generate()),
self.wasm_entries(other, module), damaged,
self.wasm_entries(value, b"ZX\0\0not webassembly")):
with self.subTest(variant=sorted(variant)), self.assertRaises(ValueError):
release.import_node_app(entries | variant, self.directory / "refused", self.publishers,
"inbe.photos")
self.assertFalse((self.directory / "refused").exists())
# A variant without its release's .zx has nothing it was lowered from.
legacy, legacy_data = self.release(2, signature=b"ZIB\0")
with self.assertRaises(ValueError):
self.publish(legacy, legacy_data, wasm=module)
self.publish(value, data, wasm=module)
# A sequence keeps the one variant it was published with.
with self.assertRaisesRegex(ValueError, "another WebAssembly variant"):
self.publish(value, data, wasm=module + b"!")
self.publish(value, data, wasm=module)
def test_payload_must_match_its_name(self):
value, data = self.release(1)
with self.assertRaises(ValueError):
self.publish(value, data, ".zib")
legacy, legacy_data = self.release(2, signature=b"ZIB\0")
with self.assertRaises(ValueError):
self.publish(legacy, legacy_data, ".zx")
unknown, unknown_data = self.release(3, signature=b"ZIR\0")
with self.assertRaises(ValueError):
self.publish(unknown, unknown_data, ".zx")
def test_only_registered_apps_with_a_newer_release_are_published(self):
ledger = self.directory / "versions.json"
ledger.write_text(json.dumps(dict(host_api=2, module_api=2, node_apps=dict(
photos=dict(id="inbe.photos", title="Photos", version="1.0.2", sequence=2, beta=True),
chess=dict(id="inbe.chess", title="Chess", version="1.0.1", sequence=2),
radio=dict(id="inbe.radio", title="Radio", version="1.0.0", sequence=1)))))
served = {"inbe.photos": self.release(1)[0], "inbe.chess": dict(self.release(2)[0], app_id="inbe.chess")}
def open_url(url, timeout):
if url == "https://node.example/api/v1/apps":
return BytesIO(json.dumps(dict(apps=[dict(app_id="inbe.photos", status="active"),
dict(app_id="inbe.chess", status="active"),
dict(app_id="inbe.radio", status="suspended")])).encode())
app_id = url.split("/api/v2/packages/")[1].split("/")[0]
# Today's node serves these apps only as legacy .zib releases.
if url.endswith("/latest?bucket=0&format=zx"):
raise HTTPError(url, 404, "Not Found", {}, None)
self.assertTrue(url.endswith("/latest?bucket=0"))
return BytesIO(json.dumps(served[app_id]).encode())
published = []
with patch.object(release, "stage_node_app") as stage, \
patch.object(release, "publish_node_app", side_effect=lambda store, name, *_: published.append(name)), \
patch.object(release, "verify_node_app"):
release.publish_node_apps(self.store, Path("publisher.pem"), "test", "[email protected]",
"/srv/packages", "https://node.example/", self.directory / "publishers.json",
ledger_path=ledger, bundle_directory=self.directory / "node-apps",
open_url=open_url)
self.assertEqual(published, ["photos"])
self.assertEqual(stage.call_args.args[1], "photos")
def test_the_ledger_zx_revision_must_match_each_payload(self):
bundles = self.directory / "node-apps"
bundles.mkdir()
ledger = self.directory / "versions.json"
entry = dict(id="inbe.photos", title="Photos", version="1.0.1", sequence=1)
for revision, ledger_value, component_value, accepted in (
(28, 28, None, True), (26, 28, None, False), (28, None, None, True),
(26, 28, 26, True), (28, 28, 26, False), (28, "28", None, False), (28, 0, None, False)):
(bundles / "photos.zx").write_bytes(self.revision(revision) + b"photos")
versions = dict(host_api=44, module_api=2, node_apps=dict(photos=dict(entry)))
if ledger_value is not None:
versions["zx_revision"] = ledger_value
if component_value is not None:
versions["node_apps"]["photos"]["zx_revision"] = component_value
ledger.write_text(json.dumps(versions))
with self.subTest(revision=revision, ledger=ledger_value, component=component_value):
if accepted:
release.node_app_release("photos", self.key, "test", ledger_path=ledger, bundle_directory=bundles)
else:
with self.assertRaises(ValueError):
release.node_app_release("photos", self.key, "test", ledger_path=ledger,
bundle_directory=bundles)
def test_a_release_publishes_its_signed_webassembly_variant(self):
import tarfile
bundles = self.directory / "build"
bundles.mkdir()
(bundles / "photos.zx").write_bytes(self.revision(28) + b"photos")
module = b"\0asm\x01\0\0\0photos lowered"
(bundles / "photos.wasm").write_bytes(module)
ledger = self.directory / "versions.json"
ledger.write_text(json.dumps(dict(host_api=44, module_api=2, zx_revision=28, node_apps=dict(
photos=dict(id="inbe.photos", title="Photos", version="1.0.1", sequence=1, beta=True)))))
key_path = self.directory / "key.pem"
key_path.write_bytes(self.key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption()))
publishers_path = self.directory / "publishers.json"
publishers_path.write_text(json.dumps(self.publishers))
staged = self.directory / "staged"
value = release.stage_node_app(staged, "photos", key_path, "test", publishers_path,
ledger_path=ledger, bundle_directory=bundles)
uploaded = {}
def upload(archive, target, remote_store):
with tarfile.open(archive) as tar:
uploaded.update({member.name: tar.extractfile(member).read() for member in tar.getmembers()})
with patch.object(release, "upload", upload):
release.publish_node_app(staged, "photos", "node", "/store")
self.assertEqual(len(uploaded), 7)
release.import_node_app(uploaded, self.store, self.publishers, "inbe.photos")
node = self.store / "inbe.photos"
variant = json.loads((node / "release-1.wasm.json").read_bytes())
release.validate_release(variant, "inbe.photos", self.publishers)
self.assertTrue(release.same_release(variant, value))
self.assertEqual(variant["channel"], "beta")
self.assertEqual(variant["artifacts"][0], dict(variant="module", sha256=sha256(module).hexdigest(),
size=len(module)))
self.assertEqual((node / (variant["artifacts"][0]["sha256"] + ".wasm")).read_bytes(), module)
# The release and its history still name the .zx; web hosts ask for the variant.
self.assertEqual(json.loads((node / "latest-v2.json").read_bytes()), value)
self.assertEqual([entry["artifacts"] for entry in self.history()], [value["artifacts"]])
def open_url(url, timeout):
name = url.rsplit("/", 1)[1]
if name.startswith("latest"):
name = "release-1.wasm.json" if name.endswith("format=wasm") else "latest-v2.json"
return BytesIO((node / name).read_bytes())
release.verify_node_app(staged, "photos", "https://node.test", open_url)
(node / (variant["artifacts"][0]["sha256"] + ".wasm")).write_bytes(module[:-1] + b"!")
with self.assertRaises(ValueError):
release.verify_node_app(staged, "photos", "https://node.test", open_url)
# A file that is not a WebAssembly module never signs.
(bundles / "photos.wasm").write_bytes(b"ZX\0\0photos")
with self.assertRaises(ValueError):
release.stage_node_app(self.directory / "other", "photos", key_path, "test", publishers_path,
ledger_path=ledger, bundle_directory=bundles)
def test_ledger_beta_apps_are_signed_for_the_beta_channel(self):
bundles = self.directory / "node-apps"
bundles.mkdir()
(bundles / "photos.zx").write_bytes(b"ZX\0\0photos")
ledger = self.directory / "versions.json"
ledger.write_text(json.dumps(dict(host_api=2, module_api=2, node_apps=dict(
photos=dict(id="inbe.photos", title="Photos", version="1.0.1", sequence=1, beta=True)))))
value, _ = release.node_app_release("photos", self.key, "test", ledger_path=ledger,
bundle_directory=bundles)
self.assertEqual(value["channel"], "beta")
release.validate_release(value, "inbe.photos", self.publishers)
def test_a_collection_publishes_its_games_to_download_one_by_one(self):
import tarfile
bundles = self.directory / "build"
(bundles / "arcade.games").mkdir(parents=True)
(bundles / "arcade.zx").write_bytes(b"ZX\0\0arcade")
games = [b"ZX\0\0shovey", b"ZX\0\0editor"]
for game in games:
(bundles / "arcade.games" / (sha256(game).hexdigest() + ".zx")).write_bytes(game)
ledger = self.directory / "versions.json"
ledger.write_text(json.dumps(dict(host_api=31, module_api=2, node_apps=dict(
arcade=dict(id="inbe.arcade", title="Arcade", version="1.0.0", sequence=7)))))
key_path = self.directory / "key.pem"
key_path.write_bytes(self.key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption()))
publishers_path = self.directory / "publishers.json"
publishers_path.write_text(json.dumps(self.publishers))
staged = self.directory / "staged"
value = release.stage_node_app(staged, "arcade", key_path, "test", publishers_path,
ledger_path=ledger, bundle_directory=bundles)
uploaded = {}
def upload(archive, target, remote_store):
with tarfile.open(archive) as tar:
uploaded.update({member.name: tar.extractfile(member).read() for member in tar.getmembers()})
with patch.object(release, "upload", upload):
release.publish_node_app(staged, "arcade", "node", "/store")
self.assertEqual(len(uploaded), 4 + 2 * len(games))
# A game whose bytes the release does not sign never imports.
tampered = dict(uploaded)
tampered[f"inbe.arcade/{sha256(games[0]).hexdigest()}.zx"] = b"ZX\0\0other!"
with self.assertRaises(ValueError):
release.import_node_app(tampered, self.directory / "other", self.publishers, "inbe.arcade")
release.import_node_app(uploaded, self.store, self.publishers, "inbe.arcade")
node = self.store / "inbe.arcade"
for game in games:
digest = sha256(game).hexdigest()
self.assertEqual((node / (digest + ".zx")).read_bytes(), game)
lookup = json.loads((node / (digest + ".zx.release-v2.json")).read_bytes())
self.assertEqual((lookup["sequence"], lookup["artifacts"][0]["sha256"]), (value["sequence"], digest))
# The latest release and the history name only the collection itself.
self.assertEqual(json.loads((node / "latest-v2.json").read_bytes()), value)
versions = json.loads((node / "history-v2.json").read_bytes())["versions"]
self.assertEqual([entry["artifacts"] for entry in versions], [value["artifacts"]])
def open_url(url, timeout):
name = url.rsplit("/", 1)[1]
return BytesIO((node / ("latest-v2.json" if name.startswith("latest") else name)).read_bytes())
release.verify_node_app(staged, "arcade", "https://node.test", open_url)
(node / (sha256(games[1]).hexdigest() + ".zx")).write_bytes(b"ZX\0\0stale!")
with self.assertRaises(ValueError):
release.verify_node_app(staged, "arcade", "https://node.test", open_url)
class ExactNodeAppIdTest(unittest.TestCase):
"""A game publishes under its own exact ID once a publisher pin names it."""
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.directory = Path(self.temporary.name)
self.key = Ed25519PrivateKey.generate()
public = self.key.public_key().public_bytes(serialization.Encoding.Raw,
serialization.PublicFormat.Raw).hex()
self.publishers = [dict(key_id="test", public_key=public, app_ids=[], app_prefixes=["inbe."],
node_app_ids=["xyz.waozi.wurm"])]
self.publishers_path = self.directory / "publishers.json"
self.publishers_path.write_text(json.dumps(self.publishers))
self.key_path = self.directory / "key.pem"
self.key_path.write_bytes(self.key.private_bytes(serialization.Encoding.PEM,
serialization.PrivateFormat.PKCS8,
serialization.NoEncryption()))
self.bundles = self.directory / "build"
self.bundles.mkdir()
for name in ("wurm", "other", "photos"):
(self.bundles / f"{name}.zx").write_bytes(b"ZX\0\0" + name.encode())
self.ledger = self.directory / "versions.json"
self.ledger.write_text(json.dumps(dict(host_api=31, module_api=2, node_apps=dict(
wurm=dict(id="xyz.waozi.wurm", title="Wurm", version="0.2.28", sequence=28),
other=dict(id="xyz.waozi.other", title="Other", version="1.0.0", sequence=1),
photos=dict(id="inbe.photos", title="Photos", version="1.0.1", sequence=1)))))
self.staged = self.directory / "staged"
self.node = self.directory / "node"
def stage(self, name, publishers_path=None):
return release.stage_node_app(self.staged, name, self.key_path, "test",
publishers_path or self.publishers_path,
ledger_path=self.ledger, bundle_directory=self.bundles)
def receive(self, archive, target, remote_store):
"""The node's receiver: the archive names one app, imported with the node's pins."""
import tarfile
with tarfile.open(archive) as tar:
entries = {member.name: tar.extractfile(member).read() for member in tar.getmembers()}
(app_id,) = {name.split("/")[0] for name in entries}
release.import_node_app(entries, self.node, self.publishers, app_id)
def open_url(self, url, timeout):
if url == "https://node.test/api/v1/apps":
return BytesIO(json.dumps(dict(apps=[dict(app_id="xyz.waozi.wurm", status="active"),
dict(app_id="xyz.waozi.other", status="active")])).encode())
app_id, name = url.split("/api/v2/packages/")[1].split("/")
path = self.node / app_id / ("latest-v2.json" if name.startswith("latest") else name)
if not path.is_file():
raise HTTPError(url, 404, "Not Found", {}, None)
return BytesIO(path.read_bytes())
def test_a_configured_exact_id_signs_stages_imports_and_verifies(self):
ledger = json.loads(self.ledger.read_text())
del ledger["node_apps"]["other"], ledger["node_apps"]["photos"]
self.ledger.write_text(json.dumps(ledger))
with patch.object(release, "upload", self.receive):
release.publish_node_apps(self.staged, self.key_path, "test", "[email protected]", "/srv/packages",
"https://node.test", self.publishers_path, ledger_path=self.ledger,
bundle_directory=self.bundles, open_url=self.open_url)
staged = json.loads((self.staged / "xyz.waozi.wurm" / "latest-v2.json").read_bytes())
self.assertEqual((staged["app_id"], staged["version"], staged["sequence"]), ("xyz.waozi.wurm", "0.2.28", 28))
release.validate_release(staged, "xyz.waozi.wurm", self.publishers)
served = self.node / "xyz.waozi.wurm"
self.assertEqual(json.loads((served / "latest-v2.json").read_bytes()), staged)
self.assertEqual((served / (staged["artifacts"][0]["sha256"] + ".zx")).read_bytes(), b"ZX\0\0wurm")
self.assertEqual(json.loads((served / "history-v2.json").read_bytes())["versions"], [staged])
release.write_histories(self.node, self.publishers_path)
self.assertEqual(json.loads((served / "history-v2.json").read_bytes())["versions"], [staged])
# Publishing again finds the release served and skips it.
with patch.object(release, "stage_node_app") as stage:
release.publish_node_apps(self.staged, self.key_path, "test", "[email protected]", "/srv/packages",
"https://node.test", self.publishers_path, ledger_path=self.ledger,
bundle_directory=self.bundles, open_url=self.open_url)
stage.assert_not_called()
# Verification reads the node's bytes, so a changed payload fails it.
(served / (staged["artifacts"][0]["sha256"] + ".zx")).write_bytes(b"ZX\0\0wurn")
with self.assertRaises(ValueError):
release.verify_node_app(self.staged, "wurm", "https://node.test", self.open_url, app_id="xyz.waozi.wurm")
def test_an_unconfigured_exact_id_is_refused(self):
self.assertFalse(release.node_app_id("xyz.waozi.other", self.publishers))
self.assertIsNone(release.trusted_pin(self.publishers, "test", "xyz.waozi.other"))
with self.assertRaises(ValueError):
self.stage("other")
self.assertFalse((self.staged / "xyz.waozi.other").exists())
# A release signed for it anyway never imports on the node.
data = b"ZX\0\0other"
value = dict(app_id="xyz.waozi.other", sequence=1, version="1.0.0", runtime="kryon-app-v1", host_api=31,
module_api=2, data_schema=0, key_id="test",
artifacts=[dict(variant="module", sha256=sha256(data).hexdigest(), size=len(data))],
dependencies=[])
value["signature"] = self.key.sign(release.signing_message(value)).hex()
encoded = json.dumps(value).encode()
payload = value["artifacts"][0]["sha256"] + ".zx"
entries = {"xyz.waozi.other/latest-v2.json": encoded, f"xyz.waozi.other/{payload}": data,
f"xyz.waozi.other/{payload}.release-v2.json": encoded,
"xyz.waozi.other/release-1.json": encoded}
with self.assertRaises(ValueError):
release.import_node_app(entries, self.node, self.publishers, "xyz.waozi.other")
self.assertFalse((self.node / "xyz.waozi.other").exists())
# Naming it to the node is not enough: the pin itself must name it.
other_pin = dict(self.publishers[0], key_id="other", node_app_ids=["xyz.waozi.other"])
self.assertIsNone(release.trusted_pin([self.publishers[0], other_pin], "test", "xyz.waozi.other"))
with self.assertRaises(ValueError):
release.import_node_app(entries, self.node, [self.publishers[0], other_pin], "xyz.waozi.other")
def test_exact_ids_stay_outside_inbe_and_match_their_ledger_name(self):
pins = [dict(self.publishers[0], node_app_ids=["inbe", "inbe.habits", "inbe.chess", "wurm", "xyz.wurm",
"xyz.waozi.Wurm", "xyz..wurm", "xyz.waozi.wurm"])]
self.assertEqual([app_id for app_id in pins[0]["node_app_ids"] if release.node_app_id(app_id, pins)],
["inbe.chess", "xyz.waozi.wurm"])
self.assertIsNone(release.trusted_pin([dict(pins[0], app_prefixes=[])], "test", "inbe.chess"))
ledger = json.loads(self.ledger.read_text())
ledger["node_apps"]["chess"] = dict(ledger["node_apps"]["wurm"])
self.ledger.write_text(json.dumps(ledger))
(self.bundles / "chess.zx").write_bytes(b"ZX\0\0chess")
with self.assertRaisesRegex(ValueError, "not an app the node offers"):
self.stage("chess")
def test_inbe_apps_publish_as_before(self):
self.assertTrue(release.node_app_id("inbe.photos"))
self.assertFalse(release.node_app_id("inbe.habits", self.publishers))
self.assertFalse(release.node_app_id("xyz.waozi.wurm"))
legacy = self.directory / "legacy.json"
legacy.write_text(json.dumps([{field: item for field, item in self.publishers[0].items()
if field != "node_app_ids"}]))
value = self.stage("photos", legacy)
self.assertEqual(value["app_id"], "inbe.photos")
self.assertTrue((self.staged / "inbe.photos" / "latest-v2.json").is_file())
with self.assertRaises(ValueError):
self.stage("wurm", legacy)
if __name__ == "__main__":
unittest.main()