Files
MeshCore/test/test_companion_direct_admin_guard.py
T

315 lines
17 KiB
Python

"""Execute Companion's guarded Binary modes and decrypted RX admission offline."""
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import unittest
from test_direct_ota_admin_client import STUB
from test_replay_reset_integration import extract_braced
ROOT = Path(__file__).resolve().parents[1]
HARNESS = r'''
#include <helpers/CompanionDirectAdminGuard.h>
#define CMD_SEND_PATH_DISCOVERY_REQ 52
#define ERR_CODE_NOT_FOUND 1
#define ERR_CODE_BAD_STATE 2
#define ERR_CODE_ILLEGAL_ARG 3
#define ERR_CODE_TABLE_FULL 4
#define MAX_ANON_CONTACTS 8
#define ADV_TYPE_NONE 0
#define ADV_TYPE_REPEATER 2
#define ADV_TYPE_ROOM 3
#define TXT_TYPE_CLI_DATA 1
struct ContactInfo {
mesh::Identity id;
uint8_t type=0, out_path_len=0, tx_radio=0, flags=0;
char name[32]{};
uint32_t sync_since=0;
uint8_t out_path[64]{};
mutable uint8_t secret[32]{};
const uint8_t* getSharedSecret(const mesh::LocalIdentity&) const {memset(secret,0x44,32);return secret;}
bool setPath(const uint8_t*,uint8_t length){out_path_len=length;memset(out_path,0,sizeof(out_path));return true;}
};
struct BaseSerialInterface {BaseSerialInterface* route=this;BaseSerialInterface* captureReplyRoute(){return route;}};
struct Timer { uint32_t now=100;uint32_t getMillis()const{return now;} };
struct BaseChatMesh:mesh::Mesh {
ContactInfo contact,anonymous[MAX_ANON_CONTACTS];
int data_calls=0,path_calls=0,login_calls=0,clear_calls=0,lookup_length=0;
BaseChatMesh(){memset(contact.id.pub_key,0x11,32);contact.type=2;contact.out_path_len=2;contact.out_path[0]=0xAA;
contact.flags=31;contact.sync_since=987;contact.tx_radio=2;strcpy(contact.name,"Saved contact");}
ContactInfo* lookupContactByPubKey(const uint8_t* key,int n){
lookup_length=n;
for(auto& p:anonymous) if(!memcmp(key,p.id.pub_key,n)) return &p;
return !memcmp(key,contact.id.pub_key,n)?&contact:nullptr;
}
ContactInfo* getContactPtrByIdx(unsigned i){return i<MAX_ANON_CONTACTS?&anonymous[i]:nullptr;}
bool isTransientContact(const ContactInfo& p){for(auto& a:anonymous)if(&a==&p)return true;return false;}
void resetContactValue(ContactInfo& c){c=ContactInfo();}
bool clearTransientContact(ContactInfo& c){assert(isTransientContact(c));resetContactValue(c);++clear_calls;return true;}
virtual uint8_t getContactTxRadio(const mesh::Identity&)const{return 2;}
int sendLogin(const ContactInfo&,const char*,uint32_t&);
int sendContactPacket(const ContactInfo& peer,mesh::Packet* packet,uint32_t& timeout){
assert(peer.out_path_len==0);timeout=0;
packet->tx_radio=getContactTxRadio(peer.id);
return sendDirect(packet,nullptr,peer.out_path_len)?1:0;
}
void onPeerDataRecv(mesh::Packet*,uint8_t,int,const uint8_t*,uint8_t*,size_t){++data_calls;}
bool onPeerPathRecv(mesh::Packet*,int,const uint8_t*,uint8_t*,uint8_t,uint8_t,uint8_t*,uint8_t){++path_calls;return true;}
void onContactResponse(const ContactInfo&,const uint8_t*,uint8_t){++login_calls;}
};
struct MyMesh:BaseChatMesh {
Timer timer;Timer* _ms=&timer;
BaseSerialInterface wire;BaseSerialInterface* _serial=&wire;
BaseSerialInterface* _ota_direct_usb_route=&wire;
uint8_t cmd_frame[64]{};int response=-1;
mesh::CompanionDirectAdminGuard _ota_direct_admin;
ContactInfo _ota_direct_contact;
ContactInfo* _ota_direct_transient=nullptr;
void writeOKFrame(){response=0;}
void writeErrFrame(int value){response=value;}
void dispatch(size_t len){
response=-1;
#if FULL
if(handleDirectOtaFrame(len)) return;
#else
(void)len;
#endif
}
bool handleDirectOtaFrame(size_t len);
bool handleDirectOtaCommand(const char*,uint32_t,char*,size_t);
void closeDirectOtaAdmin();
void mode(int value,const mesh::Identity* peer=nullptr,uint8_t type=ADV_TYPE_REPEATER){
cmd_frame[0]=52;cmd_frame[1]=value;memcpy(cmd_frame+2,(peer?peer->pub_key:contact.id.pub_key),32);
cmd_frame[34]=type;dispatch(value==1?35:34);
}
bool command(const char* command,uint32_t stamp,char* reply){
#if FULL
return handleDirectOtaCommand(command,stamp,reply,160);
#else
(void)command;(void)stamp;(void)reply;return false;
#endif
}
void expect(const char* prefix){cmd_frame[0]=52;cmd_frame[1]=4;memcpy(cmd_frame+2,contact.id.pub_key,32);memcpy(cmd_frame+34,prefix,3);dispatch(37);assert(response==0);}
void onPeerDataRecv(mesh::Packet*,uint8_t,int,const uint8_t*,uint8_t*,size_t);
#if FULL
uint8_t getContactTxRadio(const mesh::Identity&)const;
#else
uint8_t getContactTxRadio(const mesh::Identity& peer)const override{return BaseChatMesh::getContactTxRadio(peer);}
#endif
bool onPeerPathRecv(mesh::Packet*,int,const uint8_t*,uint8_t*,uint8_t,uint8_t,uint8_t*,uint8_t);
void rawRoute(mesh::Packet* pkt){
#if FULL
@RAW_ROUTE@
#else
(void)pkt;
#endif
}
};
@CALLBACKS@
@BINARY@
@SEND_LOGIN@
static void repeaterPrefix(char*& command,char*& reply){@REPEATER_PREFIX@}
static void roomPrefix(char*& command,char*& reply){@ROOM_PREFIX@}
[[maybe_unused]] static void body(uint8_t* data,uint32_t stamp,const char* prefix,const char* text){
memset(data,0,184);memcpy(data,&stamp,4);data[4]=4;memcpy(data+5,prefix,3);memcpy(data+8,text,strlen(text));
}
int main(){
MyMesh m;char reply[160]{};
for(char a='!';a<='~';++a)for(char b='!';b<='~';++b){
if(a=='|'||b=='|')continue;
char input[]={a,b,'|','g','e','t',' ','p','u','b','l','i','c','.','k','e','y',0};
for(auto parser:{repeaterPrefix,roomPrefix}){
char* command=input;char* output=reply;
parser(command,output);
assert(!strcmp(command,"get public.key")&&output==reply+3&&!memcmp(reply,input,3));
}
#if FULL
assert(m._ota_direct_admin.expect(reinterpret_cast<const uint8_t*>(input),m.timer.now)==false);
#endif
}
m.mode(1);
#if FULL
assert(m.response==0&&m.calls==0); // capability negotiation has no RF
assert(m.contact.out_path_len==2&&m.contact.out_path[0]==0xAA);
assert(m.lookup_length==PUB_KEY_SIZE&&m._ota_direct_contact.id.matches(m.contact.id));
assert(m._ota_direct_contact.out_path_len==0&&m._ota_direct_contact.tx_radio==1);
assert(m._ota_direct_contact.type==ADV_TYPE_REPEATER&&m._ota_direct_contact.sync_since==0);
assert(m._ota_direct_contact.flags==0&&m._ota_direct_contact.name[0]==0);
assert(m.contact.flags==31&&m.contact.sync_since==987&&m.contact.tx_radio==2);
assert(!strcmp(m.contact.name,"Saved contact"));
assert(m.getContactTxRadio(m.contact.id)==mesh::RADIO_TX_PRIMARY);
mesh::Identity another;assert(m.getContactTxRadio(another)==2);
mesh::Packet ota;ota.payload_type=12;m.rawRoute(&ota);assert(ota.tx_radio==mesh::RADIO_TX_PRIMARY);
assert(m.command("get ota.direct",0,reply)&&strstr(reply,"v=2 active=1 busy=0"));
for(char a='!';a<='~';++a)for(char b='!';b<='~';++b){
if(a=='|'||b=='|')continue;
const uint8_t prefix[]={uint8_t(a),uint8_t(b),'|'};
assert(m._ota_direct_admin.expect(prefix,m.timer.now));
assert(m.command("get ota.direct.reply 0",0,reply));
const char* tag=strstr(reply,"req=")+4;assert(tag[0]==a&&tag[1]==b&&tag[2]==' ');
}
assert(!m.command("get ota.direct",1,reply));
BaseSerialInterface foreign;m.wire.route=&foreign;
m.mode(1);assert(m.response==ERR_CODE_BAD_STATE);
assert(m.command("get ota.direct.reply 0",0,reply)&&strstr(reply,"physical USB"));
m.wire.route=&m.wire;
uint8_t data[184]{};mesh::Packet packet;packet.direct=false;
uint8_t secret[32],other[32];memset(secret,0x44,32);memset(other,0x77,32);
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_RESPONSE,0,secret,data,13);assert(m.login_calls==0);
m._ota_direct_admin.beginLogin(m.contact.id,m.timer.now);
uint32_t login_stamp=1000;memcpy(data,&login_stamp,4);data[7]=3;
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_RESPONSE,0,secret,data,13);assert(m.login_calls==1);
packet.path_len=1;m.onPeerDataRecv(&packet,PAYLOAD_TYPE_RESPONSE,0,secret,data,13);assert(m.login_calls==1);
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_RESPONSE,0,other,data,13);assert(m.data_calls==1);
packet.path_len=0;
m.mode(2);assert(m.response==0&&m.type==PAYLOAD_TYPE_PATH&&m.packet.tx_radio==1);
assert(m.command("get ota.direct",0,reply)&&strstr(reply,"busy=1"));
m.pending=false;assert(m.command("get ota.direct",0,reply)&&strstr(reply,"busy=0"));
// Exact MAC-bound peer, fresh timestamp, DIRECT0 and command prefix are all
// required. Ordinary private messages and unmatched CLI replies stay in inbox.
m.expect("Ab|");
body(data,1001,"Ab|","reply");
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_TXT_MSG,0,secret,data,16);
assert(m.command("get ota.direct.reply 0",0,reply)&&strstr(reply,"state=pending"));
packet.direct=true;packet.path_len=0x40;
body(data,999,"Ab|","stale");m.onPeerDataRecv(&packet,PAYLOAD_TYPE_TXT_MSG,0,secret,data,16);
assert(m.command("get ota.direct.reply 0",0,reply)&&strstr(reply,"state=pending"));
body(data,1001,"ZZ|","other CLI");m.onPeerDataRecv(&packet,PAYLOAD_TYPE_TXT_MSG,0,secret,data,32);assert(m.data_calls==2);
body(data,1001,"Ab|","unrelated message");data[4]=0;
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_TXT_MSG,0,secret,data,32);assert(m.data_calls==3);
std::string expected(160,'X');body(data,1001,"Ab|",expected.c_str());
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_TXT_MSG,0,secret,data,176);assert(m.data_calls==3);
for(unsigned offset: {0U,40U,80U,120U}){
std::string command="get ota.direct.reply "+std::to_string(offset);
assert(m.command(command.c_str(),0,reply));
assert(strstr(reply,"req=Ab state=ready bytes=160"));
const char* hex=strstr(reply,"data=")+5;assert(strlen(hex)==80);
for(unsigned i=0;i<80;++i)assert(hex[i]==(i%2?'8':'5'));
}
m.onPeerDataRecv(&packet,PAYLOAD_TYPE_TXT_MSG,0,secret,data,176);assert(m.data_calls==3); // duplicate is consumed
assert(m.command("get ota.direct.reply 161",0,reply)&&strstr(reply,"invalid reply offset"));
assert(m.command("get ota.direct.reply -1",0,reply)&&strstr(reply,"invalid reply offset"));
assert(!m.onPeerPathRecv(&packet,0,secret,data,1,0,data,0));assert(m.path_calls==0);
assert(!m.onPeerPathRecv(&packet,0,secret,data,0,0,data,0));assert(m.path_calls==0);
assert(m.contact.out_path_len==2&&m.contact.out_path[0]==0xAA);
m.mode(3);assert(m.response==0&&!m._ota_direct_admin.active(m.timer.now));
assert(m.getContactTxRadio(m.contact.id)==2);
m.mode(3);assert(m.response==0); // cleanup is idempotent
m.contact.type=ADV_TYPE_ROOM;
m.mode(1,nullptr,ADV_TYPE_ROOM);
assert(m.response==0&&m._ota_direct_contact.type==ADV_TYPE_ROOM);
assert(m._ota_direct_contact.sync_since==0&&m._ota_direct_contact.id.matches(m.contact.id));
uint32_t timeout=0;
assert(m.sendLogin(m._ota_direct_contact,"secret",timeout)==1);
assert(m.type==PAYLOAD_TYPE_ANON_REQ&&m.packet.tx_radio==mesh::RADIO_TX_PRIMARY);
assert(m.sent.size()==14&&!memcmp(m.sent.data()+8,"secret",6));
for(unsigned i=4;i<8;++i)assert(m.sent[i]==0); // Room login requests no historical cursor.
assert(m.contact.type==ADV_TYPE_ROOM&&m.contact.sync_since==987);
assert(m.contact.out_path_len==2&&m.contact.out_path[0]==0xAA&&m.contact.tx_radio==2);
m.mode(3);assert(m.response==0);
mesh::Identity fresh;memset(fresh.pub_key,0x22,32);m.mode(1,&fresh);
assert(m.response==0&&m._ota_direct_transient);
assert(m._ota_direct_contact.id.matches(fresh)&&m._ota_direct_contact.type==ADV_TYPE_REPEATER);
assert(m._ota_direct_contact.out_path_len==0&&m._ota_direct_contact.tx_radio==mesh::RADIO_TX_PRIMARY);
assert(m._ota_direct_transient->type==ADV_TYPE_NONE&&m.contact.out_path_len==2);
m.mode(3,&fresh);assert(m.response==0&&m.clear_calls==1);
for(auto& slot:m.anonymous){memset(slot.id.pub_key,0x33,32);slot.type=ADV_TYPE_NONE;}
m.mode(1,&fresh);assert(m.response==ERR_CODE_TABLE_FULL); // never evict occupied transient requests
for(auto& slot:m.anonymous)assert(slot.id.pub_key[0]==0x33);
#else
assert(m.response==-1&&m.calls==0);
assert(!m.command("get ota.direct",0,reply));
#endif
}
'''
class CompanionDirectAdminGuardTest(unittest.TestCase):
def test_guard_and_production_companion_wiring(self):
compiler = shutil.which("g++") or shutil.which("clang++")
if compiler is None:
self.skipTest("a host C++17 compiler is required")
source = (ROOT / "examples/companion_radio/MyMesh.cpp").read_text()
binary = extract_braced(source, "bool MyMesh::handleDirectOtaFrame(")
getter = extract_braced(source, "bool MyMesh::handleDirectOtaCommand(")
closer = extract_braced(source, "void MyMesh::closeDirectOtaAdmin(")
base = (ROOT / "src/helpers/BaseChatMesh.cpp").read_text()
send_login = extract_braced(base, "int BaseChatMesh::sendLogin(")
callbacks = "\n".join(extract_braced(source, signature) for signature in (
"uint8_t MyMesh::getContactTxRadio(", "void MyMesh::onPeerDataRecv(", "bool MyMesh::onPeerPathRecv("))
raw = extract_braced(source, "if (pkt->getPayloadType() == PAYLOAD_TYPE_OTA\n && _ota_direct_admin.active")
self.assertIn("_ota_direct_admin.beginLogin(recipient->id", source)
self.assertIn("if (handleDirectOtaCommand(command, sender_timestamp, reply, reply_capacity))", source)
self.assertIn("closeDirectOtaAdmin();", extract_braced(source, "void MyMesh::resetUsbHostSessionInput("))
self.assertIn("setDirectAdminUsbRoute(&usb_serial_interface)", (ROOT / "examples/companion_radio/main.cpp").read_text())
self.assertIn("recipient = &_ota_direct_contact", source)
self.assertIn("if (handleDirectOtaFrame(len)) return;", source)
self.assertIn("&& (!COMPANION_FEATURE_DIRECT_OTA_ADMIN || cmd_frame[1] == 0))", source)
mesh = (ROOT / "src/Mesh.cpp").read_text()
start = mesh.index("Packet* Mesh::createPathReturn(const uint8_t* dest_hash,")
end = mesh.index("\nPacket* Mesh::createDatagram(", start)
stub = STUB.replace("@PATH_BUILDER@", mesh[start:end])
stub = stub.replace("#define PAYLOAD_TYPE_PATH 8", "#define PAYLOAD_TYPE_PATH 8\n#define PAYLOAD_TYPE_OTA 12")
stub = stub.replace("bool direct=true;", "uint8_t payload_type=0;uint8_t getPayloadType()const{return payload_type;}\n bool direct=true;")
prefix_blocks = []
for board in ("simple_repeater", "simple_room_server"):
server = (ROOT / "examples" / board / "MyMesh.cpp").read_text()
prefix_blocks.append(extract_braced(server, "if (strlen(command) > 4 && command[2] == '|') {"))
with tempfile.TemporaryDirectory(prefix="meshcore-companion-direct-") as folder:
folder = Path(folder)
(folder / "Mesh.h").write_text(stub)
for full in (0, 1):
code = HARNESS.replace("@BINARY@", (binary + "\n" + getter + "\n" + closer) if full else "")
code = code.replace("@RAW_ROUTE@", raw)
code = code.replace("@CALLBACKS@", callbacks if full else "")
code = code.replace("@SEND_LOGIN@", send_login if full else "")
code = code.replace("@REPEATER_PREFIX@", prefix_blocks[0])
code = code.replace("@ROOM_PREFIX@", prefix_blocks[1])
(folder / "test.cpp").write_text(code)
executable = folder / "guard.exe"
sanitize = (["-fsanitize=address,undefined", "-fno-omit-frame-pointer", "-fno-pie", "-no-pie"]
if sys.platform.startswith("linux") else [])
result = subprocess.run([compiler, "-std=c++17", "-Wall", "-Wextra", "-Werror",
*sanitize, f"-DFULL={full}", "-I" + str(folder), "-I" + str(ROOT / "src"),
str(folder / "test.cpp"), "-o", str(executable)],
capture_output=True, text=True, timeout=60)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
result = subprocess.run([str(executable)], capture_output=True, text=True, timeout=10)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
def test_direct_helper_defaults_preserve_existing_rak_full_features(self):
compiler = shutil.which("g++") or shutil.which("clang++")
if compiler is None:
self.skipTest("a host C++ preprocessor is required")
full = ["COMPANION_RADIO_FULL=1", "ENABLE_OTA=1", "ENABLE_USB_INTERFACE=1", "BLE_PIN_CODE=123456"]
cases = (("esp32", full + ["ESP32_PLATFORM=1", "WIFI_SSID=fixture"], 1, 1),
("nrf52", full + ["NRF52_PLATFORM=1"], 1, 1),
("rak4631", full + ["NRF52_PLATFORM=1", "RAK_4631=1"], 1, 1),
("reduced", ["NRF52_PLATFORM=1", "RAK_4631=1"], 0, 0),
("rak opt-out", full + ["NRF52_PLATFORM=1", "RAK_4631=1", "COMPANION_FEATURE_DIRECT_OTA_ADMIN=0"], 0, 1))
code = ('#include "examples/companion_radio/CompanionFeatures.h"\n'
'DIRECT_HELPER COMPANION_FEATURE_DIRECT_OTA_ADMIN\n'
'EXISTING_OTA COMPANION_FEATURE_OTA_CLI\n'
'EXISTING_TEMP COMPANION_FEATURE_TEMP_RADIO\n')
for name, flags, direct, existing in cases:
with self.subTest(profile=name):
result = subprocess.run([compiler, "-E", "-P", "-x", "c++", "-I" + str(ROOT),
"-I" + str(ROOT / "src"), *["-D" + flag for flag in flags], "-"],
input=code, capture_output=True, text=True, timeout=30)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertIn(f"DIRECT_HELPER {direct}", result.stdout)
self.assertIn(f"EXISTING_OTA {existing}", result.stdout)
self.assertIn(f"EXISTING_TEMP {existing}", result.stdout)
if __name__ == "__main__":
unittest.main()