Warn admins on login while the default password is unchanged
This commit is contained in:
1 parent
25f3546c07
commit
98c2858087
11 files changed
+348
-18
No files matched your search
@@ -2532,6 +2532,10 @@ Older Companion firmware is not a safe transport for this backup flow.
|
||||
|
||||
**Default:** `password`
|
||||
|
||||
Repeaters and room servers send `CHANGE YOUR PASSWORD` as a separate CLI reply
|
||||
after a successful admin radio login while the saved password still matches
|
||||
the build's `ADMIN_PASSWORD`. Saving a different password stops the warning.
|
||||
|
||||
`get password` returns the current admin password only on a local connection:
|
||||
USB, Ethernet, or the authenticated LAN browser CLI. It is rejected over LoRa.
|
||||
ESP32 WiFi Companion instead reports management-password status without revealing
|
||||
|
||||
@@ -272,6 +272,8 @@ You can get the latitude and longitude from Google Maps by right-clicking the lo
|
||||
|
||||
`password {new-password}`
|
||||
|
||||
Repeaters and rooms send `CHANGE YOUR PASSWORD` to admins on login while the
|
||||
admin password still matches the firmware default.
|
||||
|
||||
### 3.4. Q: What is the password to join a room server?
|
||||
**A:** The default guest password to a room server is `hello`. Use the following command to change the guest password:
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#include "MyMesh.h"
|
||||
#include <helpers/DefaultPasswordWarning.h>
|
||||
#if defined(HELTEC_V4_R8_TFT) && defined(HELTEC_TFT_RUNTIME_ROTATION) \
|
||||
&& HELTEC_TFT_RUNTIME_ROTATION == 1
|
||||
#include <helpers/ui/DisplayRotationSettings.h>
|
||||
@@ -658,6 +659,29 @@ uint8_t MyMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t* secr
|
||||
return 13; // reply length
|
||||
}
|
||||
|
||||
void MyMesh::sendDefaultPasswordWarning(ClientInfo* client,
|
||||
uint32_t sender_timestamp,
|
||||
uint8_t path_hash_size) {
|
||||
if (client == NULL || !client->isAdmin()
|
||||
|| !mesh::defaultAdminPasswordUnchanged(
|
||||
_prefs.password, ADMIN_PASSWORD, sizeof(_prefs.password))) return;
|
||||
uint8_t data[5 + sizeof(mesh::DEFAULT_PASSWORD_LOGIN_WARNING) - 1];
|
||||
uint32_t timestamp = getRTCClock()->getCurrentTimeUnique();
|
||||
if (timestamp == sender_timestamp) timestamp++;
|
||||
memcpy(data, ×tamp, 4);
|
||||
data[4] = TXT_TYPE_CLI_DATA << 2;
|
||||
memcpy(data + 5, mesh::DEFAULT_PASSWORD_LOGIN_WARNING, sizeof(data) - 5);
|
||||
mesh::Packet* warning = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id,
|
||||
client->shared_secret, data, sizeof(data));
|
||||
if (warning == NULL) return;
|
||||
warning->radio_reply = true;
|
||||
if (mesh::Packet::isValidPathLen(client->out_path_len)) {
|
||||
sendClientReply(client, warning, SERVER_RESPONSE_DELAY + 2000UL, path_hash_size);
|
||||
} else {
|
||||
sendFloodReply(warning, SERVER_RESPONSE_DELAY + 2000UL, path_hash_size);
|
||||
}
|
||||
}
|
||||
|
||||
// Comparison functions for qsort() - defined at file scope to avoid heap allocations
|
||||
static int cmp_neighbours_newest_to_oldest(const void* a, const void* b) {
|
||||
const NeighbourInfo* na = *(const NeighbourInfo**)a;
|
||||
@@ -2781,6 +2805,7 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
|
||||
memcpy(×tamp, data, 4);
|
||||
|
||||
data[len] = 0; // ensure null terminator
|
||||
const bool login_request = data[4] == 0 || data[4] >= ' ';
|
||||
uint8_t reply_len;
|
||||
|
||||
reply_path_len = 0xFF;
|
||||
@@ -2816,6 +2841,8 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
|
||||
*client, OUT_PATH_UNKNOWN,
|
||||
futureMillis(LOGIN_PATH_OBSERVATION_TIMEOUT_MS));
|
||||
}
|
||||
if (login_request && login_path_sent)
|
||||
sendDefaultPasswordWarning(client, timestamp, packet->getPathHashSize());
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -2823,13 +2850,16 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
|
||||
mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len);
|
||||
if (reply == NULL) return;
|
||||
|
||||
bool reply_queued;
|
||||
if (route == mesh::REPLY_ROUTE_DIRECT_SUPPLIED) {
|
||||
sendDirect(reply, reply_path, reply_path_len, SERVER_RESPONSE_DELAY);
|
||||
reply_queued = sendDirect(reply, reply_path, reply_path_len, SERVER_RESPONSE_DELAY);
|
||||
} else if (route == mesh::REPLY_ROUTE_DIRECT_OUT_PATH) {
|
||||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
|
||||
reply_queued = sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
|
||||
} else {
|
||||
sendFloodReply(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
|
||||
reply_queued = sendFloodReply(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
|
||||
}
|
||||
if (login_request && reply_queued)
|
||||
sendDefaultPasswordWarning(client, timestamp, packet->getPathHashSize());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -851,6 +851,8 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks
|
||||
void putNeighbour(const mesh::Identity& id, uint32_t timestamp, float snr,
|
||||
int16_t rssi);
|
||||
uint8_t handleLoginReq(const mesh::Identity& sender, const uint8_t* secret, uint32_t sender_timestamp, const uint8_t* data, bool is_flood);
|
||||
void sendDefaultPasswordWarning(ClientInfo* client, uint32_t sender_timestamp,
|
||||
uint8_t path_hash_size);
|
||||
uint8_t handleAnonRegionsReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data, size_t data_len);
|
||||
uint8_t handleAnonOwnerReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data, size_t data_len);
|
||||
uint8_t handleAnonClockReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data, size_t data_len);
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#include "MyMesh.h"
|
||||
#include <helpers/DefaultPasswordWarning.h>
|
||||
#if defined(HELTEC_V4_R8_TFT) && defined(HELTEC_TFT_RUNTIME_ROTATION) \
|
||||
&& HELTEC_TFT_RUNTIME_ROTATION == 1
|
||||
#include <helpers/ui/DisplayRotationSettings.h>
|
||||
@@ -1836,6 +1837,25 @@ mesh::DispatcherAction MyMesh::onRecvPacket(mesh::Packet* pkt) {
|
||||
return action;
|
||||
}
|
||||
|
||||
void MyMesh::sendDefaultPasswordWarning(ClientInfo* client,
|
||||
uint32_t sender_timestamp,
|
||||
uint8_t path_hash_size) {
|
||||
if (client == NULL || !client->isAdmin()
|
||||
|| !mesh::defaultAdminPasswordUnchanged(
|
||||
_prefs.password, ADMIN_PASSWORD, sizeof(_prefs.password))) return;
|
||||
uint8_t data[5 + sizeof(mesh::DEFAULT_PASSWORD_LOGIN_WARNING) - 1];
|
||||
uint32_t timestamp = getRTCClock()->getCurrentTimeUnique();
|
||||
if (timestamp == sender_timestamp) timestamp++;
|
||||
memcpy(data, ×tamp, 4);
|
||||
data[4] = TXT_TYPE_CLI_DATA << 2;
|
||||
memcpy(data + 5, mesh::DEFAULT_PASSWORD_LOGIN_WARNING, sizeof(data) - 5);
|
||||
mesh::Packet* warning = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id,
|
||||
client->shared_secret, data, sizeof(data));
|
||||
if (warning == NULL) return;
|
||||
warning->radio_reply = true;
|
||||
sendClientReply(client, warning, SERVER_RESPONSE_DELAY + 2000UL, path_hash_size);
|
||||
}
|
||||
|
||||
void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const mesh::Identity &sender,
|
||||
uint8_t *data, size_t len) {
|
||||
if (!room_access.allowsIdentity(sender.pub_key)) return;
|
||||
@@ -1934,23 +1954,27 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
|
||||
|
||||
next_push = futureMillis(PUSH_NOTIFY_DELAY_MILLIS); // delay next push, give RESPONSE packet time to arrive first
|
||||
|
||||
bool login_reply_queued = false;
|
||||
if (packet->isRouteFlood()) {
|
||||
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
|
||||
mesh::Packet *path = createPathReturn(sender, client->shared_secret, packet->path, packet->path_len,
|
||||
PAYLOAD_TYPE_RESPONSE, reply_data, 13);
|
||||
if (path && sendFloodReply(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize())) {
|
||||
if (path && (login_reply_queued = sendFloodReply(
|
||||
path, SERVER_RESPONSE_DELAY, packet->getPathHashSize()))) {
|
||||
mesh::beginObservedClientPath(*client, OUT_PATH_UNKNOWN, futureMillis(60000));
|
||||
}
|
||||
} else {
|
||||
mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->shared_secret, reply_data, 13);
|
||||
if (reply) {
|
||||
if (mesh::Packet::isValidPathLen(client->out_path_len)) { // we have an out_path, so send DIRECT
|
||||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
|
||||
login_reply_queued = sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
|
||||
} else {
|
||||
sendFloodReply(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
|
||||
login_reply_queued = sendFloodReply(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
|
||||
}
|
||||
}
|
||||
}
|
||||
if (login_reply_queued)
|
||||
sendDefaultPasswordWarning(client, sender_timestamp, packet->getPathHashSize());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -462,6 +462,8 @@ protected:
|
||||
bool allowPacketForward(const mesh::Packet* packet) override;
|
||||
bool allowPacketTransmit(const mesh::Packet* packet) const override;
|
||||
void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len) override;
|
||||
void sendDefaultPasswordWarning(ClientInfo* client, uint32_t sender_timestamp,
|
||||
uint8_t path_hash_size);
|
||||
int searchPeersByHash(const uint8_t* hash) override ;
|
||||
void getPeerSharedSecret(uint8_t* dest_secret, int peer_idx) override;
|
||||
void onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_idx, const uint8_t* secret, uint8_t* data, size_t len) override;
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
namespace mesh {
|
||||
|
||||
static constexpr char DEFAULT_PASSWORD_LOGIN_WARNING[] = "CHANGE YOUR PASSWORD";
|
||||
|
||||
inline bool defaultAdminPasswordUnchanged(const char* password,
|
||||
const char* factory_password,
|
||||
size_t capacity) {
|
||||
// Match the same bounded value stored when the role initializes its prefs.
|
||||
return password && factory_password && capacity > 1 && password[0]
|
||||
&& factory_password[0]
|
||||
&& strncmp(password, factory_password, capacity - 1) == 0;
|
||||
}
|
||||
|
||||
} // namespace mesh
|
||||
@@ -68,6 +68,8 @@ struct MyMesh {
|
||||
uint8_t handleAnonOwnerReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t);
|
||||
uint8_t handleAnonClockReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t);
|
||||
void onAnonDataRecv(mesh::Packet*, const uint8_t*, const mesh::Identity&, uint8_t*, size_t);
|
||||
// Warning authorization/transport is exercised by the full login suites.
|
||||
void sendDefaultPasswordWarning(ClientInfo*, uint32_t, uint8_t) {}
|
||||
uint8_t handleLoginReq(const mesh::Identity&, const uint8_t*, uint32_t timestamp,
|
||||
const uint8_t* password, bool flood) {
|
||||
++logins;
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
"""Execute repeater guest authorization, saved toggles, and receive admission."""
|
||||
from pathlib import Path
|
||||
import re
|
||||
import json
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
@@ -18,6 +19,8 @@ HARNESS = r'''
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <helpers/GuestLoginSettings.h>
|
||||
#include <helpers/ClientLoginPersistence.h>
|
||||
#include <helpers/ClientPathObservation.h>
|
||||
@@ -25,10 +28,15 @@ HARNESS = r'''
|
||||
#include <helpers/LazyPersistence.h>
|
||||
#include <helpers/FloodCommandAliases.h>
|
||||
#include <helpers/LoginHistory.h>
|
||||
#include <helpers/DefaultPasswordWarning.h>
|
||||
#define PUB_KEY_SIZE 32
|
||||
#define MAX_PATH_SIZE 64
|
||||
#define MAX_PACKET_PAYLOAD 184
|
||||
#define PAYLOAD_TYPE_ANON_REQ 0x07
|
||||
#define PAYLOAD_TYPE_RESPONSE 0x01
|
||||
#define PAYLOAD_TYPE_TXT_MSG 0x02
|
||||
#define TXT_TYPE_CLI_DATA 1
|
||||
#define ADMIN_PASSWORD "password"
|
||||
#define MAX_CLIENTS 16
|
||||
#define MESH_CLIENT_REPEATER_ONLY 1
|
||||
#define MESH_ENABLE_FLOOD_RULE_ENGINE 1
|
||||
@@ -44,11 +52,19 @@ struct Identity {
|
||||
};
|
||||
struct Packet {
|
||||
bool direct = true;
|
||||
bool radio_reply = false, path_return = false;
|
||||
uint8_t type = PAYLOAD_TYPE_ANON_REQ;
|
||||
uint8_t path_len = 0, path[MAX_PATH_SIZE]{}, payload[MAX_PACKET_PAYLOAD]{};
|
||||
size_t payload_len = 0;
|
||||
bool isRouteDirect() const { return direct; }
|
||||
bool isRouteFlood() const { return !direct; }
|
||||
uint8_t getPayloadType() const { return type; }
|
||||
uint8_t getPathHashSize() const { return (path_len >> 6) + 1; }
|
||||
static bool isValidPathLen(uint8_t);
|
||||
static size_t writePath(uint8_t*, const uint8_t*, uint8_t);
|
||||
};
|
||||
@PACKET_HELPERS@
|
||||
@ROUTING_HELPERS@
|
||||
}
|
||||
@CLIENT_INFO@;
|
||||
struct ClientACL {
|
||||
@@ -110,15 +126,57 @@ struct MyMesh {
|
||||
unsigned received = 0;
|
||||
unsigned anonymous_requests = 0;
|
||||
uint8_t reply_path_len = 0;
|
||||
uint8_t reply_path[MAX_PATH_SIZE]{};
|
||||
struct Sent { mesh::Packet packet; unsigned long delay; uint8_t hash_size; };
|
||||
std::vector<Sent> sent;
|
||||
mesh::Packet response;
|
||||
unsigned creations = 0, path_returns = 0, client_replies = 0, fail_creation_on = 0;
|
||||
bool create_ok = true, queue_ok = true;
|
||||
bool metadata_reply = false;
|
||||
MyMesh() { assert(guest_login.begin(&fs)); }
|
||||
Clock* getRTCClock() { return &clock; }
|
||||
RNG* getRNG() { return &rng; }
|
||||
unsigned long futureMillis(unsigned long delay) { return 10000 + delay; }
|
||||
uint8_t handleLoginReq(const mesh::Identity&, const uint8_t*, uint32_t, const uint8_t*, bool);
|
||||
void onAnonDataRecv(mesh::Packet*, const uint8_t*, const mesh::Identity&, uint8_t*, size_t);
|
||||
uint8_t handleAnonRegionsReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t) { ++anonymous_requests; return 0; }
|
||||
uint8_t handleAnonOwnerReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t) { ++anonymous_requests; return 0; }
|
||||
uint8_t handleAnonClockReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t) { ++anonymous_requests; return 0; }
|
||||
void sendDefaultPasswordWarning(ClientInfo*, uint32_t, uint8_t);
|
||||
mesh::Packet* createDatagram(uint8_t type, const mesh::Identity& to, const uint8_t* key,
|
||||
const uint8_t* data, size_t length) {
|
||||
++creations;
|
||||
assert(length <= sizeof(response.payload));
|
||||
assert(to.matches(acl.clients[0].id) && !memcmp(key, acl.clients[0].shared_secret, PUB_KEY_SIZE));
|
||||
if (!create_ok || creations == fail_creation_on) return nullptr;
|
||||
response = mesh::Packet{}; response.type = type; response.payload_len = length;
|
||||
memcpy(response.payload, data, length); return &response;
|
||||
}
|
||||
mesh::Packet* createPathReturn(const mesh::Identity& to, const uint8_t* key,
|
||||
const uint8_t*, uint8_t, uint8_t type, const uint8_t* data, size_t length) {
|
||||
++path_returns;
|
||||
auto* packet = createDatagram(type, to, key, data, length);
|
||||
if (packet) packet->path_return = true;
|
||||
return packet;
|
||||
}
|
||||
bool sendDirect(mesh::Packet* packet, const uint8_t*, uint8_t length, unsigned long delay) {
|
||||
assert(packet && mesh::Packet::isValidPathLen(length));
|
||||
packet->direct = true; packet->path_len = length;
|
||||
if (queue_ok) sent.push_back({*packet, delay, 0});
|
||||
return queue_ok;
|
||||
}
|
||||
bool sendFloodReply(mesh::Packet* packet, unsigned long delay, uint8_t hash_size) {
|
||||
assert(packet); packet->direct = false;
|
||||
if (queue_ok) sent.push_back({*packet, delay, hash_size});
|
||||
return queue_ok;
|
||||
}
|
||||
bool sendClientReply(ClientInfo* client, mesh::Packet* packet, unsigned long delay, uint8_t hash_size) {
|
||||
++client_replies;
|
||||
assert(client);
|
||||
return mesh::Packet::isValidPathLen(client->out_path_len)
|
||||
? sendDirect(packet, client->out_path, client->out_path_len, delay)
|
||||
: sendFloodReply(packet, delay, hash_size);
|
||||
}
|
||||
uint8_t handleAnonRegionsReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t) { ++anonymous_requests; return metadata_reply ? 13 : 0; }
|
||||
uint8_t handleAnonOwnerReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t) { ++anonymous_requests; return metadata_reply ? 13 : 0; }
|
||||
uint8_t handleAnonClockReq(const mesh::Identity&, uint32_t, const uint8_t*, size_t) { ++anonymous_requests; return metadata_reply ? 13 : 0; }
|
||||
bool handleGuestCommand(const char*, char*, size_t);
|
||||
int searchPeersByHash(const uint8_t*);
|
||||
void onPeerDataRecv(mesh::Packet*, uint8_t, int, const uint8_t*, uint8_t*, size_t);
|
||||
@@ -127,6 +185,7 @@ struct MyMesh {
|
||||
void dispatch(ClientInfo*, const char*, char*);
|
||||
};
|
||||
@LOGIN@
|
||||
@PASSWORD_WARNING@
|
||||
@ANONYMOUS@
|
||||
@COMMAND@
|
||||
@SEARCH@
|
||||
@@ -408,6 +467,72 @@ static void anonymousRequestsAreNotLogins() {
|
||||
history(mesh, 1, 1, LoginResult::GuestsDisabled);
|
||||
assert(mesh.anonymous_requests == 3);
|
||||
}
|
||||
static void useFactoryPassword(MyMesh& mesh) {
|
||||
memset(mesh._prefs.password, 0, sizeof(mesh._prefs.password));
|
||||
const size_t limit = sizeof(mesh._prefs.password) - 1;
|
||||
const size_t length = strlen(ADMIN_PASSWORD) < limit ? strlen(ADMIN_PASSWORD) : limit;
|
||||
memcpy(mesh._prefs.password, ADMIN_PASSWORD, length);
|
||||
}
|
||||
static void defaultPasswordWarnings() {
|
||||
const auto dispatch = [](MyMesh& mesh, const char* password, bool flood, uint32_t timestamp = 100) {
|
||||
guest_metadata_fs = &mesh.fs;
|
||||
uint8_t data[40]{}; memcpy(data, ×tamp, 4);
|
||||
memcpy(data + 4, password, strlen(password));
|
||||
mesh::Packet request; request.direct = !flood; request.path_len = 0x42;
|
||||
mesh.onAnonDataRecv(&request, secret, identity(1), data, 4 + strlen(password));
|
||||
};
|
||||
for (bool flood : {false, true}) {
|
||||
MyMesh mesh; useFactoryPassword(mesh);
|
||||
dispatch(mesh, mesh._prefs.password, flood);
|
||||
assert(mesh.sent.size() == 2 && mesh.creations == 2);
|
||||
const auto& login = mesh.sent[0]; const auto& warning = mesh.sent[1];
|
||||
assert(login.packet.type == PAYLOAD_TYPE_RESPONSE && login.packet.payload_len == 13);
|
||||
assert(login.packet.payload[4] == RESP_SERVER_LOGIN_OK && login.packet.payload[12] == FIRMWARE_VER_LEVEL);
|
||||
assert(login.delay == SERVER_RESPONSE_DELAY);
|
||||
assert(warning.packet.type == PAYLOAD_TYPE_TXT_MSG && warning.packet.payload_len == 25);
|
||||
assert(warning.packet.payload[4] == (TXT_TYPE_CLI_DATA << 2));
|
||||
assert(!memcmp(warning.packet.payload + 5, "CHANGE YOUR PASSWORD", 20));
|
||||
assert(warning.packet.radio_reply && warning.delay == SERVER_RESPONSE_DELAY + 2000UL);
|
||||
assert(!warning.packet.direct && warning.hash_size == 2);
|
||||
assert(mesh.path_returns == (flood ? 1U : 0U));
|
||||
assert(mesh.client_replies == 0); // Unknown routes use the scoped flood reply boundary.
|
||||
}
|
||||
// An assigned administrator may reconnect without resending the password.
|
||||
MyMesh assigned; useFactoryPassword(assigned);
|
||||
add(assigned, 1, PERM_ACL_ADMIN); dispatch(assigned, "", false);
|
||||
assert(assigned.sent.size() == 2 && assigned.sent[1].packet.direct);
|
||||
assert(assigned.client_replies == 1);
|
||||
assigned.metadata_reply = true;
|
||||
uint8_t query[7]{}; query[4] = ANON_REQ_TYPE_OWNER;
|
||||
mesh::Packet metadata;
|
||||
assigned.onAnonDataRecv(&metadata, secret, identity(1), query, sizeof(query) - 1);
|
||||
assert(assigned.sent.size() == 3 && assigned.client_replies == 1);
|
||||
for (unsigned failure = 0; failure < 9; ++failure) {
|
||||
MyMesh mesh; useFactoryPassword(mesh);
|
||||
const char* password = mesh._prefs.password;
|
||||
if (failure == 0) { strcpy(mesh._prefs.password, "changed-secret"); password = "changed-secret"; }
|
||||
if (failure == 1) password = "wrong";
|
||||
if (failure == 2) { assert(mesh.guest_login.setEnabled(true)); password = ""; }
|
||||
if (failure == 3) mesh.acl.authorize_ok = false;
|
||||
if (failure == 4) mesh.create_ok = false;
|
||||
if (failure == 5) mesh.queue_ok = false;
|
||||
if (failure == 6) { add(mesh, 1, PERM_ACL_FILTER_MGR); password = ""; }
|
||||
if (failure == 7) mesh.acl.allocate_ok = false;
|
||||
if (failure == 8) mesh.fail_creation_on = 2;
|
||||
dispatch(mesh, password, false);
|
||||
assert(mesh.sent.size() == (failure == 0 || failure == 2 || failure == 6 || failure == 8 ? 1U : 0U));
|
||||
for (const auto& sent : mesh.sent) assert(sent.packet.type == PAYLOAD_TYPE_RESPONSE);
|
||||
}
|
||||
MyMesh replay; useFactoryPassword(replay);
|
||||
dispatch(replay, replay._prefs.password, false);
|
||||
dispatch(replay, replay._prefs.password, false);
|
||||
assert(replay.sent.size() == 2);
|
||||
MyMesh empty; auto* admin = add(empty, 1, PERM_ACL_ADMIN);
|
||||
empty._prefs.password[0] = 0;
|
||||
empty.sendDefaultPasswordWarning(admin, 100, 1);
|
||||
empty.sendDefaultPasswordWarning(nullptr, 100, 1);
|
||||
assert(empty.creations == 0 && empty.sent.empty());
|
||||
}
|
||||
int main(int argc, char** argv) {
|
||||
assert(argc == 2);
|
||||
if (!strcmp(argv[1], "passwords")) defaultsAndPasswords();
|
||||
@@ -417,6 +542,7 @@ int main(int argc, char** argv) {
|
||||
else if (!strcmp(argv[1], "receive")) receiveAdmission();
|
||||
else if (!strcmp(argv[1], "history")) loginHistoryDecisions();
|
||||
else if (!strcmp(argv[1], "anonymous")) anonymousRequestsAreNotLogins();
|
||||
else if (!strcmp(argv[1], "default-password")) defaultPasswordWarnings();
|
||||
else assert(false);
|
||||
printf("repeater guest %s passed\n", argv[1]);
|
||||
}
|
||||
@@ -437,6 +563,10 @@ class RepeaterGuestAccessTests(unittest.TestCase):
|
||||
for name in ("FIRMWARE_VER_LEVEL", "RESP_SERVER_LOGIN_OK", "LAZY_CONTACTS_WRITE_DELAY",
|
||||
"ANON_REQ_TYPE_REGIONS", "ANON_REQ_TYPE_OWNER", "ANON_REQ_TYPE_BASIC"):
|
||||
constants += "\n" + re.search(r"^#define\s+" + name + r"\s+.*$", source, re.MULTILINE).group()
|
||||
constants += "\n" + re.search(
|
||||
r"static constexpr uint32_t LOGIN_PATH_OBSERVATION_TIMEOUT_MS[^;]*;", source).group()
|
||||
constants += "\n" + re.search(r"^\s*#define SERVER_RESPONSE_DELAY[^\n]*",
|
||||
source, re.MULTILINE).group()
|
||||
manager_helpers = "\n".join(extract_braced(source, signature) for signature in (
|
||||
"static bool commandFamilyMatches(", "static bool commandListMatches(",
|
||||
"static bool isCommonManagerReadOnlyAllowed(", "static bool isRegionMgrAllowed(",
|
||||
@@ -457,14 +587,20 @@ class RepeaterGuestAccessTests(unittest.TestCase):
|
||||
request = extract_braced(source, "int MyMesh::handleRequest(")
|
||||
request_admission = request[:request.index(" if (reply_capacity >")] + "++received; return 1;\n}"
|
||||
anonymous = extract_braced(source, "void MyMesh::onAnonDataRecv(")
|
||||
anonymous = anonymous[:anonymous.index(" if (reply_len == 0) return;")] + " (void)reply_len;\n }\n}"
|
||||
cls.source_text = source
|
||||
packet = (ROOT / "src/Packet.cpp").read_text()
|
||||
routing = (ROOT / "src/helpers/RoutingPolicy.h").read_text()
|
||||
replacements = {
|
||||
"@CONSTANTS@": constants,
|
||||
"@CLIENT_INFO@": extract_braced(acl_header, "struct ClientInfo {"),
|
||||
"@REMOVE_GUESTS@": extract_braced(acl_source, "int ClientACL::removeGuestClients("),
|
||||
"@MANAGER_HELPERS@": manager_helpers,
|
||||
"@LOGIN@": extract_braced(source, "uint8_t MyMesh::handleLoginReq("),
|
||||
"@PASSWORD_WARNING@": extract_braced(source, "void MyMesh::sendDefaultPasswordWarning("),
|
||||
"@PACKET_HELPERS@": "\n".join(extract_braced(packet, signature) for signature in (
|
||||
"bool Packet::isValidPathLen(", "size_t Packet::writePath(")),
|
||||
"@ROUTING_HELPERS@": extract_braced(routing, "enum ReplyRoute") + ";\n"
|
||||
+ extract_braced(routing, "inline ReplyRoute chooseReplyRoute("),
|
||||
"@ANONYMOUS@": anonymous,
|
||||
"@COMMAND@": extract_braced(source, "bool MyMesh::handleGuestCommand("),
|
||||
"@SEARCH@": extract_braced(source, "int MyMesh::searchPeersByHash("),
|
||||
@@ -485,15 +621,19 @@ class RepeaterGuestAccessTests(unittest.TestCase):
|
||||
sanitizer = (["-fsanitize=address,undefined", "-fno-sanitize-recover=all",
|
||||
"-fno-omit-frame-pointer", "-fno-pie", "-no-pie"]
|
||||
if sys.platform.startswith("linux") else [])
|
||||
result = subprocess.run([
|
||||
command = [
|
||||
compiler, "-std=c++17", "-O1", "-g", "-Wall", "-Wextra", "-Werror",
|
||||
"-Wno-unused-parameter", "-Wno-sign-compare", "-Wno-misleading-indentation",
|
||||
"-DESP32_PLATFORM", "-DESP32", *sanitizer,
|
||||
"-I", str(FIXTURE / "mocks"), "-I", str(ROOT / "src"),
|
||||
str(cpp), str(ROOT / "src/helpers/GuestLoginSettings.cpp"), "-o", str(cls.binary),
|
||||
], capture_output=True, text=True, timeout=60)
|
||||
]
|
||||
result = subprocess.run(command, capture_output=True, text=True, timeout=60)
|
||||
if result.returncode:
|
||||
raise AssertionError(result.stdout + result.stderr)
|
||||
cls.generated = generated
|
||||
cls.compile_command = command
|
||||
cls.source = cpp
|
||||
|
||||
def scenario(self, name):
|
||||
result = subprocess.run([str(self.binary), name], capture_output=True, text=True, timeout=15)
|
||||
@@ -521,6 +661,25 @@ class RepeaterGuestAccessTests(unittest.TestCase):
|
||||
def test_only_login_requests_enter_history(self):
|
||||
self.scenario("anonymous")
|
||||
|
||||
def test_default_password_admin_login_warns_after_the_binary_reply(self):
|
||||
self.scenario("default-password")
|
||||
|
||||
def test_custom_factory_password_and_bounded_long_factory_password(self):
|
||||
for index, factory in enumerate(("factory-admin", "12345678901234567890")):
|
||||
with self.subTest(factory=factory):
|
||||
source = Path(self.work.name) / ("factory-" + str(index) + ".cpp")
|
||||
source.write_text(self.generated.replace('#define ADMIN_PASSWORD "password"',
|
||||
'#define ADMIN_PASSWORD ' + json.dumps(factory)))
|
||||
binary = source.with_suffix("")
|
||||
command = [str(source) if value == str(self.source)
|
||||
else str(binary) if value == str(self.binary) else value
|
||||
for value in self.compile_command]
|
||||
built = subprocess.run(command, capture_output=True, text=True, timeout=60)
|
||||
self.assertEqual(built.returncode, 0, built.stdout + built.stderr)
|
||||
checked = subprocess.run([str(binary), "default-password"],
|
||||
capture_output=True, text=True, timeout=15)
|
||||
self.assertEqual(checked.returncode, 0, checked.stdout + checked.stderr)
|
||||
|
||||
def test_password_bytes_are_not_logged(self):
|
||||
login = extract_braced(self.source_text, "uint8_t MyMesh::handleLoginReq(")
|
||||
debug_calls = re.findall(r"MESH_DEBUG_PRINTLN\([\s\S]*?\);", login)
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
"""Execute the real room login/replay handlers against controlled storage faults."""
|
||||
|
||||
from pathlib import Path
|
||||
import json
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
@@ -36,6 +37,8 @@ HARNESS = r'''
|
||||
#include <helpers/ClientLoginPersistence.h>
|
||||
#include <helpers/LazyPersistence.h>
|
||||
#include <helpers/LogicalMessageCache.h>
|
||||
#include <helpers/DefaultPasswordWarning.h>
|
||||
#define ADMIN_PASSWORD "password"
|
||||
@CONSTANTS@
|
||||
@STR_HELPER@
|
||||
#define MESH_CLIENT_REPEATER_ONLY 0
|
||||
@@ -190,8 +193,8 @@ struct MyMesh {
|
||||
mesh::Packet* createAck(uint32_t ack) { ++post_acks; response.payload_len = 4; memcpy(response.payload, &ack, 4); return &response; }
|
||||
mesh::Packet* createMultiAck(uint32_t ack, uint8_t) { return createAck(ack); }
|
||||
struct Prefs {
|
||||
char password[32] = "admin";
|
||||
char guest_password[32] = "guest";
|
||||
char password[16] = "admin";
|
||||
char guest_password[16] = "guest";
|
||||
bool allow_read_only = false;
|
||||
uint8_t direct_retry_enabled = 1;
|
||||
} _prefs;
|
||||
@@ -201,6 +204,10 @@ struct MyMesh {
|
||||
uint8_t contacts_save_failures = 0, reply_data[32] = {};
|
||||
unsigned creations = 0, direct_sends = 0, flood_sends = 0, path_returns = 0;
|
||||
bool create_ok = true, queue_ok = true;
|
||||
unsigned fail_creation_on = 0;
|
||||
uint8_t created_type = 0;
|
||||
struct Sent { uint8_t type; std::vector<uint8_t> data; unsigned long delay; bool direct; bool radio_reply; uint8_t hash_size; };
|
||||
std::vector<Sent> sent;
|
||||
mesh::Packet response;
|
||||
uint8_t response_secret[PUB_KEY_SIZE] = {}, response_key[PUB_KEY_SIZE] = {};
|
||||
uint8_t returned_path[MAX_PATH_SIZE] = {}, direct_path[MAX_PATH_SIZE] = {};
|
||||
@@ -218,13 +225,15 @@ struct MyMesh {
|
||||
mesh::Packet* createDatagram(uint8_t type, const mesh::Identity& sender,
|
||||
const uint8_t* secret, const uint8_t* data, size_t len) {
|
||||
++creations;
|
||||
created_type = type;
|
||||
response.radio_reply = false;
|
||||
assert(type == PAYLOAD_TYPE_RESPONSE || type == PAYLOAD_TYPE_TXT_MSG);
|
||||
assert(len <= sizeof(captured_reply));
|
||||
memcpy(response_key, sender.pub_key, PUB_KEY_SIZE);
|
||||
memcpy(response_secret, secret, PUB_KEY_SIZE);
|
||||
memcpy(captured_reply, data, len);
|
||||
captured_reply_length = len;
|
||||
return create_ok ? &response : nullptr;
|
||||
return create_ok && creations != fail_creation_on ? &response : nullptr;
|
||||
}
|
||||
mesh::Packet* createPathReturn(const mesh::Identity& sender, const uint8_t* secret,
|
||||
const uint8_t* path, uint8_t path_len, uint8_t type, const uint8_t* data, size_t len) {
|
||||
@@ -235,17 +244,23 @@ struct MyMesh {
|
||||
}
|
||||
bool sendDirect(mesh::Packet* packet, const uint8_t* path, uint8_t path_len,
|
||||
unsigned long delay) {
|
||||
assert(packet == &response && (delay == SERVER_RESPONSE_DELAY || delay == TXT_ACK_DELAY));
|
||||
assert(packet == &response && (delay == SERVER_RESPONSE_DELAY || delay == TXT_ACK_DELAY
|
||||
|| (packet->radio_reply && delay == SERVER_RESPONSE_DELAY + 2000UL)));
|
||||
assert(mesh::Packet::isValidPathLen(path_len));
|
||||
++direct_sends;
|
||||
direct_path_len = path_len;
|
||||
memcpy(direct_path, path, (path_len & 63) * ((path_len >> 6) + 1));
|
||||
if (queue_ok) sent.push_back({created_type, std::vector<uint8_t>(captured_reply,
|
||||
captured_reply + captured_reply_length), delay, true, packet->radio_reply, 0});
|
||||
return queue_ok;
|
||||
}
|
||||
bool sendFloodReply(mesh::Packet* packet, unsigned long delay, uint8_t hash_size) {
|
||||
assert(packet == &response && (delay == SERVER_RESPONSE_DELAY || delay == TXT_ACK_DELAY));
|
||||
assert(packet == &response && (delay == SERVER_RESPONSE_DELAY || delay == TXT_ACK_DELAY
|
||||
|| (packet->radio_reply && delay == SERVER_RESPONSE_DELAY + 2000UL)));
|
||||
++flood_sends;
|
||||
reply_hash_size = hash_size;
|
||||
if (queue_ok) sent.push_back({created_type, std::vector<uint8_t>(captured_reply,
|
||||
captured_reply + captured_reply_length), delay, false, packet->radio_reply, hash_size});
|
||||
return queue_ok;
|
||||
}
|
||||
bool store_ok = true;
|
||||
@@ -275,7 +290,9 @@ struct MyMesh {
|
||||
bool onPeerPathRecv(mesh::Packet*, int, const uint8_t*, uint8_t*, uint8_t, uint8_t, uint8_t*, uint8_t);
|
||||
void onAnonDataRecv(mesh::Packet*, const uint8_t*, const mesh::Identity&,
|
||||
uint8_t*, size_t);
|
||||
void sendDefaultPasswordWarning(ClientInfo*, uint32_t, uint8_t);
|
||||
};
|
||||
@PASSWORD_WARNING@
|
||||
@LOGIN_HANDLER@
|
||||
@PEER_HANDLER@
|
||||
@PATH_HANDLER@
|
||||
@@ -818,6 +835,52 @@ static void allRequestQuotaCases() {
|
||||
}
|
||||
puts("actual request quota covers status, telemetry, ACL, board, and exact payload retries passed");
|
||||
}
|
||||
static void useFactoryPassword(MyMesh& mesh) {
|
||||
memset(mesh._prefs.password, 0, sizeof(mesh._prefs.password));
|
||||
const size_t limit = sizeof(mesh._prefs.password) - 1;
|
||||
const size_t length = strlen(ADMIN_PASSWORD) < limit ? strlen(ADMIN_PASSWORD) : limit;
|
||||
memcpy(mesh._prefs.password, ADMIN_PASSWORD, length);
|
||||
}
|
||||
static void defaultPasswordWarnings() {
|
||||
for (bool flood : {false, true}) {
|
||||
MyMesh mesh; useFactoryPassword(mesh);
|
||||
const uint32_t requested = mesh.clock.now + 2; // Force the warning timestamp collision guard.
|
||||
login(mesh, mesh._prefs.password, requested, 0, flood);
|
||||
assert(mesh.sent.size() == 2 && mesh.creations == 2);
|
||||
const auto& response = mesh.sent[0]; const auto& warning = mesh.sent[1];
|
||||
assert(response.type == PAYLOAD_TYPE_RESPONSE && response.data.size() == 13);
|
||||
assert(response.data[4] == RESP_SERVER_LOGIN_OK && response.data[12] == FIRMWARE_VER_LEVEL);
|
||||
assert(response.delay == SERVER_RESPONSE_DELAY);
|
||||
assert(warning.type == PAYLOAD_TYPE_TXT_MSG && warning.data.size() == 25);
|
||||
assert(warning.data[4] == (TXT_TYPE_CLI_DATA << 2));
|
||||
assert(!memcmp(warning.data.data() + 5, "CHANGE YOUR PASSWORD", 20));
|
||||
uint32_t timestamp; memcpy(×tamp, warning.data.data(), 4);
|
||||
assert(timestamp != requested && warning.radio_reply);
|
||||
assert(warning.delay == SERVER_RESPONSE_DELAY + 2000UL && !warning.direct && warning.hash_size == 2);
|
||||
assert(mesh.path_returns == (flood ? 1U : 0U));
|
||||
}
|
||||
MyMesh assigned; useFactoryPassword(assigned);
|
||||
seedKnown(assigned, PERM_ACL_ADMIN); login(assigned, "");
|
||||
assert(assigned.sent.size() == 2 && assigned.sent[1].direct);
|
||||
for (unsigned failure = 0; failure < 7; ++failure) {
|
||||
MyMesh mesh; useFactoryPassword(mesh);
|
||||
const char* password = mesh._prefs.password;
|
||||
if (failure == 0) { strcpy(mesh._prefs.password, "changed-secret"); password = "changed-secret"; }
|
||||
if (failure == 1) password = "wrong";
|
||||
if (failure == 2) password = "guest";
|
||||
if (failure == 3) mesh.acl.storage.write_ok = false;
|
||||
if (failure == 4) mesh.create_ok = false;
|
||||
if (failure == 5) mesh.queue_ok = false;
|
||||
if (failure == 6) mesh.fail_creation_on = 2;
|
||||
login(mesh, password);
|
||||
assert(mesh.sent.size() == (failure == 0 || failure == 2 || failure == 6 ? 1U : 0U));
|
||||
for (const auto& sent : mesh.sent) assert(sent.type == PAYLOAD_TYPE_RESPONSE);
|
||||
}
|
||||
MyMesh replay; useFactoryPassword(replay);
|
||||
login(replay, replay._prefs.password); login(replay, replay._prefs.password);
|
||||
assert(replay.sent.size() == 2);
|
||||
puts("default password warning follows successful admin login without changing the binary response passed");
|
||||
}
|
||||
int main(int argc, char** argv) {
|
||||
assert(argc == 2);
|
||||
if (!strcmp(argv[1], "authorization")) authorizationCases();
|
||||
@@ -830,6 +893,7 @@ int main(int argc, char** argv) {
|
||||
else if (!strcmp(argv[1], "requests")) allRequestQuotaCases();
|
||||
else if (!strcmp(argv[1], "observed")) observedLoginPath();
|
||||
else if (!strcmp(argv[1], "reconnect")) reconnectCursor();
|
||||
else if (!strcmp(argv[1], "default-password")) defaultPasswordWarnings();
|
||||
else assert(false);
|
||||
}
|
||||
'''
|
||||
@@ -898,6 +962,7 @@ class RoomLoginIntegrationTests(unittest.TestCase):
|
||||
room, "uint8_t MyMesh::getUnsyncedCount(")),
|
||||
"@ROOM_MAIL_STATUS@": extract_braced(room, "bool MyMesh::roomClientChatEnabled("),
|
||||
"@LOGIN_HANDLER@": extract_braced(room, "void MyMesh::onAnonDataRecv("),
|
||||
"@PASSWORD_WARNING@": extract_braced(room, "void MyMesh::sendDefaultPasswordWarning("),
|
||||
}
|
||||
generated = HARNESS
|
||||
for marker, text in replacements.items():
|
||||
@@ -930,6 +995,25 @@ class RoomLoginIntegrationTests(unittest.TestCase):
|
||||
def test_unknown_blank_read_only_disabled_passwords_and_payload_bounds(self):
|
||||
self.run_case("authorization", "real-handler credentials, disabled passwords, and minimum payload cases passed")
|
||||
|
||||
def test_default_password_admin_login_warns_after_the_binary_reply(self):
|
||||
self.run_case("default-password", "default password warning follows successful admin login")
|
||||
|
||||
def test_custom_factory_password_and_bounded_long_factory_password(self):
|
||||
for index, factory in enumerate(("factory-admin", "12345678901234567890")):
|
||||
with self.subTest(factory=factory):
|
||||
source = Path(self.directory.name) / ("factory-" + str(index) + ".cpp")
|
||||
source.write_text(self.generated.replace('#define ADMIN_PASSWORD "password"',
|
||||
'#define ADMIN_PASSWORD ' + json.dumps(factory)))
|
||||
binary = source.with_suffix("")
|
||||
command = [str(source) if value == str(self.source)
|
||||
else str(binary) if value == str(self.binary) else value
|
||||
for value in self.compile_command]
|
||||
built = subprocess.run(command, capture_output=True, text=True, timeout=60)
|
||||
self.assertEqual(built.returncode, 0, built.stdout + built.stderr)
|
||||
checked = subprocess.run([str(binary), "default-password"],
|
||||
capture_output=True, text=True, timeout=15)
|
||||
self.assertEqual(checked.returncode, 0, checked.stdout + checked.stderr)
|
||||
|
||||
def test_non_demotion_all_roles_and_exact_replay_preserve_session(self):
|
||||
self.run_case("roles", "2048 real-handler preserved roles and replay rejects plus 256 admin upgrades passed")
|
||||
|
||||
|
||||
@@ -73,7 +73,9 @@ struct MyMesh {
|
||||
return createDatagram(type, sender, secret, data, length);
|
||||
}
|
||||
bool sendFloodReply(mesh::Packet*, unsigned long, uint8_t) { return true; }
|
||||
void sendDirect(mesh::Packet*, const uint8_t*, uint8_t, unsigned long) {}
|
||||
bool sendDirect(mesh::Packet*, const uint8_t*, uint8_t, unsigned long) { return true; }
|
||||
// The production warning sender is covered by RoomLoginIntegrationTests.
|
||||
void sendDefaultPasswordWarning(ClientInfo*, uint32_t, uint8_t) {}
|
||||
static bool saveFilter(ClientInfo*);
|
||||
void onAnonDataRecv(mesh::Packet*, const uint8_t*, const mesh::Identity&, uint8_t*, size_t);
|
||||
};
|
||||
|
||||
Reference in new issue
Block a user