Files
meshcore-tth/src/Packet.cpp
T
2026-09-01 20:12:01 +02:00

108 lines
3.7 KiB
C++

#include "Packet.h"
#include <string.h>
#include <SHA256.h>
namespace mesh {
Packet::Packet() {
header = 0;
path_len = 0;
payload_len = 0;
}
bool Packet::isValidPathLen(uint8_t path_len) {
uint8_t hash_count = path_len & 63;
uint8_t hash_size = (path_len >> 6) + 1;
if (hash_size == 4) return false; // Reserved for future
return hash_count*hash_size <= MAX_PATH_SIZE;
}
size_t Packet::writePath(uint8_t* dest, const uint8_t* src, uint8_t path_len) {
uint8_t hash_count = path_len & 63;
uint8_t hash_size = (path_len >> 6) + 1;
size_t len = hash_count*hash_size;
if (len > MAX_PATH_SIZE) {
MESH_DEBUG_PRINTLN("Packet::copyPath, invalid path_len=%d", (uint32_t)path_len);
return 0; // Error
}
memcpy(dest, src, len);
return len;
}
uint8_t Packet::copyPath(uint8_t* dest, const uint8_t* src, uint8_t path_len) {
writePath(dest, src, path_len);
return path_len;
}
int Packet::getRawLength() const {
return 2 + getPathByteLen() + payload_len + (hasTransportCodes() ? 4 : 0);
}
void Packet::calculatePacketHash(uint8_t* hash) const {
SHA256 sha;
uint8_t t = getPayloadType();
sha.update(&t, 1);
if (t == PAYLOAD_TYPE_TRACE) {
sha.update(&path_len, sizeof(path_len)); // CAVEAT: TRACE packets can revisit same node on return path
}
sha.update(payload, payload_len);
sha.finalize(hash, MAX_HASH_SIZE);
}
uint8_t Packet::writeTo(uint8_t dest[]) const {
uint8_t i = 0;
dest[i++] = header;
if (hasTransportCodes()) {
memcpy(&dest[i], &transport_codes[0], 2); i += 2;
memcpy(&dest[i], &transport_codes[1], 2); i += 2;
}
dest[i++] = path_len;
i += writePath(&dest[i], path, path_len);
memcpy(&dest[i], payload, payload_len); i += payload_len;
return i;
}
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 {
transport_codes[0] = transport_codes[1] = 0;
}
path_len = src[i++];
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;
payload_len = len - i;
if (payload_len > sizeof(payload)) return false; // bad encoding
memcpy(payload, &src[i], payload_len); //i += payload_len;
return true; // success
}
}