Files
meshcore-tth/tools/gen_node_id.py
T

178 lines
7.4 KiB
Python
Executable File

#!/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 <adresa> 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()