vnode 0.1.2__py3-none-any.whl

vnode/__init__.py

@@ -0,0 +1,40 @@
+"""Virtual Meshtastic node package."""
+
+from .config import (
+    BroadcastConfig,
+    ChannelConfig,
+    MeshDbConfig,
+    NodeConfig,
+    PositionConfig,
+    SecurityConfig,
+    UdpConfig,
+)
+from .crypto import (
+    b64_decode,
+    b64_encode,
+    decrypt_dm,
+    derive_public_key,
+    encrypt_dm,
+    generate_keypair,
+)
+from .runtime import VirtualNode, parse_node_id, resolve_hw_model, resolve_role
+
+__all__ = [
+    "BroadcastConfig",
+    "ChannelConfig",
+    "MeshDbConfig",
+    "NodeConfig",
+    "PositionConfig",
+    "SecurityConfig",
+    "UdpConfig",
+    "VirtualNode",
+    "b64_decode",
+    "b64_encode",
+    "decrypt_dm",
+    "derive_public_key",
+    "encrypt_dm",
+    "generate_keypair",
+    "parse_node_id",
+    "resolve_hw_model",
+    "resolve_role",
+]

vnode/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

vnode/cli.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import argparse
+from typing import List, Optional
+
+from .runtime import VirtualNode
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Virtual Meshtastic node")
+    parser.add_argument(
+        "--vnode-file",
+        "--config",
+        dest="vnode_file",
+        default="node.json",
+        help="Path to node.json",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("run", help="Run the virtual node listener and nodeinfo broadcaster")
+
+    send_text = subparsers.add_parser("send-text", help="Send a text message")
+    send_text.add_argument("--to", required=True, help="Destination node id, name, or hex suffix")
+    send_text.add_argument("--message", required=True, help="Text to send")
+    send_text.add_argument(
+        "--pki",
+        choices=("auto", "on", "off"),
+        default="auto",
+        help="PKI mode for direct messages",
+    )
+
+    send_nodeinfo = subparsers.add_parser("send-nodeinfo", help="Broadcast or unicast nodeinfo")
+    send_nodeinfo.add_argument(
+        "--to",
+        default="!ffffffff",
+        help="Destination node id; default is broadcast",
+    )
+
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "run":
+        node = VirtualNode(args.vnode_file)
+        node.run_forever()
+        return 0
+
+    if args.command == "send-text":
+        node = VirtualNode(args.vnode_file)
+        packet_id = node.send_text(args.to, args.message, pki_mode=args.pki)
+        print(packet_id)
+        return 0
+
+    if args.command == "send-nodeinfo":
+        node = VirtualNode(args.vnode_file)
+        packet_id = node.send_nodeinfo(destination=node._resolve_destination(args.to))
+        print(packet_id)
+        return 0
+
+    parser.error(f"Unknown command {args.command}")
+    return 2

vnode/config.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import json
+import secrets
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+
+@dataclass
+class BroadcastConfig:
+    send_startup_nodeinfo: bool = True
+    nodeinfo_interval_seconds: int = 900
+
+
+@dataclass
+class PositionConfig:
+    enabled: bool = False
+    latitude: Optional[float] = None
+    longitude: Optional[float] = None
+    altitude: Optional[int] = None
+    position_interval_seconds: int = 900
+
+
+@dataclass
+class ChannelConfig:
+    name: str = "LongFast"
+    psk: str = "AQ=="
+
+
+@dataclass
+class UdpConfig:
+    mcast_group: str = "224.0.0.69"
+    mcast_port: int = 4403
+
+
+@dataclass
+class MeshDbConfig:
+    path: str = "./data"
+
+
+@dataclass
+class SecurityConfig:
+    public_key: str = ""
+    private_key: str = ""
+
+
+@dataclass
+class NodeConfig:
+    node_id: str = ""
+    long_name: str = "Virtual Meshtastic Node"
+    short_name: str = "VND"
+    hw_model: Union[str, int] = "ANDROID_SIM"
+    role: Union[str, int] = "CLIENT"
+    is_licensed: bool = False
+    hop_limit: int = 3
+    broadcasts: BroadcastConfig = field(default_factory=BroadcastConfig)
+    position: PositionConfig = field(default_factory=PositionConfig)
+    channel: ChannelConfig = field(default_factory=ChannelConfig)
+    udp: UdpConfig = field(default_factory=UdpConfig)
+    meshdb: MeshDbConfig = field(default_factory=MeshDbConfig)
+    security: SecurityConfig = field(default_factory=SecurityConfig)
+
+    @classmethod
+    def load(cls, path: Union[str, Path]) -> "NodeConfig":
+        config_path = Path(path)
+        cls.ensure_exists(config_path)
+        payload = json.loads(config_path.read_text(encoding="utf-8"))
+        changed = cls._populate_generated_defaults(payload)
+        if changed:
+            config_path.write_text(
+                json.dumps(payload, indent=2, sort_keys=False) + "\n",
+                encoding="utf-8",
+            )
+        security_payload = dict(payload.get("security", {}))
+        security_payload.pop("enabled", None)
+        return cls(
+            node_id=str(payload.get("node_id", cls.node_id)),
+            long_name=str(payload.get("long_name", cls.long_name)),
+            short_name=str(payload.get("short_name", cls.short_name)),
+            hw_model=payload.get("hw_model", cls.hw_model),
+            role=payload.get("role", cls.role),
+            is_licensed=bool(payload.get("is_licensed", cls.is_licensed)),
+            hop_limit=int(payload.get("hop_limit", cls.hop_limit)),
+            broadcasts=BroadcastConfig(**payload.get("broadcasts", {})),
+            position=PositionConfig(**payload.get("position", {})),
+            channel=ChannelConfig(**payload.get("channel", {})),
+            udp=UdpConfig(**payload.get("udp", {})),
+            meshdb=MeshDbConfig(**payload.get("meshdb", {})),
+            security=SecurityConfig(**security_payload),
+        )
+
+    @staticmethod
+    def _example_config_candidates(config_path: Path) -> List[Path]:
+        package_root = Path(__file__).resolve().parent
+        repo_root = Path(__file__).resolve().parents[2]
+        return [
+            config_path.with_name("example-node.json"),
+            package_root / "example-node.json",
+            repo_root / "example-node.json",
+        ]
+
+    @classmethod
+    def ensure_exists(cls, path: Union[str, Path]) -> None:
+        config_path = Path(path)
+        if config_path.exists():
+            return
+
+        template_path = next(
+            (candidate for candidate in cls._example_config_candidates(config_path) if candidate.exists()),
+            None,
+        )
+        if template_path is None:
+            raise FileNotFoundError(
+                f"Missing config {config_path} and could not find example-node.json to copy from"
+            )
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.loads(template_path.read_text(encoding="utf-8"))
+        cls._populate_generated_defaults(payload)
+        security = payload.setdefault("security", {})
+        security.pop("public_key", None)
+        if not str(security.get("private_key", "")).strip():
+            from .crypto import b64_encode, generate_keypair
+
+            _public_key, private_key = generate_keypair()
+            security["private_key"] = b64_encode(private_key)
+
+        config_path.write_text(
+            json.dumps(payload, indent=2, sort_keys=False) + "\n",
+            encoding="utf-8",
+        )
+
+    @staticmethod
+    def _generate_node_id() -> str:
+        while True:
+            value = secrets.randbits(32)
+            if value not in (0, 0xFFFFFFFF):
+                return f"!{value:08x}"
+
+    @classmethod
+    def _populate_generated_defaults(cls, payload: Dict[str, Any]) -> bool:
+        changed = False
+        if not str(payload.get("node_id", "")).strip():
+            payload["node_id"] = cls._generate_node_id()
+            changed = True
+        return changed
+
+    def save(self, path: Union[str, Path]) -> None:
+        config_path = Path(path)
+        config_path.write_text(
+            json.dumps(self.to_dict(), indent=2, sort_keys=False) + "\n",
+            encoding="utf-8",
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        security = data.get("security")
+        if isinstance(security, dict):
+            security.pop("public_key", None)
+        return data

vnode/crypto.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import base64
+import secrets
+from dataclasses import dataclass
+from hashlib import sha256
+from typing import Optional, Tuple
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.x25519 import (
+    X25519PrivateKey,
+    X25519PublicKey,
+)
+from cryptography.hazmat.primitives.ciphers.aead import AESCCM
+
+
+def b64_encode(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii")
+
+
+def b64_decode(text: str) -> bytes:
+    return base64.b64decode(text.encode("ascii"))
+
+
+def generate_keypair() -> Tuple[bytes, bytes]:
+    private_key = X25519PrivateKey.generate()
+    public_key = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw,
+    )
+    private_bytes = private_key.private_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PrivateFormat.Raw,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    return public_key, private_bytes
+
+
+def derive_public_key(private_key: bytes) -> bytes:
+    return X25519PrivateKey.from_private_bytes(private_key).public_key().public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw,
+    )
+
+
+def build_nonce(packet_id: int, from_node: int, extra_nonce: int) -> bytes:
+    nonce = bytearray(16)
+    nonce[0:8] = int(packet_id).to_bytes(8, "little", signed=False)
+    nonce[8:12] = int(from_node).to_bytes(4, "little", signed=False)
+    if extra_nonce:
+        nonce[4:8] = int(extra_nonce).to_bytes(4, "little", signed=False)
+    return bytes(nonce[:13])
+
+
+def build_shared_key(private_key: bytes, public_key: bytes) -> bytes:
+    shared = X25519PrivateKey.from_private_bytes(private_key).exchange(
+        X25519PublicKey.from_public_bytes(public_key)
+    )
+    return sha256(shared).digest()
+
+
+@dataclass(frozen=True)
+class PkiEnvelope:
+    ciphertext: bytes
+    tag: bytes
+    extra_nonce: int
+
+    def pack(self) -> bytes:
+        return self.ciphertext + self.tag + self.extra_nonce.to_bytes(4, "little", signed=False)
+
+
+def encrypt_dm(
+    *,
+    sender_private_key: bytes,
+    receiver_public_key: bytes,
+    packet_id: int,
+    from_node: int,
+    plaintext: bytes,
+    extra_nonce: Optional[int] = None,
+) -> bytes:
+    nonce_value = secrets.randbits(32) if extra_nonce is None else int(extra_nonce) & 0xFFFFFFFF
+    key = build_shared_key(sender_private_key, receiver_public_key)
+    nonce = build_nonce(packet_id, from_node, nonce_value)
+    encrypted = AESCCM(key, tag_length=8).encrypt(nonce, plaintext, None)
+    return PkiEnvelope(encrypted[:-8], encrypted[-8:], nonce_value).pack()
+
+
+def decrypt_dm(
+    *,
+    receiver_private_key: bytes,
+    sender_public_key: bytes,
+    packet_id: int,
+    from_node: int,
+    payload: bytes,
+) -> bytes:
+    if len(payload) < 12:
+        raise ValueError("PKI payload too short")
+    ciphertext = payload[:-12]
+    tag = payload[-12:-4]
+    extra_nonce = int.from_bytes(payload[-4:], "little", signed=False)
+    key = build_shared_key(receiver_private_key, sender_public_key)
+    nonce = build_nonce(packet_id, from_node, extra_nonce)
+    return AESCCM(key, tag_length=8).decrypt(nonce, ciphertext + tag, None)

vnode/example-node.json

@@ -0,0 +1,34 @@
+{
+  "node_id": "",
+  "long_name": "Virtual Meshtastic Node",
+  "short_name": "VND",
+  "hw_model": "ANDROID_SIM",
+  "role": "CLIENT",
+  "is_licensed": false,
+  "hop_limit": 3,
+  "broadcasts": {
+    "send_startup_nodeinfo": true,
+    "nodeinfo_interval_seconds": 900
+  },
+  "position": {
+    "enabled": false,
+    "latitude": null,
+    "longitude": null,
+    "altitude": null,
+    "position_interval_seconds": 900
+  },
+  "channel": {
+    "name": "LongFast",
+    "psk": "AQ=="
+  },
+  "udp": {
+    "mcast_group": "224.0.0.69",
+    "mcast_port": 4403
+  },
+  "meshdb": {
+    "path": "./data"
+  },
+  "security": {
+    "private_key": ""
+  }
+}