From 1171d8f97281f5edef52fb18e3e0578f36e68762 Mon Sep 17 00:00:00 2001 From: TeTeHacko Date: Wed, 18 Nov 2026 10:18:04 +0100 Subject: [PATCH] ClientACL: the replay floor survives a reboot -- a captured admin command no longer works after every boot Co-Authored-By: Claude Opus 5.5 --- examples/simple_repeater/MyMesh.cpp | 3 + examples/simple_room_server/MyMesh.cpp | 3 + examples/simple_sensor/SensorMesh.cpp | 3 + src/helpers/ClientACL.cpp | 128 +++++++++++++ src/helpers/ClientACL.h | 28 ++- test/mocks/Adafruit_LittleFS.h | 61 ++++++ test/mocks/SHA256.h | 4 + .../test_acl_replay_floor.cpp | 181 ++++++++++++++++++ 8 files changed, 410 insertions(+), 1 deletion(-) create mode 100644 test/mocks/Adafruit_LittleFS.h create mode 100644 test/test_acl_replay_floor/test_acl_replay_floor.cpp diff --git a/examples/simple_repeater/MyMesh.cpp b/examples/simple_repeater/MyMesh.cpp index d56952fd..f3d526c9 100644 --- a/examples/simple_repeater/MyMesh.cpp +++ b/examples/simple_repeater/MyMesh.cpp @@ -379,6 +379,7 @@ uint8_t MyMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t* secr MESH_DEBUG_PRINTLN("Possible login replay attack!"); return 0; // FATAL: client table is full -OR- replay attack } + acl.persistTimestamp(client, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting MESH_DEBUG_PRINTLN("Login success!"); client->last_timestamp = sender_timestamp; @@ -1122,6 +1123,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, memcpy(×tamp, data, 4); if (timestamp > client->last_timestamp) { // prevent replay attacks + acl.persistTimestamp(client, timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting int reply_len = handleRequest(client, timestamp, &data[4], len - 4); if (reply_len == 0) return; // invalid command @@ -1156,6 +1158,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, MESH_DEBUG_PRINTLN("onPeerDataRecv: unsupported text type received: flags=%02x", (uint32_t)flags); } else if (sender_timestamp >= client->last_timestamp) { // prevent replay attacks bool is_retry = (sender_timestamp == client->last_timestamp); + acl.persistTimestamp(client, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting client->last_timestamp = sender_timestamp; client->last_activity = getRTCClock()->getCurrentTime(); diff --git a/examples/simple_room_server/MyMesh.cpp b/examples/simple_room_server/MyMesh.cpp index fc63a4fe..e0f349a2 100644 --- a/examples/simple_room_server/MyMesh.cpp +++ b/examples/simple_room_server/MyMesh.cpp @@ -372,6 +372,7 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m MESH_DEBUG_PRINTLN("possible replay attack!"); return; } + acl.persistTimestamp(client, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting MESH_DEBUG_PRINTLN("Login success!"); client->last_timestamp = sender_timestamp; @@ -459,6 +460,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, MESH_DEBUG_PRINTLN("onPeerDataRecv: unsupported command flags received: flags=%02x", (uint32_t)flags); } else if (sender_timestamp >= client->last_timestamp) { // prevent replay attacks, but send Acks for retries bool is_retry = (sender_timestamp == client->last_timestamp); + acl.persistTimestamp(client, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting client->last_timestamp = sender_timestamp; uint32_t now = getRTCClock()->getCurrentTimeUnique(); @@ -554,6 +556,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, if (sender_timestamp < client->last_timestamp) { // prevent replay attacks MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected"); } else { + acl.persistTimestamp(client, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting client->last_timestamp = sender_timestamp; uint32_t now = getRTCClock()->getCurrentTime(); diff --git a/examples/simple_sensor/SensorMesh.cpp b/examples/simple_sensor/SensorMesh.cpp index a7dd69a5..73107f1a 100644 --- a/examples/simple_sensor/SensorMesh.cpp +++ b/examples/simple_sensor/SensorMesh.cpp @@ -387,6 +387,7 @@ uint8_t SensorMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t* MESH_DEBUG_PRINTLN("Possible login replay attack!"); return 0; // FATAL: client table is full -OR- replay attack } + acl.persistTimestamp(client, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting MESH_DEBUG_PRINTLN("Login success!"); client->last_timestamp = sender_timestamp; @@ -619,6 +620,7 @@ void SensorMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_i memcpy(×tamp, data, 4); if (timestamp > from->last_timestamp) { // prevent replay attacks + acl.persistTimestamp(from, timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting uint8_t reply_len = handleRequest(from, timestamp, data[4], &data[5], len - 5); if (reply_len == 0) return; // invalid command @@ -649,6 +651,7 @@ void SensorMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_i uint8_t flags = (data[4] >> 2); // message attempt number, and other flags if (sender_timestamp > from->last_timestamp) { // prevent replay attacks + acl.persistTimestamp(from, sender_timestamp, getRTCClock()->getCurrentTime()); // CUSTOM (TeTeHacko): before acting if (flags == TXT_TYPE_PLAIN) { bool handled = handleIncomingMsg(*from, sender_timestamp, &data[5], flags, len - 5); if (handled) { // if msg was handled then send an ack diff --git a/src/helpers/ClientACL.cpp b/src/helpers/ClientACL.cpp index 12823827..13b59677 100644 --- a/src/helpers/ClientACL.cpp +++ b/src/helpers/ClientACL.cpp @@ -50,6 +50,120 @@ void ClientACL::load(FILESYSTEM* fs, const mesh::LocalIdentity& self_id) { file.close(); } } + loadTimestamps(); +} + +// CUSTOM (TeTeHacko): /s_acl_ts0 and /s_acl_ts1 are written alternately, each +// {pubkey prefix 8, timestamp 4} * n + seq 4 + sha256 tag 4. A write torn by a +// power cut leaves the other slot intact, and the floor is the max over both +// valid slots, so it can only ever move forward. The next write always goes over +// the OLDER slot (lower seq) -- and a torn write means the command it guarded +// never ran, so nothing executed is lost. +#define ACL_TS_PREFIX 8 +#define ACL_TS_RECORD (ACL_TS_PREFIX + 4) + +static const char* tsFilename(uint8_t slot) { return slot ? "/s_acl_ts1" : "/s_acl_ts0"; } + +void ClientACL::loadTimestamps() { + static uint8_t buf[2 * MAX_CLIENTS * ACL_TS_RECORD + 8]; + _num_ts_orphans = 0; + _ts_seq = 0; + _ts_slot = 0; + bool have_newest = false; + for (uint8_t slot = 0; slot < 2; slot++) { + if (!_fs->exists(tsFilename(slot))) continue; + #if defined(RP2040_PLATFORM) + File file = _fs->open(tsFilename(slot), "r"); + #else + File file = _fs->open(tsFilename(slot)); + #endif + if (!file) continue; + int len = file.read(buf, sizeof(buf)); + file.close(); + if (len < 8 || (len - 8) % ACL_TS_RECORD != 0) continue; + + uint8_t tag[4]; + mesh::Utils::sha256(tag, 4, buf, len - 4); + if (memcmp(tag, &buf[len - 4], 4) != 0) continue; // torn write: ignore this slot + uint32_t seq; + memcpy(&seq, &buf[len - 8], 4); + if (!have_newest || seq > _ts_seq) { + _ts_seq = seq; + _ts_slot = slot ^ 1; // next write goes over the other, older slot + have_newest = true; + } + + for (int ofs = 0; ofs < len - 8; ofs += ACL_TS_RECORD) { + uint32_t ts; + memcpy(&ts, &buf[ofs + ACL_TS_PREFIX], 4); + ClientInfo* c = getClient(&buf[ofs], ACL_TS_PREFIX); + if (c) { + if (ts > c->saved_timestamp) c->saved_timestamp = ts; + continue; + } + // Not in /s_contacts: a fresh login whose lazy ACL write a reboot beat, or an + // evicted guest. Keep the floor, or replaying their login would re-admit them. + int j = 0; + while (j < _num_ts_orphans && memcmp(_ts_orphans[j].prefix, &buf[ofs], ACL_TS_PREFIX) != 0) j++; + if (j == _num_ts_orphans) { + if (j == MAX_CLIENTS) continue; + memcpy(_ts_orphans[j].prefix, &buf[ofs], ACL_TS_PREFIX); + _ts_orphans[j].ts = 0; + _num_ts_orphans++; + } + if (ts > _ts_orphans[j].ts) _ts_orphans[j].ts = ts; + } + } + for (int i = 0; i < num_clients; i++) { + clients[i].last_timestamp = clients[i].saved_timestamp; + } +} + +void ClientACL::saveTimestamps() { + if (!_fs) return; + static uint8_t buf[2 * MAX_CLIENTS * ACL_TS_RECORD + 8]; + int len = 0; + for (int i = 0; i < num_clients; i++) { + if (clients[i].saved_timestamp == 0) continue; + memcpy(&buf[len], clients[i].id.pub_key, ACL_TS_PREFIX); + memcpy(&buf[len + ACL_TS_PREFIX], &clients[i].saved_timestamp, 4); + len += ACL_TS_RECORD; + } + for (int i = 0; i < _num_ts_orphans; i++) { + memcpy(&buf[len], _ts_orphans[i].prefix, ACL_TS_PREFIX); + memcpy(&buf[len + ACL_TS_PREFIX], &_ts_orphans[i].ts, 4); + len += ACL_TS_RECORD; + } + _ts_seq++; + memcpy(&buf[len], &_ts_seq, 4); + len += 4; + mesh::Utils::sha256(&buf[len], 4, buf, len); + len += 4; + + File file = openWrite(_fs, tsFilename(_ts_slot)); + if (file) { + file.write(buf, len); + file.close(); + } + _ts_slot ^= 1; +} + +void ClientACL::orphanTimestamp(const ClientInfo* c) { + if (c->saved_timestamp == 0) return; + if (_num_ts_orphans == MAX_CLIENTS) { // full: drop the oldest + memmove(&_ts_orphans[0], &_ts_orphans[1], (MAX_CLIENTS - 1) * sizeof(TsOrphan)); + _num_ts_orphans--; + } + memcpy(_ts_orphans[_num_ts_orphans].prefix, c->id.pub_key, ACL_TS_PREFIX); + _ts_orphans[_num_ts_orphans].ts = c->saved_timestamp; + _num_ts_orphans++; +} + +void ClientACL::persistTimestamp(ClientInfo* c, uint32_t sender_timestamp, uint32_t now) { + if (sender_timestamp <= c->saved_timestamp) return; // retry, or nothing new + if (sender_timestamp > now + ACL_TS_MAX_AHEAD) return; // runaway sender clock + c->saved_timestamp = sender_timestamp; + saveTimestamps(); } void ClientACL::save(FILESYSTEM* fs, bool (*filter)(ClientInfo*)) { @@ -82,8 +196,12 @@ bool ClientACL::clear() { if (_fs->exists("/s_contacts")) { _fs->remove("/s_contacts"); } + // The replay floors outlive the ACL: with them gone, a captured password login + // would be accepted again. + for (int i = 0; i < num_clients; i++) orphanTimestamp(&clients[i]); memset(clients, 0, sizeof(clients)); num_clients = 0; + saveTimestamps(); return true; } @@ -110,11 +228,20 @@ ClientInfo* ClientACL::putClient(const mesh::Identity& id, uint8_t init_perms) { c = &clients[num_clients++]; } else { c = oldest; // evict least active contact + orphanTimestamp(c); } memset(c, 0, sizeof(*c)); c->permissions = init_perms; c->id = id; c->out_path_len = OUT_PATH_UNKNOWN; + for (int i = 0; i < _num_ts_orphans; i++) { // known before: its replay floor comes back + if (memcmp(_ts_orphans[i].prefix, id.pub_key, ACL_TS_PREFIX) == 0) { + c->saved_timestamp = c->last_timestamp = _ts_orphans[i].ts; + _num_ts_orphans--; + memmove(&_ts_orphans[i], &_ts_orphans[i + 1], (_num_ts_orphans - i) * sizeof(TsOrphan)); + break; + } + } return c; } @@ -124,6 +251,7 @@ bool ClientACL::applyPermissions(const mesh::LocalIdentity& self_id, const uint8 c = getClient(pubkey, key_len); if (c == NULL) return false; // partial pubkey not found + orphanTimestamp(c); num_clients--; // delete from contacts[] int i = c - clients; while (i < num_clients) { diff --git a/src/helpers/ClientACL.h b/src/helpers/ClientACL.h index 9938bc1e..f7726efb 100644 --- a/src/helpers/ClientACL.h +++ b/src/helpers/ClientACL.h @@ -18,7 +18,8 @@ struct ClientInfo { uint8_t out_path_len; uint8_t out_path[MAX_PATH_SIZE]; uint8_t shared_secret[PUB_KEY_SIZE]; - uint32_t last_timestamp; // by THEIR clock (transient) + uint32_t last_timestamp; // by THEIR clock (restored from /s_acl_ts* on boot) + uint32_t saved_timestamp; // last_timestamp as last written to /s_acl_ts* uint32_t last_activity; // by OUR clock (transient) union { struct { @@ -45,20 +46,45 @@ struct ClientInfo { #define MAX_CLIENTS 32 #endif +// CUSTOM (TeTeHacko): a timestamp further ahead of our clock than this is accepted +// but not persisted, so a companion with a runaway RTC cannot lock its admin out +// across reboots. +#ifndef ACL_TS_MAX_AHEAD + #define ACL_TS_MAX_AHEAD (24 * 3600) +#endif + class ClientACL { FILESYSTEM* _fs; ClientInfo clients[MAX_CLIENTS]; int num_clients; + uint8_t _ts_slot; + uint32_t _ts_seq; + struct TsOrphan { uint8_t prefix[8]; uint32_t ts; }; + TsOrphan _ts_orphans[MAX_CLIENTS]; // floors of clients not (or no longer) in clients[] + int _num_ts_orphans; + + void loadTimestamps(); + void saveTimestamps(); + void orphanTimestamp(const ClientInfo* c); public: ClientACL() { memset(clients, 0, sizeof(clients)); num_clients = 0; + _ts_slot = 0; + _ts_seq = 0; + _num_ts_orphans = 0; } void load(FILESYSTEM* _fs, const mesh::LocalIdentity& self_id); void save(FILESYSTEM* _fs, bool (*filter)(ClientInfo*)=NULL); bool clear(); + // CUSTOM (TeTeHacko): replay protection that survives a reboot. last_timestamp + // used to live only in RAM, so after any reboot a captured command (a `reboot` + // among them) was accepted again -- forever. Call this BEFORE acting on an + // authenticated packet; it writes the new high-water mark synchronously. + void persistTimestamp(ClientInfo* c, uint32_t sender_timestamp, uint32_t now); + ClientInfo* getClient(const uint8_t* pubkey, int key_len); ClientInfo* putClient(const mesh::Identity& id, uint8_t init_perms); bool applyPermissions(const mesh::LocalIdentity& self_id, const uint8_t* pubkey, int key_len, uint8_t perms); diff --git a/test/mocks/Adafruit_LittleFS.h b/test/mocks/Adafruit_LittleFS.h new file mode 100644 index 00000000..e4a2dd47 --- /dev/null +++ b/test/mocks/Adafruit_LittleFS.h @@ -0,0 +1,61 @@ +#pragma once + +// In-memory stand-in for the nRF52 LittleFS, enough for ClientACL: whole-file +// write, read, exists, remove. Tests reach into `files` to tear or drop a write. + +#include +#include +#include +#include + +#define FILE_O_READ 0 +#define FILE_O_WRITE 1 + +namespace Adafruit_LittleFS_Namespace { + +class File { + std::map* _files = nullptr; + std::string _name; + size_t _pos = 0; + bool _write = false; + +public: + File() = default; + File(std::map* files, const std::string& name, bool write) + : _files(files), _name(name), _write(write) { + if (write) (*_files)[name] = ""; + } + explicit operator bool() const { return _files != nullptr; } + int read(uint8_t* buf, size_t len) { + const std::string& d = (*_files)[_name]; + size_t n = std::min(len, d.size() - std::min(_pos, d.size())); + std::memcpy(buf, d.data() + _pos, n); + _pos += n; + return (int)n; + } + size_t write(const uint8_t* buf, size_t len) { + (*_files)[_name].append((const char*)buf, len); + return len; + } + void close() {} +}; + +} // namespace Adafruit_LittleFS_Namespace + +class Adafruit_LittleFS { +public: + std::map files; + int writes = 0; + + bool exists(const char* name) { return files.count(name) > 0; } + bool remove(const char* name) { return files.erase(name) > 0; } + bool mkdir(const char*) { return true; } + Adafruit_LittleFS_Namespace::File open(const char* name, uint8_t mode = FILE_O_READ) { + if (mode == FILE_O_WRITE) { + writes++; + return Adafruit_LittleFS_Namespace::File(&files, name, true); + } + if (!exists(name)) return Adafruit_LittleFS_Namespace::File(); + return Adafruit_LittleFS_Namespace::File(&files, name, false); + } +}; diff --git a/test/mocks/SHA256.h b/test/mocks/SHA256.h index 0cefe5c6..96c7e8ff 100644 --- a/test/mocks/SHA256.h +++ b/test/mocks/SHA256.h @@ -28,6 +28,10 @@ public: for (size_t i = 0; i < hashLen; i++) { hash[i] = _state[i % 32]; } + // A short digest (4-byte checksum tags) must still depend on every byte. + for (size_t i = hashLen; i < 32 && hashLen > 0; i++) { + hash[i % hashLen] ^= _state[i]; + } } void resetHMAC(const uint8_t* key, size_t keyLen) {} diff --git a/test/test_acl_replay_floor/test_acl_replay_floor.cpp b/test/test_acl_replay_floor/test_acl_replay_floor.cpp new file mode 100644 index 00000000..dffd5c35 --- /dev/null +++ b/test/test_acl_replay_floor/test_acl_replay_floor.cpp @@ -0,0 +1,181 @@ +// The replay floor (ClientACL::persistTimestamp) must survive a reboot, a torn +// write, an ACL write the reboot beat, and an ACL wipe -- otherwise a captured +// admin command (a `reboot` among them) is accepted again after every boot. + +#include + +#define NRF52_PLATFORM 1 +#ifndef MAX_PATH_SIZE + #define MAX_PATH_SIZE 64 +#endif +#include "../../src/helpers/ClientACL.cpp" + +// src/Identity.cpp needs ed25519; ClientACL only stores keys and asks for a secret. +mesh::Identity::Identity() { memset(pub_key, 0, sizeof(pub_key)); } +mesh::LocalIdentity::LocalIdentity() { memset(prv_key, 0, sizeof(prv_key)); } +void mesh::LocalIdentity::calcSharedSecret(uint8_t* secret, const uint8_t*) const { memset(secret, 0x11, PUB_KEY_SIZE); } + +namespace { + +const uint32_t NOW = 1763400000; // 2025-11-17 + +mesh::Identity idFor(uint8_t n) { + uint8_t key[PUB_KEY_SIZE]; + memset(key, n, sizeof(key)); + return mesh::Identity(key); +} + +struct Node { + Adafruit_LittleFS fs; + mesh::LocalIdentity self; + ClientACL* acl = nullptr; + + Node() { boot(); } + ~Node() { delete acl; } + + void boot() { // a reboot: RAM gone, flash kept + delete acl; + acl = new ClientACL(); + acl->load(&fs, self); + } + ClientInfo* admin(uint8_t n) { + ClientInfo* c = acl->putClient(idFor(n), 0); + c->permissions = PERM_ACL_ADMIN; + return c; + } + // What the repeater does on an authenticated CLI packet. + bool accept(ClientInfo* c, uint32_t ts) { + if (ts <= c->last_timestamp) return false; + acl->persistTimestamp(c, ts, NOW); + c->last_timestamp = ts; + return true; + } +}; + +} // namespace + +TEST(AclReplayFloor, CapturedCommandIsRejectedAfterReboot) { + Node n; + ClientInfo* c = n.admin(1); + ASSERT_TRUE(n.accept(c, NOW - 10)); // the captured `reboot` + n.acl->save(&n.fs); + n.boot(); + + ClientInfo* again = n.acl->getClient(idFor(1).pub_key, PUB_KEY_SIZE); + ASSERT_NE(again, nullptr); + EXPECT_FALSE(n.accept(again, NOW - 10)); // the replay + EXPECT_TRUE(n.accept(again, NOW - 5)); // the admin's next command +} + +TEST(AclReplayFloor, RetryWritesNothing) { + Node n; + ClientInfo* c = n.admin(1); + n.acl->persistTimestamp(c, NOW, NOW); + int writes = n.fs.writes; + n.acl->persistTimestamp(c, NOW, NOW); + n.acl->persistTimestamp(c, NOW - 1, NOW); + EXPECT_EQ(n.fs.writes, writes); +} + +TEST(AclReplayFloor, RunawayClockIsNotPersisted) { + Node n; + ClientInfo* c = n.admin(1); + ASSERT_TRUE(n.accept(c, NOW + 30 * 86400)); // accepted in this session, as upstream + n.acl->save(&n.fs); + n.boot(); + // ...but it does not lock the admin with a correct clock out after a reboot. + ClientInfo* again = n.acl->getClient(idFor(1).pub_key, PUB_KEY_SIZE); + EXPECT_TRUE(n.accept(again, NOW)); +} + +TEST(AclReplayFloor, LoginTheLazyAclWriteMissedKeepsItsFloor) { + Node n; + ClientInfo* c = n.admin(2); + ASSERT_TRUE(n.accept(c, NOW - 100)); // password login... + n.boot(); // ...and a reboot before acl.save() + EXPECT_EQ(n.acl->getClient(idFor(2).pub_key, PUB_KEY_SIZE), nullptr); + + // The replayed login re-adds the client: its floor must come back with it. + ClientInfo* replay = n.acl->putClient(idFor(2), 0); + EXPECT_FALSE(n.accept(replay, NOW - 100)); +} + +TEST(AclReplayFloor, FloorsOutliveAclClear) { + Node n; + ASSERT_TRUE(n.accept(n.admin(3), NOW - 50)); + n.acl->save(&n.fs); + n.acl->clear(); + n.boot(); + EXPECT_FALSE(n.accept(n.acl->putClient(idFor(3), 0), NOW - 50)); +} + +TEST(AclReplayFloor, EvictedClientKeepsItsFloor) { + Node n; + ClientInfo* g = n.acl->putClient(idFor(4), 0); + g->last_activity = 1; // least active -> evicted first + ASSERT_TRUE(n.accept(g, NOW - 70)); + for (int i = 0; i < MAX_CLIENTS; i++) { + ClientInfo* c = n.acl->putClient(idFor(100 + i), 0); + c->last_activity = 1000 + i; + } + ASSERT_EQ(n.acl->getClient(idFor(4).pub_key, PUB_KEY_SIZE), nullptr); + EXPECT_FALSE(n.accept(n.acl->putClient(idFor(4), 0), NOW - 70)); +} + +TEST(AclReplayFloor, TornWriteFallsBackToTheOtherSlot) { + Node n; + ClientInfo* c = n.admin(1); + ASSERT_TRUE(n.accept(c, NOW - 30)); + ASSERT_TRUE(n.accept(c, NOW - 20)); + n.acl->save(&n.fs); + n.boot(); + + // The next write must go over the OLDER slot; tear it halfway. + std::map before = n.fs.files; + c = n.acl->getClient(idFor(1).pub_key, PUB_KEY_SIZE); + n.acl->persistTimestamp(c, NOW - 10, NOW); + std::string written; + for (auto& f : n.fs.files) { + if (f.first.rfind("/s_acl_ts", 0) == 0 && before[f.first] != f.second) written = f.first; + } + ASSERT_FALSE(written.empty()); + n.fs.files[written].resize(n.fs.files[written].size() / 2); + n.boot(); + + // The newest COMPLETE write (NOW - 20) holds: the torn one guarded a command + // that never ran. + c = n.acl->getClient(idFor(1).pub_key, PUB_KEY_SIZE); + EXPECT_EQ(c->last_timestamp, NOW - 20); +} + +TEST(AclReplayFloor, CorruptedSlotIsIgnored) { + Node n; + ClientInfo* c = n.admin(1); + ASSERT_TRUE(n.accept(c, NOW - 30)); + ASSERT_TRUE(n.accept(c, NOW - 20)); + n.acl->save(&n.fs); + for (auto& f : n.fs.files) { + if (f.first.rfind("/s_acl_ts", 0) == 0) f.second[9] ^= 0x01; // flip one bit in the timestamp + } + n.boot(); + c = n.acl->getClient(idFor(1).pub_key, PUB_KEY_SIZE); + EXPECT_EQ(c->last_timestamp, 0u); // both slots garbage -> no floor, but no garbage floor either +} + +TEST(AclReplayFloor, AlternatesSlotsAcrossReboots) { + Node n; + ClientInfo* c = n.admin(1); + uint32_t ts = NOW - 1000; + for (int boot = 0; boot < 5; boot++) { + for (int k = 0; k < 3; k++) ASSERT_TRUE(n.accept(c, ++ts)); + n.acl->save(&n.fs); + n.boot(); + c = n.acl->getClient(idFor(1).pub_key, PUB_KEY_SIZE); + ASSERT_EQ(c->last_timestamp, ts) << "boot " << boot; + } +} + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}