#!/usr/bin/env python3 # SPDX-License-Identifier: MIT """Vygeneruje identitu uzlu s NEKOLIZNIM path hashem. Proc to nejde nechat na nahode ------------------------------- Path hash je prosty prefix verejneho klice (`Identity.h:20`) a jeho sirku urcuje ODESILATEL paketu, ne forwarder -- `Mesh.cpp:346` pripoji `packet->getPathHashSize()` bajtu, takze do jednobajtoveho paketu pripise jeden bajt i repeater nastaveny na dva. Kandidatem na hop je proto VZDY cela populace repeateru, ne jen ti nastaveni na tutez sirku. Zmereno na CZ meshi 5. 8. 2026 (669 repeateru): 1 bajt -> 620 repeateru sedi na sdilenem prefixu (253 z 256 hodnot obsazeno) 2 bajty -> 6 (obsazenost 1,25 %) 3 bajty -> 0 Jednobajtova unikatnost je tedy neziskatelna (pigeonhole: 669 > 256), zato dvoubajtova je skoro zadarmo. Kolize neni kosmetika: `isHashMatch` porovna prave tyhle bajty, takze na kolidujici hop reaguje VIC repeateru -- rozbiji to routovani i atribuci v analyzeru. Pouziti ------- tools/gen_node_id.py # 2B prefix volny proti CoreScope tools/gen_node_id.py --bytes 3 # prisnejsi tools/gen_node_id.py --first-byte 5f # k tomu konkretni prvni bajt tools/gen_node_id.py --known klice.txt # offline, misto CoreScope Nahrani do uzlu (klic je 64 B = seed32 || pubkey32, viz PRV_KEY_SIZE v MeshCore.h): meshcore-cli -a set private_key <128 hex znaku> """ import argparse import hashlib import json import os import secrets import sys import urllib.request from cryptography.hazmat.primitives import serialization as ser from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey def keypair(seed: bytes): """Vrati (pub32, prv64) ve formatu, ktery ceka MeshCore. POZOR: prv NENI seed||pub (konvence libsodium), ale **clampnuty SHA-512(seed)** -- viz lib/ed25519/keypair.c: sha512(seed, 32, private_key); private_key[0] &= 248; private_key[31] &= 63; private_key[31] |= 64; ge_scalarmult_base(&A, private_key); `set prv.key` jinak odpovi "Error, bad key", protoze validatePrivateKey() si pubkey odvodi pres ed25519_derive_pub() z prvnich 32 bajtu jako ze skalaru. Pub pocitame pres standardni Ed25519 ze seedu -- RFC 8032 dela presne tohle. """ h = bytearray(hashlib.sha512(seed).digest()) h[0] &= 248 h[31] &= 63 h[31] |= 64 pub = Ed25519PrivateKey.from_private_bytes(seed).public_key().public_bytes( ser.Encoding.Raw, ser.PublicFormat.Raw) return pub, bytes(h) # Verejny komunitni analyzer: vidi cely mesh (50 observeru), ne jen to, co slysi # nase dve. Kolize se musi hledat proti nejuplnejsi populaci, jakou sezeneme. DEFAULT_SRC = "https://analyzer.meshcore.cz/api/analytics/hash-sizes" def load_known(src): """Vrati (vsechny_pubkey, pubkey_repeateru) jako lowercase hex.""" if src.startswith("http"): with urllib.request.urlopen(src, timeout=20) as r: d = json.load(r) # Zdroje se lisi tvarem a API se meni pod rukama (23. 8. 2026 zmizel # "multiByteCapability" z CoreScope): zkus zname obalky, pak fallback # na prvni list dictu v odpovedi. Klic pubkeye taky pluje. nodes = None for k in ("multiByteCapability", "nodes", "data"): if isinstance(d, dict) and isinstance(d.get(k), list): nodes = d[k] break if nodes is None: if isinstance(d, list): nodes = d else: nodes = next((v for v in d.values() if isinstance(v, list)), None) if not nodes: sys.exit(f"zdroj {src} nevratil zadny seznam uzlu") def pk(n): return (n.get("pubkey") or n.get("public_key") or n.get("publicKey") or "").lower() rep_types = {"repeater", 2, "2"} return ([pk(n) for n in nodes if pk(n)], [pk(n) for n in nodes if pk(n) and ( n.get("role") in rep_types or n.get("type") in rep_types or n.get("node_type") in rep_types)]) keys = [ln.strip().lower() for ln in open(src) if ln.strip()] return keys, keys def main(): ap = argparse.ArgumentParser() ap.add_argument("--bytes", type=int, default=2, help="kolik bajtu prefixu musi byt volnych (default 2)") ap.add_argument("--first-byte", metavar="HEX", help="vynutit konkretni prvni bajt, napr. 5f") ap.add_argument("--known", default=DEFAULT_SRC, help="zdroj znamych klicu: URL CoreScope nebo soubor") ap.add_argument("--max-tries", type=int, default=5_000_000) ap.add_argument("--derive", metavar="HEX128", help="jen odvodit pubkey z existujiciho 64B prv.key a skoncit. " "PAST: prv[32:64] NENI pubkey (je to druha pulka SHA-512) " "-- pub = ge_scalarmult_base(prv[0:32]). Chce PyNaCl.") ap.add_argument("--out", metavar="SOUBOR", help="kam zapsat privatni klic (0600). Bez toho se NEVYPISUJE " "-- klic nema co delat v scrollbacku terminalu.") a = ap.parse_args() if a.derive: import nacl.bindings as nb # jen tady, jinak staci `cryptography` prv = bytes.fromhex(a.derive.strip()) if len(prv) != 64: sys.exit(f"prv.key ma mit 64 bajtu (128 hex), ma {len(prv)}") print(nb.crypto_scalarmult_ed25519_base_noclamp(prv[:32]).hex()) return try: allk, repk = load_known(a.known) except Exception as e: sys.exit(f"nelze nacist zname klice z {a.known}: {e}") n = a.bytes * 2 taken_all = {k[:n] for k in allk} bucket1 = {} for k in repk: bucket1[k[:2]] = bucket1.get(k[:2], 0) + 1 print(f"znamych uzlu {len(allk)} (z toho repeateru {len(repk)}); " f"obsazenych {a.bytes}B prefixu: {len(taken_all)}", file=sys.stderr) want = a.first_byte.lower() if a.first_byte else None if want and len(want) != 2: sys.exit("--first-byte chce prave dva hex znaky") if want in ("00", "ff"): sys.exit("00 a ff nejsou volne, ale ZAKAZANE -- Identity.cpp:56 odmita " "klic s pub[0] == 0x00 nebo 0xFF jako neplatny") for i in range(a.max_tries): seed = secrets.token_bytes(32) pub, prv64 = keypair(seed) h = pub.hex() if h[:2] in ("00", "ff"): # firmware by takovy klic odmitl continue if want and h[:2] != want: continue if h[:n] in taken_all: continue crowd = bucket1.get(h[:2], 0) print(f"nalezeno po {i + 1} pokusech", file=sys.stderr) print(f"pub_key {h}") print(f"path hash 1B={h[:2]} 2B={h[:4]} 3B={h[:6]}") print(f"prvni bajt {h[:2]} sdili {crowd} repeateru" + (" <-- unikatni i na 1 bajt!" if crowd == 0 else "")) if a.out: fd = os.open(a.out, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600) with os.fdopen(fd, "w") as f: f.write(prv64.hex() + "\n") print(f"\nprivatni klic zapsan do {a.out} (0600). Nahrani do uzlu:") print(f" repeater po seriove konzoli: set prv.key $(cat {a.out})") print(f" companion pres meshcore-cli: set private_key $(cat {a.out})") else: print("\n(privatni klic se nevypisuje; pouzij --out SOUBOR)") return sys.exit("nenalezeno, zvys --max-tries nebo uvolni podminky") if __name__ == "__main__": main()