feat(repeater): antispam — FairnessLimiter (port #1502) + kanálový deny list
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
1 parent
de5bd52bd9
commit
6f90c80dcc
15 files changed
+1098
-112
No files matched your search
@@ -0,0 +1,136 @@
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
// Pure helpers shared by the repeater channel modules (deny list, bot ignore
|
||||
// list). The header is self-contained on purpose so it compiles natively.
|
||||
#include "../../examples/simple_repeater/ChanListUtil.h"
|
||||
|
||||
// ── chan_list_has: exact, case-insensitive, never substring ──────────────────
|
||||
|
||||
TEST(ChanListHas, ExactMatch) {
|
||||
EXPECT_TRUE(chan_list_has("DandyPDA", "DandyPDA"));
|
||||
EXPECT_TRUE(chan_list_has("a,DandyPDA,b", "DandyPDA"));
|
||||
EXPECT_FALSE(chan_list_has("", "DandyPDA"));
|
||||
EXPECT_FALSE(chan_list_has("DandyPDA", ""));
|
||||
}
|
||||
|
||||
TEST(ChanListHas, CaseInsensitive) {
|
||||
EXPECT_TRUE(chan_list_has("dandypda", "DandyPDA"));
|
||||
EXPECT_TRUE(chan_list_has("DANDYPDA", "dandypda"));
|
||||
}
|
||||
|
||||
// "TTH" in the list must not silence "tracker" -- the trap that made the bot's
|
||||
// ignore list exact-match in the first place.
|
||||
TEST(ChanListHas, NeverSubstring) {
|
||||
EXPECT_FALSE(chan_list_has("TTH", "tracker"));
|
||||
EXPECT_FALSE(chan_list_has("tracker", "TTH"));
|
||||
}
|
||||
|
||||
TEST(ChanListHas, EntriesAreTrimmed) {
|
||||
EXPECT_TRUE(chan_list_has("a, DandyPDA ,b", "DandyPDA"));
|
||||
}
|
||||
|
||||
TEST(ChanListHas, Utf8NamesMatchByteExact) {
|
||||
EXPECT_TRUE(chan_list_has("BUBEN \xF0\x9F\xA5\x81", "BUBEN \xF0\x9F\xA5\x81"));
|
||||
EXPECT_FALSE(chan_list_has("BUBEN \xF0\x9F\xA5\x81", "BUBEN"));
|
||||
}
|
||||
|
||||
// ── chan_list_add ─────────────────────────────────────────────────────────────
|
||||
|
||||
TEST(ChanListAdd, AppendsWithComma) {
|
||||
char list[128] = "";
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "DandyPDA", 8), CHAN_LIST_OK);
|
||||
EXPECT_STREQ(list, "DandyPDA");
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "Foo", 3), CHAN_LIST_OK);
|
||||
EXPECT_STREQ(list, "DandyPDA,Foo");
|
||||
}
|
||||
|
||||
TEST(ChanListAdd, TrimsSpaces) {
|
||||
char list[128] = "";
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), " DandyPDA ", 12), CHAN_LIST_OK);
|
||||
EXPECT_STREQ(list, "DandyPDA");
|
||||
}
|
||||
|
||||
TEST(ChanListAdd, NamesMayContainSpaces) {
|
||||
char list[128] = "";
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "Dejv Bobry mobile", 17), CHAN_LIST_OK);
|
||||
EXPECT_TRUE(chan_list_has(list, "Dejv Bobry mobile"));
|
||||
}
|
||||
|
||||
TEST(ChanListAdd, RejectsBadNames) {
|
||||
char list[16] = "";
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "", 0), CHAN_LIST_BAD_NAME);
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), " ", 3), CHAN_LIST_BAD_NAME);
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "a,b", 3), CHAN_LIST_BAD_NAME);
|
||||
char longname[CHAN_NAME_MAX + 8];
|
||||
memset(longname, 'x', sizeof(longname));
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), longname, CHAN_NAME_MAX), CHAN_LIST_BAD_NAME);
|
||||
EXPECT_STREQ(list, ""); // nothing leaked in
|
||||
}
|
||||
|
||||
TEST(ChanListAdd, RejectsDuplicatesCaseInsensitively) {
|
||||
char list[128] = "DandyPDA";
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "dandypda", 8), CHAN_LIST_DUP);
|
||||
EXPECT_STREQ(list, "DandyPDA");
|
||||
}
|
||||
|
||||
TEST(ChanListAdd, RefusesWhenFull) {
|
||||
char list[12] = "0123456789"; // 10 chars used, cap 12
|
||||
EXPECT_EQ(chan_list_add(list, sizeof(list), "ab", 2), CHAN_LIST_FULL);
|
||||
EXPECT_STREQ(list, "0123456789");
|
||||
// exactly fitting entry is fine: 10 + comma + 0 chars is the edge below
|
||||
char list2[13] = "0123456789";
|
||||
EXPECT_EQ(chan_list_add(list2, sizeof(list2), "a", 1), CHAN_LIST_OK);
|
||||
EXPECT_STREQ(list2, "0123456789,a");
|
||||
}
|
||||
|
||||
// ── chan_list_del ─────────────────────────────────────────────────────────────
|
||||
|
||||
TEST(ChanListDel, RemovesMiddleEntry) {
|
||||
char list[128] = "a,DandyPDA,b";
|
||||
EXPECT_TRUE(chan_list_del(list, "DandyPDA"));
|
||||
EXPECT_STREQ(list, "a,b");
|
||||
}
|
||||
|
||||
TEST(ChanListDel, RemovesOnlyEntry) {
|
||||
char list[128] = "DandyPDA";
|
||||
EXPECT_TRUE(chan_list_del(list, "DandyPDA"));
|
||||
EXPECT_STREQ(list, "");
|
||||
}
|
||||
|
||||
TEST(ChanListDel, RemovesFirstAndLast) {
|
||||
char list[128] = "a,b,c";
|
||||
EXPECT_TRUE(chan_list_del(list, "a"));
|
||||
EXPECT_STREQ(list, "b,c");
|
||||
EXPECT_TRUE(chan_list_del(list, "c"));
|
||||
EXPECT_STREQ(list, "b");
|
||||
}
|
||||
|
||||
TEST(ChanListDel, CaseInsensitive) {
|
||||
char list[128] = "DandyPDA";
|
||||
EXPECT_TRUE(chan_list_del(list, "DANDYPDA"));
|
||||
EXPECT_STREQ(list, "");
|
||||
}
|
||||
|
||||
TEST(ChanListDel, AbsentEntryLeavesListAlone) {
|
||||
char list[128] = "a,b";
|
||||
EXPECT_FALSE(chan_list_del(list, "c"));
|
||||
EXPECT_STREQ(list, "a,b");
|
||||
}
|
||||
|
||||
// ── round trip: what add put in, has finds and del removes ───────────────────
|
||||
|
||||
TEST(ChanList, RoundTrip) {
|
||||
char list[128] = "";
|
||||
ASSERT_EQ(chan_list_add(list, sizeof(list), "DandyPDA", 8), CHAN_LIST_OK);
|
||||
ASSERT_EQ(chan_list_add(list, sizeof(list), "honzaa\xF0\x9F\x98\x9B", 10), CHAN_LIST_OK);
|
||||
EXPECT_TRUE(chan_list_has(list, "DandyPDA"));
|
||||
EXPECT_TRUE(chan_list_has(list, "honzaa\xF0\x9F\x98\x9B"));
|
||||
EXPECT_TRUE(chan_list_del(list, "DandyPDA"));
|
||||
EXPECT_FALSE(chan_list_has(list, "DandyPDA"));
|
||||
EXPECT_TRUE(chan_list_has(list, "honzaa\xF0\x9F\x98\x9B"));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -0,0 +1,147 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "helpers/FairnessLimiter.h"
|
||||
|
||||
using namespace mesh;
|
||||
|
||||
// PAYLOAD_VER_1 = 0, so a plain route|type header is already version 1.
|
||||
static Packet makePacket(uint8_t route, uint8_t type, std::initializer_list<uint8_t> payload) {
|
||||
Packet p;
|
||||
p.header = route | (type << PH_TYPE_SHIFT);
|
||||
p.payload_len = 0;
|
||||
for (uint8_t b : payload) p.payload[p.payload_len++] = b;
|
||||
p.path_len = 0;
|
||||
return p;
|
||||
}
|
||||
|
||||
// ── classification ───────────────────────────────────────────────────────────
|
||||
|
||||
TEST(FairnessLimiter, DirectIsNeverLimited) {
|
||||
FairnessLimiter fl; // zero tokens everywhere (no refill yet)
|
||||
Packet p = makePacket(ROUTE_TYPE_DIRECT, PAYLOAD_TYPE_TXT_MSG, {0x10, 0x22});
|
||||
for (int i = 0; i < 100; i++) EXPECT_TRUE(fl.allowPacket(&p));
|
||||
EXPECT_EQ(fl.deniedSenderNormal(), 0u);
|
||||
}
|
||||
|
||||
TEST(FairnessLimiter, UnclassifiedTypesAllowedThrough) {
|
||||
FairnessLimiter fl; // zero tokens: if these were classified, they'd deny
|
||||
Packet ack = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_ACK, {1, 2, 3, 4});
|
||||
EXPECT_TRUE(fl.allowPacket(&ack));
|
||||
EXPECT_EQ(fl.deniedGroup() + fl.deniedSenderNormal() + fl.deniedSenderLow(), 0u);
|
||||
}
|
||||
|
||||
TEST(FairnessLimiter, MalformedShortPayloadAllowedThrough) {
|
||||
FairnessLimiter fl;
|
||||
Packet grp = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {});
|
||||
EXPECT_TRUE(fl.allowPacket(&grp)); // no payload[0] to read
|
||||
Packet txt = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_TXT_MSG, {0x10});
|
||||
EXPECT_TRUE(fl.allowPacket(&txt)); // no payload[1] to read
|
||||
EXPECT_EQ(fl.deniedGroup() + fl.deniedSenderNormal(), 0u);
|
||||
}
|
||||
|
||||
// ── group bucket (GRP_TXT keyed by payload[0] = channel hash) ────────────────
|
||||
|
||||
TEST(FairnessLimiter, GroupBucketDrainsThenDenies) {
|
||||
FairnessLimiter fl;
|
||||
fl.refillGroup(); // 1 token per bucket
|
||||
Packet p = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0xEF, 0, 0});
|
||||
EXPECT_TRUE(fl.allowPacket(&p)); // consumes the single token
|
||||
EXPECT_FALSE(fl.allowPacket(&p)); // bucket empty
|
||||
EXPECT_EQ(fl.deniedGroup(), 1u);
|
||||
}
|
||||
|
||||
TEST(FairnessLimiter, GroupRefillRestoresOneToken) {
|
||||
FairnessLimiter fl;
|
||||
fl.refillGroup();
|
||||
Packet p = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0xEF, 0, 0});
|
||||
EXPECT_TRUE(fl.allowPacket(&p));
|
||||
EXPECT_FALSE(fl.allowPacket(&p));
|
||||
fl.refillGroup();
|
||||
EXPECT_TRUE(fl.allowPacket(&p));
|
||||
EXPECT_FALSE(fl.allowPacket(&p));
|
||||
}
|
||||
|
||||
TEST(FairnessLimiter, GroupCapBoundsTheBurst) {
|
||||
FairnessLimiter fl;
|
||||
for (int i = 0; i < 10 * FAIRNESS_GROUP_CAP; i++) fl.refillGroup();
|
||||
Packet p = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0xEF, 0, 0});
|
||||
int allowed = 0;
|
||||
for (int i = 0; i < 10 * FAIRNESS_GROUP_CAP; i++) {
|
||||
if (fl.allowPacket(&p)) allowed++;
|
||||
}
|
||||
EXPECT_EQ(allowed, FAIRNESS_GROUP_CAP);
|
||||
}
|
||||
|
||||
// The masks make collisions expected: 0xEF and 0xEF^0x20 share a 5-bit bucket,
|
||||
// while 0xEE does not. This documents the approximation, it is not a bug.
|
||||
TEST(FairnessLimiter, GroupBucketsCollideOnMask) {
|
||||
FairnessLimiter fl;
|
||||
fl.refillGroup();
|
||||
Packet a = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0xEF, 0, 0});
|
||||
Packet b = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {(uint8_t)(0xEF ^ 0x20), 0, 0});
|
||||
Packet c = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0xEE, 0, 0});
|
||||
EXPECT_TRUE(fl.allowPacket(&a));
|
||||
EXPECT_FALSE(fl.allowPacket(&b)); // same bucket as a
|
||||
EXPECT_TRUE(fl.allowPacket(&c)); // its own bucket
|
||||
}
|
||||
|
||||
// ── sender-normal bucket (TXT_MSG etc. keyed by payload[1] = 1 B src hash) ───
|
||||
|
||||
TEST(FairnessLimiter, SenderBucketKeysOnSrcHash) {
|
||||
FairnessLimiter fl;
|
||||
fl.refillSenderNormal();
|
||||
// dest 0x10 src 0x22 vs dest 0x99 src 0x22: SAME sender, same bucket
|
||||
Packet a = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_TXT_MSG, {0x10, 0x22, 0, 0});
|
||||
Packet b = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_TXT_MSG, {0x99, 0x22, 0, 0});
|
||||
EXPECT_TRUE(fl.allowPacket(&a));
|
||||
EXPECT_FALSE(fl.allowPacket(&b));
|
||||
EXPECT_EQ(fl.deniedSenderNormal(), 1u);
|
||||
}
|
||||
|
||||
TEST(FairnessLimiter, ReservedSenderHashesAlwaysDeny) {
|
||||
FairnessLimiter fl;
|
||||
for (int i = 0; i < 5; i++) fl.refillSenderNormal();
|
||||
Packet z = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_TXT_MSG, {0x10, 0x00, 0, 0});
|
||||
Packet f = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_TXT_MSG, {0x10, 0xFF, 0, 0});
|
||||
EXPECT_FALSE(fl.allowPacket(&z)); // 0x00 reserved (Identity.cpp:56)
|
||||
EXPECT_FALSE(fl.allowPacket(&f)); // 0xFF reserved
|
||||
}
|
||||
|
||||
// ── advert bucket (keyed by payload[0] = pubkey first byte) ──────────────────
|
||||
|
||||
TEST(FairnessLimiter, AdvertBucketIsSeparateFromGroupBucket) {
|
||||
FairnessLimiter fl;
|
||||
fl.refillSenderLow();
|
||||
// no group refill: a GRP_TXT with the same first byte must NOT be allowed
|
||||
// via the advert bucket, and the advert must not touch the group counter.
|
||||
Packet adv = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_ADVERT, {0x42, 0, 0});
|
||||
Packet grp = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0x42, 0, 0});
|
||||
EXPECT_TRUE(fl.allowPacket(&adv));
|
||||
EXPECT_FALSE(fl.allowPacket(&grp));
|
||||
EXPECT_EQ(fl.deniedSenderLow(), 0u);
|
||||
EXPECT_EQ(fl.deniedGroup(), 1u);
|
||||
}
|
||||
|
||||
TEST(FairnessLimiter, AdvertCapIsLow) {
|
||||
FairnessLimiter fl;
|
||||
for (int i = 0; i < 100; i++) fl.refillSenderLow();
|
||||
Packet adv = makePacket(ROUTE_TYPE_FLOOD, PAYLOAD_TYPE_ADVERT, {0x42, 0, 0});
|
||||
int allowed = 0;
|
||||
for (int i = 0; i < 100; i++) {
|
||||
if (fl.allowPacket(&adv)) allowed++;
|
||||
}
|
||||
EXPECT_EQ(allowed, FAIRNESS_SENDER_LOW_CAP);
|
||||
}
|
||||
|
||||
// ── transport-flood route is a flood too ─────────────────────────────────────
|
||||
|
||||
TEST(FairnessLimiter, TransportFloodIsLimitedLikeFlood) {
|
||||
FairnessLimiter fl; // zero tokens
|
||||
Packet p = makePacket(ROUTE_TYPE_TRANSPORT_FLOOD, PAYLOAD_TYPE_GRP_TXT, {0xEF, 0, 0});
|
||||
EXPECT_FALSE(fl.allowPacket(&p));
|
||||
EXPECT_EQ(fl.deniedGroup(), 1u);
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
Reference in new issue
Block a user