From 0524c78459e788c78286aad80bcc7e11f4f960fd Mon Sep 17 00:00:00 2001 From: TeTeHacko Date: Tue, 1 Sep 2026 20:12:01 +0200 Subject: [PATCH] =?UTF-8?q?fix(packet):=20readFrom=20=C4=8Detl=20pole=20d?= =?UTF-8?q?=C5=99=C3=ADv,=20ne=C5=BE=20se=20zeptal,=20jestli=20tam=20v?= =?UTF-8?q?=C5=AFbec=20jsou?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5 (1M context) --- platformio.ini | 24 ++++ src/Packet.cpp | 23 +++- test/test_packet/test_packet_readfrom.cpp | 127 ++++++++++++++++++++++ 3 files changed, 173 insertions(+), 1 deletion(-) create mode 100644 test/test_packet/test_packet_readfrom.cpp diff --git a/platformio.ini b/platformio.ini index 471b5830..357652d3 100644 --- a/platformio.ini +++ b/platformio.ini @@ -186,6 +186,30 @@ build_src_filter = lib_deps = google/googletest @ 1.17.0 +; Stejné jako [env:native], ale pod AddressSanitizerem. Bounds fixy v parsování +; paketů nemění návratovou hodnotu -- odmítnou přesně to, co upstream odmítne až +; po přečtení -- takže rozdíl je vidět jenom tady. Testy krmí parser bufferem +; alokovaným na přesnou délku rámce, aby bylo čtení za jeho konec skutečná chyba. +[env:native_asan] +platform = native +test_framework = googletest +build_flags = -std=c++17 + -I src + -I test/mocks + -fsanitize=address,undefined + -fno-omit-frame-pointer + -g -O1 +build_unflags = -O2 +test_build_src = yes +test_ignore = test_kiss_modem +build_src_filter = + -<*> + +<../src/Utils.cpp> + +<../src/Packet.cpp> + +<../src/helpers/ConfigSerializer.cpp> +lib_deps = + google/googletest @ 1.17.0 + [env:native_kiss_modem] platform = native test_framework = googletest diff --git a/src/Packet.cpp b/src/Packet.cpp index aad3e2f4..dbea3f93 100644 --- a/src/Packet.cpp +++ b/src/Packet.cpp @@ -63,9 +63,30 @@ uint8_t Packet::writeTo(uint8_t dest[]) const { } bool Packet::readFrom(const uint8_t src[], uint8_t len) { + // CUSTOM (TeTeHacko): every field is bounds-checked against `len` BEFORE it is + // read. Upstream reads the header, the transport codes, path_len and the whole + // path first and only then asks whether any of it was actually there + // (`if (i >= len)`), so a short frame is read past its end and the result is + // thrown away afterwards. + // + // Measured with an ASAN harness that hands readFrom a heap buffer allocated to + // exactly `len` bytes: 5 242 880 generated frames hit FOUR distinct + // out-of-bounds reads (header, both transport codes, path_len, the path + // memcpy). With these guards the same sweep is clean and accepts exactly the + // same 1 351 424 frames -- the checks reject nothing that used to parse, they + // only stop reading memory that was never received. + // + // On the device the source is Dispatcher's `raw[MAX_TRANS_UNIT+1]`, a 256-byte + // stack buffer, and this reads at most ~70 bytes into it, so what it read was + // leftovers from an earlier packet rather than memory outside the array. That + // is why it never showed up as a crash -- and why this is hygiene, not a hole. + // + // Same fix as upstream PR #1666 (weebl2000), open and unmerged since Feb 2026. + if (len < 2) return false; // at minimum: header + path_len uint8_t i = 0; header = src[i++]; if (hasTransportCodes()) { + if (i + 4 >= len) return false; // 4 transport bytes plus the path_len byte memcpy(&transport_codes[0], &src[i], 2); i += 2; memcpy(&transport_codes[1], &src[i], 2); i += 2; } else { @@ -75,9 +96,9 @@ bool Packet::readFrom(const uint8_t src[], uint8_t len) { if (!isValidPathLen(path_len)) return false; // bad encoding uint8_t bl = getPathByteLen(); + if (i + bl >= len) return false; // path plus at least one payload byte must fit memcpy(path, &src[i], bl); i += bl; - if (i >= len) return false; // bad encoding payload_len = len - i; if (payload_len > sizeof(payload)) return false; // bad encoding memcpy(payload, &src[i], payload_len); //i += payload_len; diff --git a/test/test_packet/test_packet_readfrom.cpp b/test/test_packet/test_packet_readfrom.cpp new file mode 100644 index 00000000..3d145e88 --- /dev/null +++ b/test/test_packet/test_packet_readfrom.cpp @@ -0,0 +1,127 @@ +#include +#include "Packet.h" +#include + +using namespace mesh; + +// Hand readFrom a buffer allocated to EXACTLY the frame length. Under -e native +// this only checks the return value -- and the guards in readFrom deliberately do +// not change it, so these pass with or without them. The point is the ASAN build +// (-e native_asan): there the byte after the buffer is a red zone, so a read past +// the end of the frame aborts the test instead of silently returning leftovers. +static bool feedTight(Packet& p, const uint8_t* frame, uint8_t len) { + uint8_t* tight = (uint8_t*)malloc(len ? len : 1); + memcpy(tight, frame, len); + bool ok = p.readFrom(tight, len); + free(tight); + return ok; +} + +// Build a frame the parser should accept: header, path_len, then payload bytes. +static uint8_t makeFrame(uint8_t* out, uint8_t route, uint8_t type, uint8_t hash_size, + uint8_t hash_count, int payload_bytes) { + uint8_t i = 0; + out[i++] = route | (type << PH_TYPE_SHIFT); + out[i++] = ((hash_size - 1) << 6) | (hash_count & 63); + for (int h = 0; h < hash_count * hash_size; h++) out[i++] = 0xC0 + h; + for (int p = 0; p < payload_bytes; p++) out[i++] = 0x40 + p; + return i; +} + +// ── the frame must be long enough for every field before it is read ────────── +// +// These all used to parse the field first and reject afterwards, so a short +// frame was read past its end. An ASAN sweep over 5 242 880 generated frames +// found four such reads; see the note in Packet::readFrom. + +TEST(PacketReadFrom, RejectsFrameTooShortForHeaderAndPathLen) { + Packet p; + uint8_t frame[4] = {0}; + EXPECT_FALSE(feedTight(p, frame, 0)); + EXPECT_FALSE(feedTight(p, frame, 1)); +} + +TEST(PacketReadFrom, RejectsTruncatedTransportCodes) { + Packet p; + uint8_t frame[8]; + frame[0] = ROUTE_TYPE_TRANSPORT_FLOOD | (PAYLOAD_TYPE_ACK << PH_TYPE_SHIFT); + for (int i = 1; i < 8; i++) frame[i] = 0x11; + // needs header + 4 transport bytes + path_len + at least 1 payload byte + for (uint8_t len = 2; len <= 6; len++) { + EXPECT_FALSE(feedTight(p, frame, len)) << "len=" << (int)len; + } +} + +TEST(PacketReadFrom, RejectsPathOverrunningTheFrame) { + Packet p; + uint8_t frame[80]; + // declares 20 one-byte hashes but the frame carries only a few bytes of them + uint8_t full = makeFrame(frame, ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_ACK, 1, 20, 4); + for (uint8_t len = 2; len < full - 4; len++) { + EXPECT_FALSE(feedTight(p, frame, len)) << "len=" << (int)len; + } +} + +TEST(PacketReadFrom, RejectsPathWithNoRoomLeftForPayload) { + Packet p; + uint8_t frame[80]; + uint8_t full = makeFrame(frame, ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_ACK, 1, 8, 0); + EXPECT_FALSE(feedTight(p, frame, full)); // path fits exactly, payload is empty +} + +// ── control group: the guards must not reject what used to parse ───────────── + +TEST(PacketReadFrom, AcceptsWellFormedFrame) { + Packet p; + uint8_t frame[80]; + uint8_t len = makeFrame(frame, ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_ACK, 1, 3, 5); + + ASSERT_TRUE(feedTight(p, frame, len)); + EXPECT_EQ(3, p.getPathHashCount()); + EXPECT_EQ(1, p.getPathHashSize()); + EXPECT_EQ(5, p.payload_len); + EXPECT_EQ(0x40, p.payload[0]); + EXPECT_EQ(0xC0, p.path[0]); +} + +TEST(PacketReadFrom, AcceptsWellFormedFrameWithTransportCodes) { + Packet p; + uint8_t frame[80]; + uint8_t i = 0; + frame[i++] = ROUTE_TYPE_TRANSPORT_DIRECT | (PAYLOAD_TYPE_ACK << PH_TYPE_SHIFT); + frame[i++] = 0x34; frame[i++] = 0x12; // transport_codes[0] + frame[i++] = 0x78; frame[i++] = 0x56; // transport_codes[1] + frame[i++] = 0; // path_len: no hops + frame[i++] = 0x99; // one payload byte + + ASSERT_TRUE(feedTight(p, frame, i)); + EXPECT_EQ(0x1234, p.transport_codes[0]); + EXPECT_EQ(0x5678, p.transport_codes[1]); + EXPECT_EQ(1, p.payload_len); + EXPECT_EQ(0x99, p.payload[0]); +} + +TEST(PacketReadFrom, RoundTripsThroughWriteTo) { + Packet out; + out.header = ROUTE_TYPE_FLOOD | (PAYLOAD_TYPE_TXT_MSG << PH_TYPE_SHIFT); + out.setPathHashSizeAndCount(2, 3); + for (int i = 0; i < 6; i++) out.path[i] = 0xA0 + i; + out.payload_len = 10; + for (int i = 0; i < 10; i++) out.payload[i] = 0x50 + i; + + uint8_t wire[MAX_TRANS_UNIT]; + uint8_t len = out.writeTo(wire); + + Packet in; + ASSERT_TRUE(feedTight(in, wire, len)); + EXPECT_EQ(out.header, in.header); + EXPECT_EQ(out.path_len, in.path_len); + EXPECT_EQ(out.payload_len, in.payload_len); + EXPECT_EQ(0, memcmp(out.path, in.path, out.getPathByteLen())); + EXPECT_EQ(0, memcmp(out.payload, in.payload, out.payload_len)); +} + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}