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.
564 lines
24 KiB
564 lines
24 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. // |
|
// // |
|
// modemmeshcore smoke test. Exercises the crypto + ADVERT builder round-trip. // |
|
// No QtTest infra yet — this is a standalone executable that aborts on first // |
|
// inconsistency. Run from build dir: ./modemmeshcore/modemmeshcore_smoke // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "meshcorepacket.h" |
|
#include "meshcore_crypto.h" |
|
#include "meshcore_builders.h" |
|
#include "meshcore_command.h" |
|
#include "meshcore_decoder.h" |
|
|
|
#include <QByteArray> |
|
#include <QMap> |
|
|
|
#include <cstdio> |
|
#include <cstdlib> |
|
|
|
namespace |
|
{ |
|
|
|
#define REQUIRE(cond, msg) do { \ |
|
if (!(cond)) { \ |
|
std::fprintf(stderr, "FAIL: %s (line %d): %s\n", msg, __LINE__, #cond); \ |
|
std::abort(); \ |
|
} \ |
|
std::printf(" ok: %s\n", msg); \ |
|
} while (0) |
|
|
|
QByteArray fromHex(const char* hex) { return QByteArray::fromHex(QByteArray(hex)); } |
|
|
|
void testCryptoRoundtrip() |
|
{ |
|
using namespace modemmeshcore; |
|
|
|
// Deterministic 32-byte seed (test vector). |
|
const QByteArray seed = fromHex("0102030405060708090a0b0c0d0e0f10111213141516171819" |
|
"1a1b1c1d1e1f20"); |
|
REQUIRE(seed.size() == kPubKeySize, "seed is 32 bytes"); |
|
|
|
const QByteArray pub32 = detail::derivePubKey(seed); |
|
REQUIRE(pub32.size() == kPubKeySize, "pub32 derived from seed is 32 bytes"); |
|
|
|
// expandedKey(seed) is MeshCore's 64-byte form (clamp(SHA512(seed)[0..32]) || ..). |
|
const QByteArray expanded = detail::expandedKey(seed); |
|
REQUIRE(expanded.size() == kPrvKeySize, "expandedKey is 64 bytes"); |
|
|
|
// ECDH to self: computing shared secret with our own pub key should succeed |
|
// and produce 32 bytes. (Round-trip validation: same secret on both sides.) |
|
const QByteArray sharedSelf = detail::sharedSecret(seed, pub32); |
|
REQUIRE(sharedSelf.size() == kPubKeySize, "ECDH self-shared secret is 32B"); |
|
|
|
// Encrypt-then-MAC round-trip with the self-shared secret. |
|
const QByteArray plaintext = QByteArray("Hello MeshCore!"); |
|
const QByteArray encrypted = detail::encryptThenMac(sharedSelf, plaintext); |
|
REQUIRE(!encrypted.isEmpty(), "encryptThenMac produced output"); |
|
REQUIRE(encrypted.size() >= kCipherMacSize + kCipherBlockSize, |
|
"encryptThenMac output >= 18 bytes"); |
|
|
|
const QByteArray decrypted = detail::macThenDecrypt(sharedSelf, encrypted); |
|
REQUIRE(!decrypted.isEmpty(), "macThenDecrypt validated MAC"); |
|
// decrypted is zero-padded; the prefix must equal the plaintext |
|
REQUIRE(decrypted.startsWith(plaintext), "decrypted starts with plaintext"); |
|
|
|
// MAC tamper: flip one byte in the ciphertext, decrypt should fail |
|
QByteArray tampered = encrypted; |
|
tampered[5] = static_cast<char>(static_cast<uint8_t>(tampered[5]) ^ 0x01); |
|
const QByteArray badDecrypt = detail::macThenDecrypt(sharedSelf, tampered); |
|
REQUIRE(badDecrypt.isEmpty(), "tampered MAC rejected"); |
|
|
|
// Ed25519 sign / verify |
|
const QByteArray msg = QByteArray("MeshCore signing test message"); |
|
const QByteArray sig = detail::signEd25519(seed, msg); |
|
REQUIRE(sig.size() == kSignatureSize, "signature is 64 bytes"); |
|
REQUIRE(detail::verifyEd25519(sig, pub32, msg), "signature verifies under pub32"); |
|
|
|
// Tampered message must fail verification |
|
QByteArray badMsg = msg; |
|
badMsg[0] = static_cast<char>(static_cast<uint8_t>(badMsg[0]) ^ 0x01); |
|
REQUIRE(!detail::verifyEd25519(sig, pub32, badMsg), "tampered msg fails verify"); |
|
} |
|
|
|
void testAdvertBuilder() |
|
{ |
|
using namespace modemmeshcore; |
|
|
|
const QByteArray seed = fromHex("0102030405060708090a0b0c0d0e0f10111213141516171819" |
|
"1a1b1c1d1e1f20"); |
|
const QByteArray pub32 = detail::derivePubKey(seed); |
|
|
|
builders::AdvertOptions opts; |
|
opts.nodeType = AdvertNodeChat; |
|
opts.name = QStringLiteral("SDRangelTest"); |
|
opts.timestamp = 1700000000U; |
|
opts.routeType = RouteFlood; |
|
|
|
const QByteArray packet = builders::buildAdvert(seed, pub32, opts); |
|
REQUIRE(!packet.isEmpty(), "ADVERT packet built"); |
|
|
|
// Minimum size: header(1) + path_len(1) + body(pub32+ts4+sig64+flags1+name) |
|
const int expectedMin = 1 + 1 + kPubKeySize + 4 + kSignatureSize + 1 |
|
+ opts.name.toUtf8().size(); |
|
REQUIRE(packet.size() == expectedMin, "ADVERT exact size matches spec"); |
|
|
|
// Header byte: route=Flood(1), payload=Advert(4), version=0 |
|
const uint8_t header = static_cast<uint8_t>(packet[0]); |
|
REQUIRE((header & kRouteMask) == RouteFlood, "header route = Flood"); |
|
REQUIRE(((header >> kPayloadTypeShift) & kPayloadTypeMask) == PayloadAdvert, |
|
"header payload = Advert"); |
|
|
|
// path_len byte: empty path -> 0 |
|
REQUIRE(static_cast<uint8_t>(packet[1]) == 0, "path_len = 0 (no path)"); |
|
|
|
// pubkey at offset 2 must equal pub32 |
|
REQUIRE(packet.mid(2, kPubKeySize) == pub32, "pubkey at offset 2 matches"); |
|
} |
|
|
|
void testPathLenEncoding() |
|
{ |
|
using namespace modemmeshcore; |
|
|
|
// 1-byte hash mode, 0 hashes -> 0x00 |
|
REQUIRE(encodePathLen(0, 1) == 0x00, "encode(0,1) == 0x00"); |
|
// 1-byte hash mode, 5 hashes -> 0x05 |
|
REQUIRE(encodePathLen(5, 1) == 0x05, "encode(5,1) == 0x05"); |
|
// 2-byte hash mode, 3 hashes -> 0x40 | 3 = 0x43 |
|
REQUIRE(encodePathLen(3, 2) == 0x43, "encode(3,2) == 0x43"); |
|
// 3-byte hash mode, 1 hash -> 0x80 | 1 = 0x81 |
|
REQUIRE(encodePathLen(1, 3) == 0x81, "encode(1,3) == 0x81"); |
|
|
|
// Round-trip |
|
const PathLen p1 = decodePathLen(0x05); |
|
REQUIRE(p1.hashCount == 5 && p1.hashSize == 1 && p1.totalBytes == 5, |
|
"decode(0x05) = {5,1,5}"); |
|
const PathLen p2 = decodePathLen(0x43); |
|
REQUIRE(p2.hashCount == 3 && p2.hashSize == 2 && p2.totalBytes == 6, |
|
"decode(0x43) = {3,2,6}"); |
|
const PathLen p3 = decodePathLen(0x81); |
|
REQUIRE(p3.hashCount == 1 && p3.hashSize == 3 && p3.totalBytes == 3, |
|
"decode(0x81) = {1,3,3}"); |
|
} |
|
|
|
} // namespace |
|
|
|
void testEncryptedBuilders() |
|
{ |
|
using namespace modemmeshcore; |
|
namespace b = modemmeshcore::builders; |
|
|
|
const QByteArray seedA = fromHex("0102030405060708090a0b0c0d0e0f10111213141516171819" |
|
"1a1b1c1d1e1f20"); |
|
const QByteArray seedB = fromHex("a1a2a3a4a5a6a7a8a9aaabacadaeafb0" |
|
"b1b2b3b4b5b6b7b8b9babbbcbdbebfc0"); |
|
const QByteArray pubA = detail::derivePubKey(seedA); |
|
const QByteArray pubB = detail::derivePubKey(seedB); |
|
REQUIRE(pubA.size() == kPubKeySize, "pubA derived"); |
|
REQUIRE(pubB.size() == kPubKeySize, "pubB derived"); |
|
|
|
// ECDH symmetry: shared(A->B) == shared(B->A) |
|
const QByteArray sharedAB = detail::sharedSecret(seedA, pubB); |
|
const QByteArray sharedBA = detail::sharedSecret(seedB, pubA); |
|
REQUIRE(!sharedAB.isEmpty() && sharedAB == sharedBA, "ECDH symmetric"); |
|
|
|
// ---- TXT_MSG: A -> B ---- |
|
{ |
|
b::TxtMsgOptions opts; |
|
opts.timestamp = 1700000001U; |
|
opts.routeType = RouteDirect; |
|
const QByteArray text = QByteArray("Hello from A"); |
|
const QByteArray pkt = b::buildTxtMsg(seedA, pubB, text, opts); |
|
REQUIRE(!pkt.isEmpty(), "TXT_MSG built"); |
|
|
|
// Header byte: route=Direct, payload=Txt |
|
REQUIRE((static_cast<uint8_t>(pkt[0]) & kRouteMask) == RouteDirect, |
|
"TXT_MSG route=Direct"); |
|
REQUIRE(((static_cast<uint8_t>(pkt[0]) >> kPayloadTypeShift) & kPayloadTypeMask) |
|
== PayloadTxt, "TXT_MSG payload=Txt"); |
|
REQUIRE(static_cast<uint8_t>(pkt[1]) == 0, "TXT_MSG path_len=0"); |
|
|
|
// dest_hash and src_hash at offsets 2 and 3 |
|
REQUIRE(static_cast<uint8_t>(pkt[2]) == static_cast<uint8_t>(pubB[0]), |
|
"TXT_MSG dest_hash = pubB[0]"); |
|
REQUIRE(static_cast<uint8_t>(pkt[3]) == static_cast<uint8_t>(pubA[0]), |
|
"TXT_MSG src_hash = pubA[0]"); |
|
|
|
// RX-side: B decrypts using shared secret. |
|
const QByteArray macThenCt = pkt.mid(4); |
|
const QByteArray plaintext = detail::macThenDecrypt(sharedBA, macThenCt); |
|
REQUIRE(!plaintext.isEmpty(), "TXT_MSG decrypts under B's secret"); |
|
// plaintext layout: ts(4) || flags(1) || text || pad |
|
REQUIRE(plaintext.size() >= 5 + text.size(), "TXT_MSG plaintext length OK"); |
|
REQUIRE(plaintext.mid(5, text.size()) == text, |
|
"TXT_MSG plaintext text matches"); |
|
} |
|
|
|
// ---- ANON_REQ: A -> B ---- |
|
{ |
|
b::AnonReqOptions opts; |
|
opts.timestamp = 1700000002U; |
|
const QByteArray data = QByteArray("anon-req payload"); |
|
const QByteArray pkt = b::buildAnonReq(seedA, pubB, data, opts); |
|
REQUIRE(!pkt.isEmpty(), "ANON_REQ built"); |
|
|
|
REQUIRE(((static_cast<uint8_t>(pkt[0]) >> kPayloadTypeShift) & kPayloadTypeMask) |
|
== PayloadAnonReq, "ANON_REQ payload=AnonReq"); |
|
|
|
// dest_hash at 2, sender_pub at 3..3+32 |
|
REQUIRE(static_cast<uint8_t>(pkt[2]) == static_cast<uint8_t>(pubB[0]), |
|
"ANON_REQ dest_hash = pubB[0]"); |
|
REQUIRE(pkt.mid(3, kPubKeySize) == pubA, "ANON_REQ sender_pub at offset 3"); |
|
|
|
// RX-side decrypt |
|
const QByteArray macThenCt = pkt.mid(3 + kPubKeySize); |
|
const QByteArray plaintext = detail::macThenDecrypt(sharedBA, macThenCt); |
|
REQUIRE(!plaintext.isEmpty(), "ANON_REQ decrypts"); |
|
REQUIRE(plaintext.mid(4, data.size()) == data, "ANON_REQ data matches"); |
|
} |
|
|
|
// ---- GRP_TXT: public channel ---- |
|
{ |
|
const QByteArray psk = b::publicChannelPsk(); |
|
REQUIRE(psk.size() == 16, "public PSK is 16 bytes"); |
|
const b::GroupChannel pub = b::GroupChannel::fromPsk("public", psk); |
|
REQUIRE(pub.isValid(), "public channel valid"); |
|
REQUIRE(pub.hash.size() == 1, "channel hash is 1 byte"); |
|
REQUIRE(pub.secret.size() == kPubKeySize, "channel secret zero-padded to 32"); |
|
|
|
b::GrpTxtOptions opts; |
|
opts.timestamp = 1700000003U; |
|
const QByteArray text = QByteArray("Test: public message"); |
|
const QByteArray pkt = b::buildGrpTxt(pub, text, opts); |
|
REQUIRE(!pkt.isEmpty(), "GRP_TXT built"); |
|
|
|
REQUIRE(((static_cast<uint8_t>(pkt[0]) >> kPayloadTypeShift) & kPayloadTypeMask) |
|
== PayloadGrpTxt, "GRP_TXT payload=GrpTxt"); |
|
REQUIRE(static_cast<uint8_t>(pkt[2]) == static_cast<uint8_t>(pub.hash[0]), |
|
"GRP_TXT channel_hash matches"); |
|
|
|
// Decrypt with channel secret |
|
const QByteArray macThenCt = pkt.mid(3); |
|
const QByteArray plaintext = detail::macThenDecrypt(pub.secret, macThenCt); |
|
REQUIRE(!plaintext.isEmpty(), "GRP_TXT decrypts under channel secret"); |
|
REQUIRE(plaintext.mid(5, text.size()) == text, "GRP_TXT text matches"); |
|
} |
|
|
|
// ---- ACK ---- |
|
{ |
|
const QByteArray msgHash = fromHex("deadbeef"); |
|
b::AckOptions opts; |
|
const QByteArray pkt = b::buildAck(pubA, msgHash, opts); |
|
REQUIRE(!pkt.isEmpty(), "ACK built"); |
|
REQUIRE(((static_cast<uint8_t>(pkt[0]) >> kPayloadTypeShift) & kPayloadTypeMask) |
|
== PayloadAck, "ACK payload=Ack"); |
|
REQUIRE(pkt.size() == 1 + 1 + 1 + 4, "ACK size = header + path_len + dest + msg_hash"); |
|
REQUIRE(static_cast<uint8_t>(pkt[2]) == static_cast<uint8_t>(pubA[0]), |
|
"ACK dest_hash = pubA[0]"); |
|
REQUIRE(pkt.mid(3, 4) == msgHash, "ACK msg_hash matches"); |
|
} |
|
} |
|
|
|
void testCommandParser() |
|
{ |
|
using namespace modemmeshcore; |
|
|
|
// ---- isCommand ---- |
|
REQUIRE(Packet::isCommand("MESHCORE: type=advert"), "isCommand uppercase prefix"); |
|
REQUIRE(Packet::isCommand("meshcore:type=ack"), "isCommand lowercase no space"); |
|
REQUIRE(!Packet::isCommand("Hello world"), "isCommand rejects plain text"); |
|
|
|
// ---- tokenize ---- |
|
{ |
|
QMap<QString, QString> kv; |
|
QString err; |
|
REQUIRE(command::tokenize("a=1; b=hello world; c=0xff", kv, err), |
|
"tokenize ok"); |
|
REQUIRE(kv.value("a") == "1", "tokenize a=1"); |
|
REQUIRE(kv.value("b") == "hello world", "tokenize whitespace value"); |
|
REQUIRE(kv.value("c") == "0xff", "tokenize hex value"); |
|
REQUIRE(kv.size() == 3, "tokenize 3 entries"); |
|
} |
|
{ |
|
QMap<QString, QString> kv; |
|
QString err; |
|
REQUIRE(!command::tokenize("a=1; bad-token", kv, err), |
|
"tokenize rejects malformed"); |
|
REQUIRE(!err.isEmpty(), "tokenize sets error"); |
|
} |
|
|
|
// ---- ADVERT via command ---- |
|
const QByteArray seedHex = "0102030405060708090a0b0c0d0e0f10" |
|
"111213141516171819""1a1b1c1d1e1f20"; |
|
{ |
|
QString cmd = QStringLiteral("MESHCORE: type=advert; seed=") + |
|
QString::fromLatin1(seedHex) + |
|
QStringLiteral("; name=NodeA; ts=1700000100"); |
|
QByteArray frame; |
|
QString summary, err; |
|
REQUIRE(Packet::buildFrameFromCommand(cmd, frame, summary, err), |
|
"advert command builds"); |
|
REQUIRE(!frame.isEmpty(), "advert frame non-empty"); |
|
// Header: route=Flood, payload=Advert |
|
REQUIRE((static_cast<uint8_t>(frame[0]) & kRouteMask) == RouteFlood, |
|
"advert command default route=Flood"); |
|
REQUIRE(((static_cast<uint8_t>(frame[0]) >> kPayloadTypeShift) & kPayloadTypeMask) |
|
== PayloadAdvert, |
|
"advert command payload=Advert"); |
|
REQUIRE(summary.contains("advert"), "advert summary mentions type"); |
|
} |
|
|
|
// ---- TXT_MSG via command ---- |
|
{ |
|
// Generate a destination identity |
|
const QByteArray destSeed = QByteArray::fromHex( |
|
"a1a2a3a4a5a6a7a8a9aaabacadaeafb0" |
|
"b1b2b3b4b5b6b7b8b9babbbcbdbebfc0"); |
|
const QByteArray destPub = detail::derivePubKey(destSeed); |
|
|
|
QString cmd = QStringLiteral("MESHCORE: type=txt_msg; seed=") + |
|
QString::fromLatin1(seedHex) + |
|
QStringLiteral("; dest=") + |
|
QString::fromLatin1(destPub.toHex()) + |
|
QStringLiteral("; text=Hello via parser; ts=1700000200"); |
|
QByteArray frame; |
|
QString summary, err; |
|
REQUIRE(Packet::buildFrameFromCommand(cmd, frame, summary, err), |
|
"txt_msg command builds"); |
|
REQUIRE(((static_cast<uint8_t>(frame[0]) >> kPayloadTypeShift) & kPayloadTypeMask) |
|
== PayloadTxt, "txt_msg payload=Txt"); |
|
} |
|
|
|
// ---- GRP_TXT via channel=public ---- |
|
{ |
|
QString cmd = QStringLiteral("MESHCORE: type=grp_txt; channel=public; " |
|
"text=Hello group; ts=1700000300"); |
|
QByteArray frame; |
|
QString summary, err; |
|
REQUIRE(Packet::buildFrameFromCommand(cmd, frame, summary, err), |
|
"grp_txt public builds"); |
|
REQUIRE(summary.contains("grp_txt"), "grp_txt summary"); |
|
} |
|
|
|
// ---- ACK ---- |
|
{ |
|
const QByteArray destSeed = QByteArray::fromHex( |
|
"a1a2a3a4a5a6a7a8a9aaabacadaeafb0" |
|
"b1b2b3b4b5b6b7b8b9babbbcbdbebfc0"); |
|
const QByteArray destPub = detail::derivePubKey(destSeed); |
|
QString cmd = QStringLiteral("MESHCORE: type=ack; dest=") + |
|
QString::fromLatin1(destPub.toHex()) + |
|
QStringLiteral("; msg_hash=deadbeef"); |
|
QByteArray frame; |
|
QString summary, err; |
|
REQUIRE(Packet::buildFrameFromCommand(cmd, frame, summary, err), |
|
"ack command builds"); |
|
REQUIRE(frame.size() == 1 + 1 + 1 + 4, "ack exact size"); |
|
} |
|
|
|
// ---- error cases ---- |
|
{ |
|
QByteArray frame; |
|
QString summary, err; |
|
REQUIRE(!Packet::buildFrameFromCommand("MESHCORE: name=foo", frame, summary, err), |
|
"missing type rejected"); |
|
REQUIRE(err.contains("type"), "error mentions type"); |
|
} |
|
{ |
|
QByteArray frame; |
|
QString summary, err; |
|
REQUIRE(!Packet::buildFrameFromCommand("MESHCORE: type=advert; seed=00", |
|
frame, summary, err), |
|
"short seed rejected"); |
|
REQUIRE(err.contains("seed"), "error mentions seed"); |
|
} |
|
|
|
// ---- deriveTxRadioSettings ---- |
|
{ |
|
TxRadioSettings settings; |
|
QString err; |
|
REQUIRE(Packet::deriveTxRadioSettings( |
|
"MESHCORE: type=advert; sf=8; bw=62500; cr=8; sync=0x12; freq=869.618M", |
|
settings, err), |
|
"deriveTxRadioSettings parses"); |
|
REQUIRE(settings.spreadFactor == 8, "sf=8 applied"); |
|
REQUIRE(settings.bandwidthHz == 62500, "bw=62500 applied"); |
|
REQUIRE(settings.parityBits == 4, "cr=8 -> parity=4"); |
|
REQUIRE(settings.syncWord == 0x12, "sync=0x12 applied"); |
|
REQUIRE(settings.centerFrequencyHz == 869618000, "freq=869.618M applied"); |
|
REQUIRE(settings.hasCommand, "hasCommand set"); |
|
REQUIRE(settings.hasLoRaParams, "hasLoRaParams set"); |
|
REQUIRE(settings.hasCenterFrequency, "hasCenterFrequency set"); |
|
} |
|
{ |
|
TxRadioSettings settings; |
|
QString err; |
|
REQUIRE(Packet::deriveTxRadioSettings("Hello world", settings, err), |
|
"non-command -> defaults OK"); |
|
REQUIRE(settings.bandwidthHz == kDefaultBandwidthHz, "default BW"); |
|
REQUIRE(settings.spreadFactor == kDefaultSpreadFactor, "default SF"); |
|
REQUIRE(settings.parityBits == kDefaultParityBits, "default parity"); |
|
} |
|
} |
|
|
|
QString findField(const modemmeshcore::DecodeResult& r, const QString& path) |
|
{ |
|
for (const auto& f : r.fields) { |
|
if (f.path == path) return f.value; |
|
} |
|
return QString(); |
|
} |
|
|
|
void testRoundtripDecode() |
|
{ |
|
using namespace modemmeshcore; |
|
namespace b = modemmeshcore::builders; |
|
|
|
const QByteArray seedA = fromHex("0102030405060708090a0b0c0d0e0f10" |
|
"111213141516171819""1a1b1c1d1e1f20"); |
|
const QByteArray seedB = fromHex("a1a2a3a4a5a6a7a8a9aaabacadaeafb0" |
|
"b1b2b3b4b5b6b7b8b9babbbcbdbebfc0"); |
|
const QByteArray pubA = detail::derivePubKey(seedA); |
|
const QByteArray pubB = detail::derivePubKey(seedB); |
|
|
|
// ---- ADVERT round-trip ---- |
|
{ |
|
b::AdvertOptions o; |
|
o.timestamp = 1700001000U; |
|
o.name = "NodeA"; |
|
o.routeType = RouteFlood; |
|
const QByteArray pkt = b::buildAdvert(seedA, pubA, o); |
|
REQUIRE(!pkt.isEmpty(), "advert built"); |
|
|
|
DecodeResult r; |
|
REQUIRE(Packet::decodeFrame(pkt, r), "advert decoded"); |
|
REQUIRE(r.isFrame, "advert isFrame"); |
|
REQUIRE(r.payloadType == PayloadAdvert, "advert payloadType=Advert"); |
|
REQUIRE(r.dataDecoded, "advert dataDecoded"); |
|
REQUIRE(findField(r, "advert.pubkey") == QString::fromLatin1(pubA.toHex()), |
|
"advert.pubkey roundtrip"); |
|
REQUIRE(findField(r, "advert.timestamp") == "1700001000", |
|
"advert.timestamp roundtrip"); |
|
REQUIRE(findField(r, "advert.name") == "NodeA", "advert.name roundtrip"); |
|
REQUIRE(findField(r, "advert.signature_valid") == "true", |
|
"advert signature verifies"); |
|
} |
|
|
|
// ---- TXT_MSG round-trip A -> B (B's identity + A as contact) ---- |
|
{ |
|
b::TxtMsgOptions o; |
|
o.timestamp = 1700002000U; |
|
o.routeType = RouteDirect; |
|
const QByteArray text = QByteArray("Hello B from A"); |
|
const QByteArray pkt = b::buildTxtMsg(seedA, pubB, text, o); |
|
REQUIRE(!pkt.isEmpty(), "txt_msg built A->B"); |
|
|
|
const QString keys = QString("identity=") + QString::fromLatin1(seedB.toHex()) |
|
+ "; contact:alice=" + QString::fromLatin1(pubA.toHex()); |
|
DecodeResult r; |
|
REQUIRE(Packet::decodeFrame(pkt, r, keys), "txt_msg decoded"); |
|
REQUIRE(r.payloadType == PayloadTxt, "txt_msg payloadType=Txt"); |
|
REQUIRE(r.decrypted, "txt_msg decrypted"); |
|
REQUIRE(findField(r, "txt.text") == text, "txt.text roundtrip"); |
|
REQUIRE(findField(r, "txt.sender_name") == "alice", "txt.sender_name"); |
|
REQUIRE(r.keyLabel == "contact:alice", "txt keyLabel"); |
|
} |
|
|
|
// Wrong-key path: B has a key list with no matching contact |
|
{ |
|
const QByteArray text = QByteArray("Hello"); |
|
b::TxtMsgOptions o; |
|
o.timestamp = 1700002001U; |
|
const QByteArray pkt = b::buildTxtMsg(seedA, pubB, text, o); |
|
|
|
const QString keys = QString("identity=") + QString::fromLatin1(seedB.toHex()); |
|
DecodeResult r; |
|
REQUIRE(Packet::decodeFrame(pkt, r, keys), "txt_msg envelope decoded"); |
|
REQUIRE(!r.decrypted, "txt_msg not decrypted (no matching contact)"); |
|
} |
|
|
|
// ---- GRP_TXT round-trip ---- |
|
{ |
|
const QByteArray psk = b::publicChannelPsk(); |
|
const b::GroupChannel pub = b::GroupChannel::fromPsk("public", psk); |
|
b::GrpTxtOptions o; |
|
o.timestamp = 1700003000U; |
|
const QByteArray text = QByteArray("Public group test"); |
|
const QByteArray pkt = b::buildGrpTxt(pub, text, o); |
|
REQUIRE(!pkt.isEmpty(), "grp_txt built"); |
|
|
|
const QString keys = "channel:public=public"; |
|
DecodeResult r; |
|
REQUIRE(Packet::decodeFrame(pkt, r, keys), "grp_txt decoded"); |
|
REQUIRE(r.payloadType == PayloadGrpTxt, "grp_txt payloadType=GrpTxt"); |
|
REQUIRE(r.decrypted, "grp_txt decrypted"); |
|
REQUIRE(findField(r, "grp.text") == text, "grp.text roundtrip"); |
|
REQUIRE(findField(r, "grp.channel") == "public", "grp.channel matches"); |
|
} |
|
|
|
// ---- ANON_REQ round-trip ---- |
|
{ |
|
const QByteArray data = QByteArray("anon-payload"); |
|
b::AnonReqOptions o; |
|
o.timestamp = 1700004000U; |
|
const QByteArray pkt = b::buildAnonReq(seedA, pubB, data, o); |
|
const QString keys = QString("identity=") + QString::fromLatin1(seedB.toHex()); |
|
DecodeResult r; |
|
REQUIRE(Packet::decodeFrame(pkt, r, keys), "anon_req decoded"); |
|
REQUIRE(r.payloadType == PayloadAnonReq, "anon_req payloadType=AnonReq"); |
|
REQUIRE(r.decrypted, "anon_req decrypted"); |
|
REQUIRE(findField(r, "anon.text") == QString::fromUtf8(data), "anon.text roundtrip"); |
|
} |
|
|
|
// ---- ACK round-trip ---- |
|
{ |
|
const QByteArray msgHash = fromHex("cafebabe"); |
|
b::AckOptions o; |
|
const QByteArray pkt = b::buildAck(pubA, msgHash, o); |
|
DecodeResult r; |
|
REQUIRE(Packet::decodeFrame(pkt, r), "ack decoded"); |
|
REQUIRE(r.payloadType == PayloadAck, "ack payloadType=Ack"); |
|
REQUIRE(findField(r, "ack.msg_hash") == "cafebabe", "ack.msg_hash roundtrip"); |
|
} |
|
|
|
// ---- validateKeySpecList ---- |
|
{ |
|
QString err; int n = -1; |
|
const QString good = QString("identity=") + QString::fromLatin1(seedA.toHex()) |
|
+ "; channel:public=public"; |
|
REQUIRE(Packet::validateKeySpecList(good, err, &n), "valid key list"); |
|
REQUIRE(n == 2, "valid key list count = 2"); |
|
|
|
REQUIRE(!Packet::validateKeySpecList("identity=ff", err, &n), |
|
"short identity rejected"); |
|
REQUIRE(!Packet::validateKeySpecList("", err, &n), "empty rejected"); |
|
} |
|
} |
|
|
|
int main(int argc, char** argv) |
|
{ |
|
(void)argc; |
|
(void)argv; |
|
|
|
std::printf("modemmeshcore smoke test\n"); |
|
std::printf("[1] testPathLenEncoding\n"); |
|
testPathLenEncoding(); |
|
std::printf("[2] testCryptoRoundtrip\n"); |
|
testCryptoRoundtrip(); |
|
std::printf("[3] testAdvertBuilder\n"); |
|
testAdvertBuilder(); |
|
std::printf("[4] testEncryptedBuilders\n"); |
|
testEncryptedBuilders(); |
|
std::printf("[5] testCommandParser\n"); |
|
testCommandParser(); |
|
std::printf("[6] testRoundtripDecode\n"); |
|
testRoundtripDecode(); |
|
std::printf("\nALL OK\n"); |
|
return 0; |
|
}
|
|
|