#!/usr/bin/env python3 """ Tests for motalib - run with the meshcore venv: ./meshcore/bin/python tools/mota/test_mota.py (Also pytest-compatible: functions are named test_*.) """ from __future__ import annotations import io import importlib.util import os import random import struct from pathlib import Path import motalib as ml from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey def _fw(seed, size): random.seed(seed) return bytes(random.getrandbits(8) for _ in range(size)) # --- multihash / version --------------------------------------------------- def test_version_pack_roundtrip(): assert ml.pack_version("1.16.0") == (1 << 24) | (16 << 16) assert ml.unpack_version(ml.pack_version("1.16.0.2")) == "1.16.0.2" assert ml.pack_version(0x01100000) == 0x01100000 def test_target_id_for_env(): import hashlib env = "RAK_4631_companion_radio_usb" expect = int.from_bytes(hashlib.sha256(env.encode()).digest()[:4], "little") assert ml.target_id_for_env(env) == expect # distinct envs (same board, different role) get distinct ids assert ml.target_id_for_env("RAK_4631_repeater") != ml.target_id_for_env("RAK_4631_companion_radio_usb") def test_internal_bootloader_target_wiring_is_central_and_not_duplicated(): root = Path(__file__).resolve().parents[2] inventory = [ line.strip() for line in (root / "tools/mota/nrf52_internal_bootloader_targets.txt") .read_text(encoding="utf-8").splitlines() if line.strip() and not line.lstrip().startswith("#") ] assert len(inventory) == len(set(inventory)) assert len(inventory) == 21 target_header = (root / "src/helpers/ota/OtaTargets.h").read_text(encoding="utf-8") for target in inventory: assert f'"{target}"' in target_header pio = (root / "platformio.ini").read_text(encoding="utf-8") nrf52_base = pio.split("[nrf52_base]", 1)[1].split("\n[", 1)[0] assert nrf52_base.count("pre:scripts/nrf52_internal_bootloader_link.py") == 1 build = (root / "build.sh").read_text(encoding="utf-8") recipe = build.split("apply_nrf52_lora_ota_build_recipe()", 1)[1] recipe = recipe.split("supports_nrf52_internal_bootloader_update()", 1)[0] assert "scripts/nrf52_internal_bootloader_link.py" not in recipe assert "export MESHCORE_NRF52_INTERNAL_BOOTLOADER_UPDATE=1" in recipe def test_full_esp32_profile_unifies_usb_logging_and_wifi_mqtt(): root = Path(__file__).resolve().parents[2] build = (root / "build.sh").read_text(encoding="utf-8") profile = build.split("run_full_esp32_profile()", 1)[1] profile = profile.split("run_full_esp32_build_targets()", 1)[0] assert 'PACKET_LOGGING_OVERRIDE="on"' in profile assert 'MQTT_BRIDGE_OVERRIDE="on"' in profile assert 'MESHDEBUG_OVERRIDE="off"' in profile assert 'FIRMWARE_FILENAME_INFIX="full-usb-wifi"' in profile assert "do not also build its former non-MQTT FULL-logging twin" in profile mqtt_gate = build.split("disable_usb_logging_for_mqtt()", 1)[1] mqtt_gate = mqtt_gate.split("is_esp32_usb_wifi_companion_ota_build()", 1)[0] assert 'is_companion_radio_full_target "$env_name"' in mqtt_gate assert 'PACKET_LOGGING_OVERRIDE,,}" = "on"' in mqtt_gate assert '! is_esp32_companion_build "$env_name"' in mqtt_gate matrix = build.split("run_logging_matrix_build_targets()", 1)[1] matrix = matrix.split("run_build_targets()", 1)[0] assert 'is_companion_radio_full_target "$target"' in matrix assert "nRF52 Full already provides logging on its second USB port" in matrix def test_canonical_bulk_matrix_omits_runtime_and_transport_aliases(): root = Path(__file__).resolve().parents[2] build = (root / "build.sh").read_text(encoding="utf-8") resolver = build.split("resolve_all_firmwares()", 1)[1] resolver = resolver.split("is_legacy_companion_power_saving_target()", 1)[0] assert 'is_redundant_bulk_build_target "$env_name"' in resolver runtime = build.split("is_runtime_setting_alias_target()", 1)[1] runtime = runtime.split("is_redundant_bulk_build_target()", 1)[0] assert "is_legacy_companion_power_saving_target" in runtime assert "is_legacy_companion_femoff_target" in runtime assert "is_legacy_radio_gain_profile_target" in runtime assert "is_exact_companion_recipe_alias_target" in runtime redundant = build.split("is_redundant_bulk_build_target()", 1)[1] redundant = redundant.split("resolve_logging_matrix_firmwares()", 1)[0] assert "is_runtime_setting_alias_target" in redundant assert "is_nrf52_companion_transport_replaced_by_full" in redundant logging_matrix = build.split("resolve_logging_matrix_firmwares()", 1)[1] logging_matrix = logging_matrix.split("resolve_companion_firmwares()", 1)[0] assert "resolve_all_firmwares" in logging_matrix assert "print_nrf52_usb_logging_source_targets" not in build full = build.split("apply_companion_radio_full_profile()", 1)[1] full = full.split("get_firmware_filename()", 1)[0] assert "-DOTA_SEEDER_ONLY=1" in full assert "-DMOTA_TARGET_ID=0" in full assert "-UOTA_FLASH_STORE" in full assert "-UOTA_SD_STORE" in full assert "-DCFG_TUD_CDC=2" in full assert "-DMESH_DUAL_CDC_LOGGING=1" in full assert "-DMESH_DEBUG=1" in full assert "-DMESH_PACKET_LOGGING=1" in full usb_logging = (root / "src/helpers/UsbLogging.cpp").read_text( encoding="utf-8" ) assert "Adafruit_USBD_CDC dedicated_usb_logging_port" in usb_logging assert "TinyUSBDevice.detach()" in usb_logging assert "return dedicated_usb_logging_port" in usb_logging def test_release_catalog_resolves_canonical_runtime_aliases(): root = Path(__file__).resolve().parents[2] provider_path = root / "mesh-america/update-provider-release.py" spec = importlib.util.spec_from_file_location( "meshcore_provider_release_test", provider_path ) assert spec is not None and spec.loader is not None provider = importlib.util.module_from_spec(spec) spec.loader.exec_module(provider) release_files = { "RAK_4631_companion_radio_full": [Path("rak-full.zip")], "Heltec_t096_companion_radio_ble_femon": [Path("t096.zip")], "heltec_v4_companion_radio_ble": [Path("v4.bin")], "Station_G2_repeater_observer_mqtt-full-usb-wifi-ota": [ Path("g2.bin") ], } assert provider.resolve_release_identity( "RAK_4631_companion_radio_usb", release_files ) == ("RAK_4631_companion_radio_full", False) assert provider.resolve_release_identity( "RAK_4631_companion_radio_usb-logging", release_files ) == ("RAK_4631_companion_radio_full", False) assert provider.resolve_release_identity( "Heltec_t096_companion_radio_ble_ps_femoff", release_files ) == ("Heltec_t096_companion_radio_ble_femon", False) assert provider.resolve_release_identity( "heltec_v4_3_companion_radio_ble_femoff", release_files ) == ("heltec_v4_companion_radio_ble", False) assert provider.resolve_release_identity( "Station_G2_logging_repeater-logging", release_files ) == ("Station_G2_repeater_observer_mqtt-full-usb-wifi-ota", True) # ESP32 transport-specific artifacts remain preferred when they exist. release_files["Station_G2_companion_radio_usb"] = [Path("g2-usb.bin")] release_files["Station_G2_companion_radio_full"] = [Path("g2-full.bin")] assert provider.resolve_release_identity( "Station_G2_companion_radio_usb", release_files ) == ("Station_G2_companion_radio_usb", False) dual_notes = provider.normalize_nrf52_full_companion_metadata( {"title": "Companion USB", "subTitle": "USB logging"}, "PROFILE - old profile\n\nLOGGING USE - old use\n\nSELECTION - USB.", ) assert "interface 00" in dual_notes assert "interface 02" in dual_notes assert "Input received on interface 02 is ignored" in dual_notes legacy = { "role": "companionBle", "title": "Companion BLE", "subTitle": "FEM off", "version": { "old": { "notes": "old", "files": [{"name": "Board_companion_radio_ble-v1.2.3.zip"}], } }, } canonical = { "role": "companionBle", "title": "Companion BLE", "version": { "new": { "notes": "new", "files": [{"name": "Board_companion_radio_ble-v1.2.3.zip"}], } }, } catalog = {"device": [{"firmware": [legacy, canonical]}]} assert provider.deduplicate_resolved_firmware( catalog, {id(legacy): 8, id(canonical): 0} ) == 1 assert catalog["device"][0]["firmware"] == [canonical] def test_ota_target_generation_honors_explicit_disable(): from gen_targets import ota_envs, release_aliases cfg = [ ["env:enabled", [["build_flags", ["-D ENABLE_OTA=1"]]]], ["env:disabled", [["build_flags", ["-D ENABLE_OTA=1", "-D DISABLE_LORA_OTA=1"]]]], ["env:unrelated", [["build_flags", ["-D NRF52_PLATFORM"]]]], ] assert ota_envs(cfg) == ["enabled"] assert "RAK_3401_repeater_lora_ota_no_external_sensors" in release_aliases() def test_rak_nrf52_ota_profiles_keep_gps_where_uart_is_available(): root = Path(__file__).resolve().parents[2] def env_section(path, name): text = path.read_text(encoding="utf-8") return text.split(f"[env:{name}]", 1)[1].split("\n[", 1)[0] rak4631_path = root / "variants/rak4631/platformio.ini" gps_profiles = ( env_section(rak4631_path, "RAK_4631_repeater_lora_ota_no_external_sensors"), env_section( rak4631_path, "RAK_4631_repeater_bridge_rs232_serial2_lora_ota_no_external_sensors", ), env_section( root / "variants/rak3401/platformio.ini", "RAK_3401_repeater_lora_ota_no_external_sensors", ), ) for profile in gps_profiles: assert "${nrf52_no_external_sensors_keep_gps.build_flags}" in profile assert "${nrf52_no_external_sensors_keep_gps.lib_deps}" in profile assert "SparkFun u-blox GNSS Arduino Library" in profile serial1_bridge = env_section( rak4631_path, "RAK_4631_repeater_bridge_rs232_serial1_lora_ota_no_external_sensors", ) assert "${nrf52_no_external_sensors.build_flags}" in serial1_bridge assert "WITH_RS232_BRIDGE=Serial1" in serial1_bridge def test_hardware_id_for_env(): assert ml.hardware_id_for_env("RAK_4631_repeater") == "RAK4631" assert ml.hardware_id_for_env("RAK_4631_companion_radio_usb") == "RAK4631" assert ( ml.hardware_id_for_env("RAK_4631_repeater_rak15001_slot_c_lora_ota") == "RAK4631_RAK15001_C" ) assert ( ml.hardware_id_for_env("RAK_3401_repeater_rak15001_slot_c_lora_ota") == "RAK_3401" ) assert ( ml.hardware_id_for_env("Heltec_t114_without_display_repeater") == "Heltec_t114" ) assert ml.hardware_id_for_env("ThinkNode_M2_Repeater_bridge_espnow") == "ThinkNode_M2" assert ml.hardware_id_for_env("wio-e5-repeater_bridge_rs232") == "wio-e5" long_env = "ikoka_handheld_nrf_e22_30dbm_096_rotated_room_server" tag = ml.hardware_id_for_env(long_env) assert len(tag) <= 32 and tag.startswith("ikoka_handheld_nrf_e22") assert tag == ml.hardware_id_for_env(long_env.replace("room_server", "companion_radio_usb")) assert tag != ml.hardware_id_for_env("ikoka_handheld_nrf_e22_22dbm_096_rotated_room_server") # --- EndF ------------------------------------------------------------------ def test_endf_roundtrip_and_idempotent(): body = _fw(1, 5000) img, h8 = ml.ensure_endf(body) assert len(img) == 5000 + ml.ENDF_LEN assert ml.has_endf(img) pbody, ph8 = ml.parse_endf(img) assert pbody == body and ph8 == h8 == ml.mh8(body) # idempotent: feeding an already-EndF'd image returns it unchanged img2, h82 = ml.ensure_endf(img) assert img2 == img and h82 == h8 def test_endf_rejects_garbage_tail(): assert not ml.has_endf(b"too short") body = _fw(2, 1000) img = body + ml.ENDF_MAGIC + struct.pack(" zero-filled (still fixed size, still self-consistent) z, _ = ml.ensure_endf(body) assert len(z) == len(body) + ml.ENDF_LEN and ml.parse_endf_ident(z) == ml.FwIdent(0, 0, "") def test_nrf52_layout_record_roundtrip_and_policy(): assert (ml.nrf52_stage_ceiling_for_layout(ml.NRF52_APP_END, True) == ml.NRF52_EXTRAFS_START) assert ml.nrf52_stage_ceiling_for_layout(ml.NRF52_APP_END, False) == ml.NRF52_APP_END assert (ml.nrf52_stage_ceiling_for_layout(ml.NRF52_EXTRAFS_START, True) == ml.NRF52_EXTRAFS_START) assert (ml.nrf52_stage_ceiling_for_layout(ml.NRF52_EXTRAFS_START, False) == ml.NRF52_APP_END) assert (ml.nrf52_stage_ceiling_for_layout(ml.NRF52_BOOT_SCRATCH_START, False) == ml.NRF52_APP_END) layout = ml.Nrf52Layout(ml.NRF52_APP_BASE_S140_V7, ml.NRF52_EXTRAFS_START, ml.NRF52_APP_END, 0) body = ml.ensure_nrf52_layout(_fw(4, 2048), layout) image, _ = ml.ensure_endf(body, ml.FwIdent(hw_id="Xiao_nrf52")) assert ml.parse_nrf52_layout(image) == layout # Re-running the record step replaces the tail instead of duplicating it. assert ml.ensure_nrf52_layout(body, layout) == body assert ml.parse_nrf52_layout(ml.ensure_endf(_fw(5, 2048))[0]) is None internal = ml.Nrf52Layout( ml.NRF52_APP_BASE_S140_V7, ml.NRF52_EXTRAFS_START, ml.NRF52_EXTRAFS_START, ml.NRF52_LAYOUT_FLAG_INTERNAL_EXTRAFS) internal_image, _ = ml.ensure_endf(ml.ensure_nrf52_layout(_fw(6, 2048), internal)) assert ml.parse_nrf52_layout(internal_image) == internal qspi = ml.Nrf52Layout( ml.NRF52_APP_BASE_S140_V7, ml.NRF52_APP_END, ml.NRF52_APP_END, ml.NRF52_LAYOUT_FLAG_QSPI) qspi_image, _ = ml.ensure_endf(ml.ensure_nrf52_layout(_fw(7, 2048), qspi)) assert ml.parse_nrf52_layout(qspi_image) == qspi assert qspi.qspi_backed and qspi.external_backed and not qspi.sd_backed boot_qspi = ml.Nrf52Layout( ml.NRF52_APP_BASE_S140_V7, ml.NRF52_BOOT_SCRATCH_START, ml.NRF52_APP_END, ml.NRF52_LAYOUT_FLAG_QSPI | ml.NRF52_LAYOUT_FLAG_BOOTLOADER_SCRATCH) boot_qspi_image, _ = ml.ensure_endf(ml.ensure_nrf52_layout(_fw(8, 2048), boot_qspi)) assert ml.parse_nrf52_layout(boot_qspi_image) == boot_qspi assert boot_qspi.bootloader_scratch shared_internal = ml.Nrf52Layout( ml.NRF52_APP_BASE_S140_V6, ml.NRF52_APP_END, ml.NRF52_APP_END, 0) shared_internal_image, _ = ml.ensure_endf( ml.ensure_nrf52_layout(_fw(9, 2048), shared_internal)) assert ml.parse_nrf52_layout(shared_internal_image) == shared_internal assert not shared_internal.bootloader_scratch assert ((ml.NRF52_APP_END - ml.NRF52_BOOT_CONTAINER_SIZE) & ~(ml.NRF52_FLASH_PAGE - 1)) == ml.NRF52_SHARED_BOOT_STAGE_START try: ml.build_nrf52_layout(ml.Nrf52Layout( ml.NRF52_APP_BASE_S140_V7, ml.NRF52_EXTRAFS_START, ml.NRF52_EXTRAFS_START, 0)) assert False, "inconsistent layout record accepted" except ValueError: pass for flags in ( ml.NRF52_LAYOUT_FLAG_SD | ml.NRF52_LAYOUT_FLAG_QSPI, ml.NRF52_LAYOUT_FLAG_QSPI | ml.NRF52_LAYOUT_FLAG_INTERNAL_EXTRAFS, 0x10, ): try: ml.build_nrf52_layout(ml.Nrf52Layout( ml.NRF52_APP_BASE_S140_V7, ml.NRF52_APP_END, ml.NRF52_APP_END, flags)) assert False, "conflicting nRF52 layout flags accepted" except ValueError: pass def _write_boot_continuity(image, offset, *, version=0x0117010D, family=ml.BOOT_CONTINUITY_FAMILY_S140, fwid=None, app_base=ml.NRF52_APP_BASE_S140_V7, layout_abi=ml.BOOT_CONTINUITY_LAYOUT_ABI): if fwid is None: fwid = 0x0123 if app_base == ml.NRF52_APP_BASE_S140_V7 else 0x00B6 struct.pack_into("<8sHHIHHIHHI", image, offset + ml.XIAO_BOOT_MANIFEST_SIZE, ml.BOOT_CONTINUITY_MAGIC, ml.BOOT_CONTINUITY_VERSION, ml.BOOT_CONTINUITY_SIZE, version, family, fwid, app_base, layout_abi, 0, 0) def _xiao_bootloader_image(board_id=ml.XIAO_BOOT_BOARD_ID_BASE, boot_version=0x0117010D): import zlib image = bytearray(b"\xff" * ml.XIAO_BOOT_IMAGE_SIZE) struct.pack_into("> 32) first_error = struct.unpack_from("> output_bit) & 1) rows.append(row | (((affine >> output_bit) & 1) << 64)) pivot_columns = [] pivot_row = 0 for column in range(64): found = next((row for row in range(pivot_row, 64) if (rows[row] >> column) & 1), None) if found is None: continue rows[pivot_row], rows[found] = rows[found], rows[pivot_row] for row in range(64): if row != pivot_row and (rows[row] >> column) & 1: rows[row] ^= rows[pivot_row] pivot_columns.append(column) pivot_row += 1 assert all((row & ((1 << 64) - 1)) or not ((row >> 64) & 1) for row in rows) solution = 0 for row, column in enumerate(pivot_columns): if (rows[row] >> 64) & 1: solution |= 1 << column assert residual(solution) == 0 struct.pack_into("> 32) def test_xiao_bootloader_identity_skips_bad_decoy_and_rejects_two_valid_manifests(): real_offset = ml.BOOT_CANDIDATE_MANIFEST_OFFSET decoy_offset, second_offset = 0x20, 0x200 image = bytearray(_xiao_bootloader_image()) image[decoy_offset:decoy_offset + ml.XIAO_BOOT_MANIFEST_SIZE] = \ image[real_offset:real_offset + ml.XIAO_BOOT_MANIFEST_SIZE] struct.pack_into(" signature must fail (it's in the signed region) bad = bytearray(blob) hw_off = 8 + 57 # MAGIC(4)+total(4) + fixed head up to codec(57) = start of hw_id bad[hw_off] ^= 0xFF assert ml.verify(ml.parse_container(bytes(bad))) != [] def test_tampered_payload_detected(): fw = _fw(11, 10 * 1024) image, _ = ml.ensure_endf(fw) m = ml.build_manifest(target_id=1, fw_version=1, image_size=len(image), payload=image, block_size=1024, image_hash=ml.mh32(image), codec_id=ml.CODEC_FULL, is_full=True) blob = bytearray(ml.build_container(m, image)) # flip a byte inside the payload region payload_off = blob.index(image) blob[payload_off + 50] ^= 0xFF problems = ml.verify(ml.parse_container(bytes(blob))) assert any("leaves" in p or "merkle" in p or "image_hash" in p for p in problems), problems # --- signing --------------------------------------------------------------- def test_signed_build_and_verify(): priv = Ed25519PrivateKey.generate() fw = _fw(12, 20 * 1024) image, _ = ml.ensure_endf(fw) m = ml.build_manifest(target_id=7, fw_version=ml.pack_version("2.0.0"), image_size=len(image), payload=image, block_size=1024, image_hash=ml.mh32(image), codec_id=ml.CODEC_FULL, is_full=True, sign_priv=priv) parsed = ml.parse_container(ml.build_container(m, image)) assert parsed.manifest.is_signed assert ml.verify(parsed, expect_pub=priv.public_key().public_bytes_raw()) == [] # wrong expected key -> flagged other = Ed25519PrivateKey.generate().public_key().public_bytes_raw() assert any("signer_pubkey" in p for p in ml.verify(parsed, expect_pub=other)) def test_tampered_signature_detected(): priv = Ed25519PrivateKey.generate() fw = _fw(13, 8 * 1024) image, _ = ml.ensure_endf(fw) m = ml.build_manifest(target_id=7, fw_version=1, image_size=len(image), payload=image, block_size=1024, image_hash=ml.mh32(image), codec_id=ml.CODEC_FULL, is_full=True, sign_priv=priv) blob = bytearray(ml.build_container(m, image)) # flip a byte of target_id (inside signed region) without re-signing blob[10] ^= 0xFF problems = ml.verify(ml.parse_container(bytes(blob))) assert any("signature INVALID" in p for p in problems), problems # --- approval enforcement -------------------------------------------------- def test_approval_default_and_flagged_if_preapproved(): fw = _fw(14, 4 * 1024) image, _ = ml.ensure_endf(fw) m = ml.build_manifest(target_id=1, fw_version=1, image_size=len(image), payload=image, block_size=1024, image_hash=ml.mh32(image), codec_id=ml.CODEC_FULL, is_full=True) assert m.approval == ml.APPROVAL_NOT # simulate a malicious pre-approved container -> verify must flag it m.approval = ml.APPROVAL_YES parsed = ml.parse_container(ml.build_container(m, image)) assert any("approval" in p for p in ml.verify(parsed)) # --- delta ----------------------------------------------------------------- def test_delta_build_apply_verify(): old_body = _fw(20, 40 * 1024) # new = old with a chunk changed + appended -> a real, small-ish delta new_body = bytearray(old_body) for i in range(1000, 1500): new_body[i] = (new_body[i] + 1) & 0xFF new_body += _fw(21, 2048) old_image, base_hash = ml.ensure_endf(bytes(old_body)) new_image, _ = ml.ensure_endf(bytes(new_body)) import detools fp = io.BytesIO() detools.create_patch(io.BytesIO(old_image), io.BytesIO(new_image), fp, patch_type="sequential", compression="crle") delta = fp.getvalue() # with compression a near-identical-base delta is a fraction of the full image assert len(delta) < len(new_image) // 2, (len(delta), len(new_image)) m = ml.build_manifest(target_id=0xABCD, fw_version=ml.pack_version("1.2.0"), image_size=len(new_image), payload=delta, block_size=1024, image_hash=ml.mh32(new_image), codec_id=ml.CODEC_DETOOLS_SEQUENTIAL, is_full=False, base_hash=base_hash) parsed = ml.parse_container(ml.build_container(m, delta)) assert parsed.manifest.base_hash == base_hash == ml.mh8(bytes(old_body)) # full verify incl. applying the delta to the base and checking image_hash assert ml.verify(parsed, base_image=old_image) == [] # wrong base must fail the delta->image_hash check wrong = ml.verify(parsed, base_image=_fw(99, 40 * 1024)) assert wrong, "delta verify against a wrong base should fail" # --- runner ---------------------------------------------------------------- def _run(): tests = {k: v for k, v in sorted(globals().items()) if k.startswith("test_") and callable(v)} failed = 0 for name, fn in tests.items(): try: fn() print(f"ok {name}") except Exception as e: # noqa: BLE001 failed += 1 import traceback print(f"FAIL {name}: {e}") traceback.print_exc() print(f"\n{len(tests) - failed}/{len(tests)} passed") return 1 if failed else 0 if __name__ == "__main__": raise SystemExit(_run())