Harden USB logging and persist watchdog events in management reports
This commit is contained in:
1 parent
bd55369aa9
commit
3add4695cc
98 files changed
+7207
-372
No files matched your search
+84
-13
@@ -19,7 +19,7 @@ int main() {
|
||||
assert(equal(tag, hex("85632d07c6e8f37f950acd320a2ecc93").data(), 16));
|
||||
assert(p == hex("40c02b9690c4dc04daef7f6afe5c"));
|
||||
assert(open(k.data(), ad.data(), ad.size(), p.data(), p.size(), tag)); assert(p == plain);
|
||||
for (size_t n : {size_t(0), size_t(1), size_t(15), size_t(16), size_t(17), size_t(78), size_t(177)}) {
|
||||
for (size_t n : {size_t(0), size_t(1), size_t(15), size_t(16), size_t(17), size_t(78), size_t(177), MAX_PAYLOAD}) {
|
||||
std::vector<uint8_t> b(n, 0x39), original = b;
|
||||
assert(seal(k.data(), ad.data(), ad.size(), b.data(), n, tag));
|
||||
assert(open(k.data(), ad.data(), ad.size(), b.data(), n, tag)); assert(b == original);
|
||||
@@ -27,7 +27,7 @@ int main() {
|
||||
assert(!open(k.data(), ad.data(), ad.size(), b.data(), n, tag));
|
||||
for (uint8_t c : b) assert(c == 0);
|
||||
}
|
||||
assert(!seal(k.data(), ad.data(), ad.size(), p.data(), 178, tag));
|
||||
assert(!seal(k.data(), ad.data(), ad.size(), p.data(), MAX_PAYLOAD + 1, tag));
|
||||
History history;
|
||||
history.sample(0, 3900, -4); history.sample(59, 3100, 98);
|
||||
assert(history.week().voltage == 3100 && history.week().high == temperature(98));
|
||||
@@ -58,18 +58,89 @@ int main() {
|
||||
assert(acl.count == 1 && acl.entries[0][12] == 3);
|
||||
for (uint8_t i = 1; i < MAX_KEYS; ++i) { token[0] = i; assert(acl.add(token, ADMIN)); }
|
||||
token[0] = 240; assert(!acl.add(token, ADMIN)); assert(acl.pages() == MAX_PAGES);
|
||||
// Emit cross-language packets with all header fields and maximum ACL pages.
|
||||
for (uint8_t page = 0; page < acl.pages(); ++page) {
|
||||
uint8_t raw[MAX_PAYLOAD] = {}, enc[32]; memcpy(raw, "MGR1", 4); memcpy(raw + 4, radio, 16);
|
||||
write32(raw + 20, 42); write32(raw + 28, 0x01110105); write16(raw + 76, FIRMWARE);
|
||||
raw[71] = 5; raw[78] = page; raw[79] = acl.pages(); raw[80] = acl.count;
|
||||
raw[81] = page * PER_PAGE; raw[82] = PER_PAGE;
|
||||
memcpy(raw + HEADER, acl.entries[page * PER_PAGE], PER_PAGE * ENTRY);
|
||||
mesh::UsbLoggingStatus usb;
|
||||
usb.supported = usb.logging_enabled = usb.watchdog_enabled = true;
|
||||
usb.host_connected = usb.reader_connected = usb.logger_active = true;
|
||||
usb.stalled = usb.recovering = usb.recovery_deferred = usb.persistence_ready = true;
|
||||
usb.watchdog_auto = true; usb.auto_connected_seconds = 1209600;
|
||||
usb.stage = 2; usb.backoff_step = 8; usb.retry_seconds = 604800;
|
||||
usb.inactive_seconds = UINT32_MAX;
|
||||
usb.last_event.reasons = 15;
|
||||
usb.last_event.action = mesh::UsbLoggingWatchdogEvent::REBOOT_REQUESTED;
|
||||
usb.last_event.epoch = 1700000001; usb.last_event.uptime_seconds = 777;
|
||||
usb.last_event.sequence = 42; usb.last_event.persisted = true;
|
||||
uint8_t usb_block[USB_STATUS_SIZE] = {};
|
||||
encodeUsbStatus(usb_block, usb);
|
||||
assert(read16(usb_block) == 2047 && usb_block[2] == (2 | (8 << 2)));
|
||||
assert(read32(usb_block + 3) == 604800 && read32(usb_block + 7) == UINT32_MAX);
|
||||
assert(read32(usb_block + 11) == 1209600);
|
||||
usb.logger_active = false; encodeUsbStatus(usb_block, usb);
|
||||
assert(read16(usb_block) == 1023); // host/reader connection does not imply a logger
|
||||
usb.logger_active = true;
|
||||
// Emit all wire versions for independent Python and browser decoders.
|
||||
for (const char* magic : {"MGR1", "MGR2", "MGR3"}) {
|
||||
const auto* version = reinterpret_cast<const uint8_t*>(magic);
|
||||
const bool current = currentPage(version), has_usb = usbPage(version);
|
||||
const size_t header = headerSize(version), per_page = entriesPerPage(version);
|
||||
for (uint8_t page = 0; page < acl.pages(per_page); ++page) {
|
||||
uint8_t raw[179] = {}, enc[32]; memcpy(raw, magic, 4);
|
||||
memcpy(raw + 4, radio, 16);
|
||||
write32(raw + 20, 42); write32(raw + 28, 0x01110105); write16(raw + 76, FIRMWARE);
|
||||
raw[71] = 5; raw[78] = page; raw[79] = acl.pages(per_page); raw[80] = acl.count;
|
||||
raw[81] = page * per_page;
|
||||
raw[82] = acl.count - raw[81] < per_page ? acl.count - raw[81] : per_page;
|
||||
if (has_usb) encodeUsbStatus(raw + HEADER, usb);
|
||||
if (current) mesh::encodeUsbWatchdogEvent(raw + WATCHDOG_EVENT_OFFSET, usb.last_event);
|
||||
const size_t private_len = raw[82] * ENTRY, size = header + private_len + TAG;
|
||||
memcpy(raw + header, acl.entries[raw[81]], private_len);
|
||||
deriveKey(root, "MeshCore-MGR1-SIV", radio, enc);
|
||||
assert(seal(enc, raw, header, raw + header, private_len, raw + header + private_len));
|
||||
assert(validPage(raw, size)); print(raw, size);
|
||||
assert(size <= MAX_PAYLOAD && floodSize(size) <= 179);
|
||||
assert(validPage(raw, floodSize(size), true));
|
||||
if (floodSize(size) > size) {
|
||||
raw[floodSize(size) - 1] ^= 1;
|
||||
assert(!validPage(raw, floodSize(size), true)); raw[floodSize(size) - 1] ^= 1;
|
||||
}
|
||||
if (has_usb) {
|
||||
raw[85] |= 0x40; assert(!validPage(raw, size)); raw[85] &= ~0x40;
|
||||
raw[84] |= 0x08; assert(!validPage(raw, size)); raw[84] &= ~0x08;
|
||||
}
|
||||
if (current) {
|
||||
const uint8_t original = raw[98];
|
||||
for (uint8_t invalid : {uint8_t(original & 0xf0), uint8_t(original & 0x8f), uint8_t(0xdf)}) {
|
||||
raw[98] = invalid; assert(!validPage(raw, size));
|
||||
}
|
||||
raw[98] = original;
|
||||
write32(raw + 107, 0); assert(!validPage(raw, size)); write32(raw + 107, 42);
|
||||
}
|
||||
raw[81]++; assert(!validPage(raw, size)); raw[81]--;
|
||||
assert(!validPage(raw, size - 1)); raw[80] = 37; assert(!validPage(raw, size));
|
||||
}
|
||||
}
|
||||
// A current report with no recorded event is authenticated, not invented.
|
||||
{
|
||||
uint8_t raw[179] = {}, enc[32]; memcpy(raw, "MGR3", 4); memcpy(raw + 4, radio, 16);
|
||||
write32(raw + 20, 43); raw[79] = 1;
|
||||
deriveKey(root, "MeshCore-MGR1-SIV", radio, enc);
|
||||
assert(seal(enc, raw, HEADER, raw + HEADER, PER_PAGE * ENTRY, raw + MAX_PAYLOAD - TAG));
|
||||
assert(validPage(raw, sizeof(raw))); print(raw, sizeof(raw));
|
||||
raw[81]++; assert(!validPage(raw, sizeof(raw))); raw[81]--;
|
||||
assert(!validPage(raw, sizeof(raw) - 1)); raw[80] = 37; assert(!validPage(raw, sizeof(raw)));
|
||||
assert(seal(enc, raw, CURRENT_HEADER, raw + CURRENT_HEADER, 0, raw + CURRENT_HEADER));
|
||||
assert(validPage(raw, CURRENT_HEADER + TAG)); print(raw, CURRENT_HEADER + TAG);
|
||||
}
|
||||
// Every ACL count retains complete coverage and the unchanged flood ceiling.
|
||||
for (unsigned total = 0; total <= MAX_KEYS; ++total) {
|
||||
for (unsigned page = 0; page < (total ? (total + 3) / 4 : 1); ++page) {
|
||||
uint8_t raw[179] = {}; memcpy(raw, "MGR3", 4);
|
||||
raw[78] = page; raw[79] = total ? (total + 3) / 4 : 1; raw[80] = total;
|
||||
raw[81] = page * 4; raw[82] = total - raw[81] < 4 ? total - raw[81] : 4;
|
||||
const size_t size = pageSize(raw);
|
||||
assert(validPage(raw, size) && floodSize(size) <= 179);
|
||||
assert(validPage(raw, floodSize(size), true));
|
||||
}
|
||||
}
|
||||
for (size_t n = 0; n < CURRENT_HEADER + TAG; ++n) {
|
||||
std::vector<uint8_t> truncated(n);
|
||||
for (size_t i = 0; i < n && i < 4; ++i) truncated[i] = "MGR3"[i];
|
||||
assert(!validPage(truncated.data(), n));
|
||||
}
|
||||
for (size_t n = 0; n < HEADER + TAG; ++n) assert(!validPage(plain.data(), n));
|
||||
}
|
||||
Reference in new issue
Block a user