You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
178 lines
6.6 KiB
178 lines
6.6 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Tom Hensel <code@jitter.eu> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// MeshCore wire-packet builders. Each function returns a complete OTA packet // |
|
// ready to be handed to the LoRa PHY encoder. // |
|
// // |
|
// Wire envelope (build_wire_packet in gr4-lora/meshcore_tx.py): // |
|
// [header(1)] [opt transport(4)] [path_len(1)] [path(N)] [payload(M)] // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#ifndef MODEMMESHCORE_MESHCORE_BUILDERS_H_ |
|
#define MODEMMESHCORE_MESHCORE_BUILDERS_H_ |
|
|
|
#include <QByteArray> |
|
#include <QString> |
|
|
|
#include <optional> |
|
#include <utility> |
|
|
|
#include "export.h" |
|
|
|
namespace modemmeshcore |
|
{ |
|
namespace builders |
|
{ |
|
|
|
// ---- header byte -------------------------------------------------------------- |
|
|
|
// Build the MeshCore header byte: version[7:6] | payload_type[5:2] | route[1:0] |
|
MODEMMESHCORE_API uint8_t makeHeader(uint8_t routeType, uint8_t payloadType, uint8_t version = 0); |
|
|
|
// ---- wire envelope ------------------------------------------------------------ |
|
|
|
struct WireOptions |
|
{ |
|
QByteArray path; // 0..63*hashSize bytes |
|
int pathHashSize = 1; // 1, 2, or 3 |
|
std::optional<std::pair<uint16_t, uint16_t>> transport; // 4-byte transport block |
|
}; |
|
|
|
// Compose the full OTA packet from header byte + per-payload-type body. |
|
MODEMMESHCORE_API QByteArray buildWirePacket( |
|
uint8_t header, |
|
const QByteArray& payload, |
|
const WireOptions& opts = WireOptions{}); |
|
|
|
// ---- ADVERT ------------------------------------------------------------------- |
|
|
|
struct AdvertOptions |
|
{ |
|
uint8_t nodeType = 0x01; // AdvertNodeChat |
|
QString name; // empty -> no name flag |
|
std::optional<std::pair<double, double>> latLon; // (lat, lon) in degrees |
|
uint32_t timestamp = 0; // 0 -> caller must inject; 0 stays as-is |
|
uint8_t routeType = 0x01; // RouteFlood (default per MeshCore convention) |
|
std::optional<std::pair<uint16_t, uint16_t>> transport; |
|
}; |
|
|
|
// Build a signed ADVERT wire packet from a 32-byte Ed25519 seed. |
|
// |
|
// Body layout: [pubkey(32)][timestamp(4 LE)][signature(64)][app_data] |
|
// app_data = [flags(1)][opt lat(4 LE)+lon(4 LE)][opt name(UTF-8)] |
|
// signature is over: pubkey || timestamp || app_data |
|
// |
|
// Returns the OTA-ready packet, empty on error. |
|
MODEMMESHCORE_API QByteArray buildAdvert( |
|
const QByteArray& seed, |
|
const QByteArray& pubKey, |
|
const AdvertOptions& opts); |
|
|
|
// ---- TXT_MSG (encrypted to a known contact via ECDH) -------------------------- |
|
|
|
enum TxtType : uint8_t |
|
{ |
|
TxtTypePlain = 0x00, |
|
TxtTypeCli = 0x01, |
|
TxtTypeSigned = 0x02, |
|
}; |
|
|
|
struct TxtMsgOptions |
|
{ |
|
uint8_t txtType = TxtTypePlain; // upper 6 bits of txt_type_attempt byte |
|
uint8_t attempt = 0; // lower 2 bits (0..3) |
|
uint32_t timestamp = 0; |
|
uint8_t routeType = 0x02; // RouteDirect default for known contacts |
|
std::optional<std::pair<uint16_t, uint16_t>> transport; |
|
}; |
|
|
|
// Encrypted text message to a known contact identified by destPub32. |
|
// |
|
// Body: [dest_hash(1)] [src_hash(1)] [MAC(2)] [AES-128-ECB ciphertext] |
|
// plaintext: [ts(4 LE)] [txt_type<<2 | attempt(1)] [text bytes] |
|
// |
|
// dest_hash = destPub32[0:1], src_hash = derivePubKey(seed)[0:1]. |
|
MODEMMESHCORE_API QByteArray buildTxtMsg( |
|
const QByteArray& seed, |
|
const QByteArray& destPub32, |
|
const QByteArray& text, |
|
const TxtMsgOptions& opts); |
|
|
|
// ---- ANON_REQ (encrypted with sender pubkey in cleartext) --------------------- |
|
|
|
struct AnonReqOptions |
|
{ |
|
uint32_t timestamp = 0; |
|
uint8_t routeType = 0x02; // RouteDirect default |
|
std::optional<std::pair<uint16_t, uint16_t>> transport; |
|
}; |
|
|
|
// Body: [dest_hash(1)] [sender_pub(32)] [MAC(2)] [AES-128-ECB ciphertext] |
|
// plaintext: [ts(4 LE)] [data] |
|
MODEMMESHCORE_API QByteArray buildAnonReq( |
|
const QByteArray& seed, |
|
const QByteArray& destPub32, |
|
const QByteArray& data, |
|
const AnonReqOptions& opts); |
|
|
|
// ---- GRP_TXT (group channel pre-shared key) ----------------------------------- |
|
|
|
// A MeshCore group channel: 16- or 32-byte PSK identified by a 1-byte hash. |
|
struct MODEMMESHCORE_API GroupChannel |
|
{ |
|
QString name; // human label |
|
QByteArray pskRaw; // 16 or 32 raw bytes |
|
QByteArray secret; // pskRaw zero-padded to 32 bytes (HMAC key) |
|
QByteArray hash; // SHA-256(pskRaw)[0:1] |
|
|
|
static GroupChannel fromPsk(const QString& name, const QByteArray& pskRaw); |
|
bool isValid() const { return !pskRaw.isEmpty() && hash.size() == 1; } |
|
}; |
|
|
|
struct GrpTxtOptions |
|
{ |
|
uint8_t txtType = TxtTypePlain; |
|
uint8_t attempt = 0; |
|
uint32_t timestamp = 0; |
|
uint8_t routeType = 0x01; // RouteFlood default for group channels |
|
std::optional<std::pair<uint16_t, uint16_t>> transport; |
|
}; |
|
|
|
// Body: [channel_hash(1)] [MAC(2)] [AES-128-ECB ciphertext] |
|
// plaintext: [ts(4 LE)] [txt_type<<2 | attempt(1)] [text bytes] |
|
// |
|
// MeshCore firmware convention: text is formatted as "SenderName: message". |
|
MODEMMESHCORE_API QByteArray buildGrpTxt( |
|
const GroupChannel& channel, |
|
const QByteArray& text, |
|
const GrpTxtOptions& opts); |
|
|
|
// ---- ACK (control plaintext, no encryption) ----------------------------------- |
|
|
|
struct AckOptions |
|
{ |
|
uint8_t routeType = 0x02; // RouteDirect default |
|
std::optional<std::pair<uint16_t, uint16_t>> transport; |
|
}; |
|
|
|
// Body: [dest_hash(1)] [msg_hash(4)] |
|
MODEMMESHCORE_API QByteArray buildAck( |
|
const QByteArray& destPub32, |
|
const QByteArray& msgHash4, |
|
const AckOptions& opts); |
|
|
|
// ---- Public-channel helper (fixed PSK convention) ----------------------------- |
|
|
|
// MeshCore firmware fixes the "public" channel PSK at this 16-byte value and |
|
// always seats it at channel index 0 in firmware/companion-app contact lists. |
|
MODEMMESHCORE_API QByteArray publicChannelPsk(); |
|
|
|
} // namespace builders |
|
} // namespace modemmeshcore |
|
|
|
#endif // MODEMMESHCORE_MESHCORE_BUILDERS_H_
|
|
|