@alteriom/painlessmesh 1.6.1

package/src/painlessmesh/router.hpp

@@ -0,0 +1,322 @@
+#ifndef _PAINLESS_MESH_ROUTER_HPP_
+#define _PAINLESS_MESH_ROUTER_HPP_
+
+#include <algorithm>
+#include <memory>
+
+#include "painlessmesh/callback.hpp"
+#include "painlessmesh/layout.hpp"
+#include "painlessmesh/logger.hpp"
+#include "painlessmesh/protocol.hpp"
+
+extern painlessmesh::logger::LogClass Log;
+
+namespace painlessmesh {
+
+/**
+ * Helper functions to route messages
+ */
+namespace router {
+template <class T>
+std::shared_ptr<T> findRoute(layout::Layout<T> tree,
+                             std::function<bool(std::shared_ptr<T>)> func) {
+  auto route = std::find_if(tree.subs.begin(), tree.subs.end(), func);
+  if (route == tree.subs.end()) return NULL;
+  return (*route);
+}
+
+template <class T>
+std::shared_ptr<T> findRoute(layout::Layout<T> tree, uint32_t nodeId) {
+  return findRoute<T>(tree, [nodeId](std::shared_ptr<T> s) {
+    return layout::contains((*s), nodeId);
+  });
+}
+
+template <class T, class U>
+bool send(T& package, std::shared_ptr<U> conn, bool priority = false) {
+  painlessmesh::protocol::Variant variant(package);
+  TSTRING msg;
+  variant.printTo(msg);
+  return conn->addMessage(msg, priority);
+}
+
+template <class T, class U>
+bool send(T&& package, std::shared_ptr<U> conn, bool priority = false) {
+  painlessmesh::protocol::Variant variant(package);
+  TSTRING msg;
+  variant.printTo(msg);
+  return conn->addMessage(msg, priority);
+}
+
+template <class U>
+bool send(protocol::Variant& variant, std::shared_ptr<U> conn,
+          bool priority = false) {
+  TSTRING msg;
+  variant.printTo(msg);
+  return conn->addMessage(msg, priority);
+}
+
+template <class U>
+bool send(protocol::Variant&& variant, std::shared_ptr<U> conn,
+          bool priority = false) {
+  TSTRING msg;
+  variant.printTo(msg);
+  return conn->addMessage(msg, priority);
+}
+
+template <class T, class U>
+bool send(T& package, layout::Layout<U> layout) {
+  painlessmesh::protocol::Variant variant(package);
+  TSTRING msg;
+  variant.printTo(msg);
+  auto conn = findRoute<U>(layout, variant.dest());
+  if (conn) return conn->addMessage(msg);
+  return false;
+}
+
+template <class U>
+bool send(protocol::Variant& variant, layout::Layout<U> layout) {
+  TSTRING msg;
+  variant.printTo(msg);
+  auto conn = findRoute<U>(layout, variant.dest());
+  if (conn) return conn->addMessage(msg);
+  return false;
+}
+
+template <class T, class U>
+bool send(T&& package, layout::Layout<U> layout) {
+  painlessmesh::protocol::Variant variant(package);
+  TSTRING msg;
+  variant.printTo(msg);
+  auto conn = findRoute<U>(layout, variant.dest());
+  if (conn) return conn->addMessage(msg);
+  return false;
+}
+
+template <class U>
+bool send(protocol::Variant&& variant, layout::Layout<U> layout) {
+  TSTRING msg;
+  variant.printTo(msg);
+  auto conn = findRoute<U>(layout, variant.dest());
+  if (conn) return conn->addMessage(msg);
+  return false;
+}
+
+template <class T, class U>
+size_t broadcast(T& package, layout::Layout<U> layout, uint32_t exclude) {
+  painlessmesh::protocol::Variant variant(package);
+  TSTRING msg;
+  variant.printTo(msg);
+  size_t i = 0;
+  for (auto&& conn : layout.subs) {
+    if (conn->nodeId != 0 && conn->nodeId != exclude) {
+      auto sent = conn->addMessage(msg);
+      if (sent) ++i;
+    }
+  }
+  return i;
+}
+
+template <class T, class U>
+size_t broadcast(T&& package, layout::Layout<U> layout, uint32_t exclude) {
+  painlessmesh::protocol::Variant variant(package);
+  TSTRING msg;
+  variant.printTo(msg);
+  size_t i = 0;
+  for (auto&& conn : layout.subs) {
+    if (conn->nodeId != 0 && conn->nodeId != exclude) {
+      auto sent = conn->addMessage(msg);
+      if (sent) ++i;
+    }
+  }
+  return i;
+}
+
+template <class T>
+size_t broadcast(protocol::Variant& variant, layout::Layout<T> layout,
+                 uint32_t exclude) {
+  TSTRING msg;
+  variant.printTo(msg);
+  size_t i = 0;
+  for (auto&& conn : layout.subs) {
+    if (conn->nodeId != 0 && conn->nodeId != exclude) {
+      auto sent = conn->addMessage(msg);
+      if (sent) ++i;
+    }
+  }
+  return i;
+}
+
+template <class T>
+size_t broadcast(protocol::Variant&& variant, layout::Layout<T> layout,
+                 uint32_t exclude) {
+  TSTRING msg;
+  variant.printTo(msg);
+  size_t i = 0;
+  for (auto&& conn : layout.subs) {
+    if (conn->nodeId != 0 && conn->nodeId != exclude) {
+      auto sent = conn->addMessage(msg);
+      if (sent) ++i;
+    }
+  }
+  return i;
+}
+
+template <class T>
+void routePackage(layout::Layout<T> layout, std::shared_ptr<T> connection,
+                  const TSTRING& pkg, callback::MeshPackageCallbackList<T> cbl,
+                  uint32_t receivedAt) {
+  using namespace logger;
+  Log(COMMUNICATION, "routePackage(): Recvd from %u: %s\n", connection->nodeId,
+      pkg.c_str());
+#if ARDUINOJSON_VERSION_MAJOR == 7
+  protocol::Variant variant(pkg);
+  if (variant.error) {
+    Log(ERROR,
+        "routePackage(): parsing failed. err=%u, total_length=%d, data=%s<--\n",
+        variant.error, pkg.length(), pkg.c_str());
+    return;
+  }
+
+  if (variant.routing() == SINGLE && variant.dest() != layout.getNodeId()) {
+    // Send on without further processing
+    send<T>(variant, layout);
+    return;
+  } else if (variant.routing() == BROADCAST) {
+    broadcast<T>(variant, layout, connection->nodeId);
+  }
+  auto calls = cbl.execute(variant.type(), variant, connection, receivedAt);
+  if (calls == 0)
+    Log(DEBUG, "routePackage(): No callbacks executed; %u, %s\n",
+        variant.type(), pkg.c_str());
+#else
+  static size_t baseCapacity = 512;
+  // Using a ptr so we can overwrite it if we need to grow capacity.
+  // Bug in copy constructor with grown capacity can cause segmentation fault
+  auto variant =
+      std::make_shared<protocol::Variant>(pkg, pkg.length() + baseCapacity);
+  while (variant->error == DeserializationError::NoMemory &&
+         baseCapacity <= 20480) {
+    // Not enough memory, adapt scaling (variant::capacityScaling) and log the
+    // new value
+    Log(DEBUG,
+        "routePackage(): parsing failed. err=%u, increasing capacity: %u\n",
+        variant->error, baseCapacity);
+    baseCapacity += 256;
+    variant =
+        std::make_shared<protocol::Variant>(pkg, pkg.length() + baseCapacity);
+  }
+  if (variant->error) {
+    Log(ERROR,
+        "routePackage(): parsing failed. err=%u, total_length=%d, data=%s<--\n",
+        variant->error, pkg.length(), pkg.c_str());
+    return;
+  }
+
+  if (variant->routing() == SINGLE && variant->dest() != layout.getNodeId()) {
+    // Send on without further processing
+    send<T>((*variant), layout);
+    return;
+  } else if (variant->routing() == BROADCAST) {
+    broadcast<T>((*variant), layout, connection->nodeId);
+  }
+  auto calls = cbl.execute(variant->type(), (*variant), connection, receivedAt);
+  if (calls == 0)
+    Log(DEBUG, "routePackage(): No callbacks executed; %u, %s\n",
+        variant->type(), pkg.c_str());
+#endif
+}
+
+template <class T, class U>
+void handleNodeSync(T& mesh, protocol::NodeTree newTree,
+                    std::shared_ptr<U> conn) {
+  Log(logger::SYNC, "handleNodeSync(): with %u\n", conn->nodeId);
+
+  if (!conn->validSubs(newTree)) {
+    Log(logger::SYNC, "handleNodeSync(): invalid new connection\n");
+    Log.remote("Invalid connection to %u\n", conn->nodeId);
+    conn->close();
+    return;
+  }
+
+  if (conn->newConnection) {
+    auto oldConnection = router::findRoute<U>(mesh, newTree.nodeId);
+    if (oldConnection) {
+      Log(logger::SYNC,
+          "handleNodeSync(): already connected to %u. Closing the new "
+          "connection \n",
+          newTree.nodeId);
+      Log.remote("Already connected to %u\n", newTree.nodeId);
+      conn->close();
+      return;
+    }
+    auto remoteNodeId = newTree.nodeId;
+    mesh.addTask([&mesh, remoteNodeId]() {
+      Log(logger::CONNECTION, "newConnectionTask():\n");
+      Log(logger::CONNECTION, "newConnectionTask(): adding %u now= %u\n",
+          remoteNodeId, mesh.getNodeTime());
+      mesh.newConnectionCallbacks.execute(remoteNodeId);
+    });
+
+    // Initially interval is every 10 seconds,
+    // this will slow down to TIME_SYNC_INTERVAL
+    // after first succesfull sync
+    // TODO move it to a new connection callback and use initTimeSync from
+    // ntp.hpp
+    conn->timeSyncTask.set(10 * TASK_SECOND, TASK_FOREVER, [conn, &mesh]() {
+      Log(logger::S_TIME, "timeSyncTask(): %u\n", conn->nodeId);
+      mesh.startTimeSync(conn);
+    });
+    mesh.mScheduler->addTask(conn->timeSyncTask);
+    if (conn->station)
+      // We are STA, request time immediately
+      conn->timeSyncTask.enable();
+    else
+      // We are the AP, give STA the change to initiate time sync
+      conn->timeSyncTask.enableDelayed();
+    conn->newConnection = false;
+  }
+
+  if (conn->updateSubs(newTree)) {
+    auto nodeId = newTree.nodeId;
+    mesh.addTask(
+        [&mesh, nodeId]() { mesh.changedConnectionCallbacks.execute(nodeId); });
+  } else {
+    conn->nodeSyncTask.delay();
+    mesh.stability += std::min(1000 - mesh.stability, (size_t)25);
+  }
+}
+
+template <class T, typename U>
+callback::MeshPackageCallbackList<U> addPackageCallback(
+    callback::MeshPackageCallbackList<U>&& callbackList, T& mesh) {
+  // REQUEST type,
+  callbackList.onPackage(
+      protocol::NODE_SYNC_REQUEST,
+      [&mesh](protocol::Variant& variant, std::shared_ptr<U> connection,
+              uint32_t receivedAt) {
+        auto newTree = variant.to<protocol::NodeSyncRequest>();
+        handleNodeSync<T, U>(mesh, newTree, connection);
+        send<protocol::NodeSyncReply>(
+            connection->reply(std::move(mesh.asNodeTree())), connection, true);
+        return false;
+      });
+
+  // Reply type just handle it
+  callbackList.onPackage(
+      protocol::NODE_SYNC_REPLY,
+      [&mesh](protocol::Variant& variant, std::shared_ptr<U> connection,
+              uint32_t receivedAt) {
+        auto newTree = variant.to<protocol::NodeSyncReply>();
+        handleNodeSync<T, U>(mesh, newTree, connection);
+        connection->timeOutTask.disable();
+        return false;
+      });
+
+  return callbackList;
+}
+
+}  // namespace router
+}  // namespace painlessmesh
+
+#endif

package/src/painlessmesh/tcp.hpp

@@ -0,0 +1,71 @@
+#ifndef _PAINLESS_MESH_TCP_HPP_
+#define _PAINLESS_MESH_TCP_HPP_
+
+#include <list>
+
+#include "Arduino.h"
+#include "painlessmesh/configuration.hpp"
+
+#include "painlessmesh/logger.hpp"
+
+namespace painlessmesh {
+namespace tcp {
+inline uint32_t encodeNodeId(const uint8_t *hwaddr) {
+  using namespace painlessmesh::logger;
+  Log(GENERAL, "encodeNodeId():\n");
+  uint32_t value = 0;
+
+  value |= hwaddr[2] << 24;  // Big endian (aka "network order"):
+  value |= hwaddr[3] << 16;
+  value |= hwaddr[4] << 8;
+  value |= hwaddr[5];
+  return value;
+}
+
+template <class T, class M>
+void initServer(AsyncServer &server, M &mesh) {
+  using namespace logger;
+  server.setNoDelay(true);
+
+  server.onClient(
+      [&mesh](void *arg, AsyncClient *client) {
+        if (mesh.semaphoreTake()) {
+          Log(CONNECTION, "New AP connection incoming\n");
+          auto conn = std::make_shared<T>(client, &mesh, false);
+          conn->initTasks();
+          mesh.subs.push_back(conn);
+          mesh.semaphoreGive();
+        }
+      },
+      NULL);
+  server.begin();
+}
+
+template <class T, class M>
+void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh) {
+  using namespace logger;
+  client.onError([&mesh](void *, AsyncClient *client, int8_t err) {
+    if (mesh.semaphoreTake()) {
+      Log(CONNECTION, "tcp_err(): error trying to connect %d\n", err);
+      mesh.droppedConnectionCallbacks.execute(0, true);
+      mesh.semaphoreGive();
+    }
+  });
+
+  client.onConnect(
+      [&mesh](void *, AsyncClient *client) {
+        if (mesh.semaphoreTake()) {
+          Log(CONNECTION, "New STA connection incoming\n");
+          auto conn = std::make_shared<T>(client, &mesh, true);
+          conn->initTasks();
+          mesh.subs.push_back(conn);
+          mesh.semaphoreGive();
+        }
+      },
+      NULL);
+
+  client.connect(ip, port);
+}
+}  // namespace tcp
+}  // namespace painlessmesh
+#endif

package/src/painlessmesh/validation.hpp

@@ -0,0 +1,239 @@
+#ifndef _PAINLESS_MESH_VALIDATION_HPP_
+#define _PAINLESS_MESH_VALIDATION_HPP_
+
+/**
+ * Input validation and security utilities for painlessMesh
+ *
+ * This module provides comprehensive validation utilities to improve
+ * security and robustness of the mesh network.
+ */
+
+#include <list>
+#include <map>
+#ifndef ARDUINO
+#include <chrono>
+#endif
+#include "ArduinoJson.h"
+#include "painlessmesh/configuration.hpp"
+
+namespace painlessmesh {
+namespace validation {
+
+/**
+ * Message validation result
+ */
+enum class ValidationResult {
+  VALID = 0,
+  INVALID_JSON,
+  MISSING_REQUIRED_FIELD,
+  INVALID_FIELD_TYPE,
+  INVALID_FIELD_VALUE,
+  MESSAGE_TOO_LARGE,
+  INVALID_NODE_ID,
+  RATE_LIMIT_EXCEEDED
+};
+
+/**
+ * Configuration for message validation
+ */
+struct ValidationConfig {
+  size_t max_message_size = 8192;     // Maximum message size in bytes
+  size_t max_string_length = 1024;    // Maximum string field length
+  uint32_t min_node_id = 1;           // Minimum valid node ID
+  uint32_t max_node_id = 0xFFFFFFFF;  // Maximum valid node ID
+  size_t max_nesting_depth = 10;      // Maximum JSON nesting depth
+  bool strict_type_checking = true;   // Enable strict type validation
+};
+
+/**
+ * Rate limiting for preventing message spam
+ */
+class RateLimiter {
+ public:
+  RateLimiter(size_t max_messages_per_second = 10, size_t window_size_ms = 1000)
+      : max_messages_(max_messages_per_second), window_size_(window_size_ms) {}
+
+  bool allow_message(uint32_t node_id) {
+    uint32_t current_time = get_current_time();
+    auto& history = node_history_[node_id];
+
+    // Remove old entries outside the window
+    while (!history.empty() &&
+           (current_time - history.front()) > window_size_) {
+      history.pop_front();
+    }
+
+    // Check if limit is exceeded
+    if (history.size() >= max_messages_) {
+      return false;
+    }
+
+    // Record this message
+    history.push_back(current_time);
+    return true;
+  }
+
+  void clear_node_history(uint32_t node_id) { node_history_.erase(node_id); }
+
+  void clear_all_history() { node_history_.clear(); }
+
+ private:
+  uint32_t get_current_time() const {
+#ifdef ARDUINO
+    return millis();
+#else
+    auto now = std::chrono::steady_clock::now();
+    auto duration = now.time_since_epoch();
+    return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
+        .count();
+#endif
+  }
+
+  size_t max_messages_;
+  size_t window_size_;
+  std::map<uint32_t, std::list<uint32_t>> node_history_;
+};
+
+/**
+ * JSON message validator
+ */
+class MessageValidator {
+ public:
+  explicit MessageValidator(const ValidationConfig& config = ValidationConfig{})
+      : config_(config) {}
+
+  /**
+   * Validate a JSON message for basic structure and security
+   */
+  ValidationResult validate_message(const JsonObject& obj,
+                                    size_t message_size = 0) const {
+    // Check message size
+    if (message_size > config_.max_message_size) {
+      return ValidationResult::MESSAGE_TOO_LARGE;
+    }
+
+    // Check required fields based on message type
+    if (!obj["type"].is<int>()) {
+      return ValidationResult::MISSING_REQUIRED_FIELD;
+    }
+
+    // Validate node IDs if present
+    if (obj["from"].is<uint32_t>()) {
+      uint32_t from_id = obj["from"].as<uint32_t>();
+      if (!is_valid_node_id(from_id)) {
+        return ValidationResult::INVALID_NODE_ID;
+      }
+    }
+
+    if (obj["dest"].is<uint32_t>()) {
+      uint32_t dest_id = obj["dest"].as<uint32_t>();
+      if (dest_id != 0 && !is_valid_node_id(dest_id)) {  // 0 is broadcast
+        return ValidationResult::INVALID_NODE_ID;
+      }
+    }
+
+    // Validate string fields
+    for (JsonPair pair : obj) {
+      if (pair.value().is<const char*>()) {
+        const char* str_value = pair.value().as<const char*>();
+        if (strlen(str_value) > config_.max_string_length) {
+          return ValidationResult::INVALID_FIELD_VALUE;
+        }
+      }
+    }
+
+    return ValidationResult::VALID;
+  }
+
+  /**
+   * Validate node ID range
+   */
+  bool is_valid_node_id(uint32_t node_id) const {
+    return node_id >= config_.min_node_id && node_id <= config_.max_node_id;
+  }
+
+  /**
+   * Get validation error message
+   */
+  const char* get_error_message(ValidationResult result) const {
+    switch (result) {
+      case ValidationResult::VALID:
+        return "Valid";
+      case ValidationResult::INVALID_JSON:
+        return "Invalid JSON format";
+      case ValidationResult::MISSING_REQUIRED_FIELD:
+        return "Missing required field";
+      case ValidationResult::INVALID_FIELD_TYPE:
+        return "Invalid field type";
+      case ValidationResult::INVALID_FIELD_VALUE:
+        return "Invalid field value";
+      case ValidationResult::MESSAGE_TOO_LARGE:
+        return "Message too large";
+      case ValidationResult::INVALID_NODE_ID:
+        return "Invalid node ID";
+      case ValidationResult::RATE_LIMIT_EXCEEDED:
+        return "Rate limit exceeded";
+      default:
+        return "Unknown error";
+    }
+  }
+
+  const ValidationConfig& get_config() const { return config_; }
+  void set_config(const ValidationConfig& config) { config_ = config; }
+
+ private:
+  ValidationConfig config_;
+};
+
+/**
+ * Secure random number generation for mesh operations
+ */
+class SecureRandom {
+ public:
+  /**
+   * Generate a cryptographically secure random number
+   * Falls back to pseudo-random if hardware RNG is not available
+   */
+  static uint32_t generate() {
+#ifdef ESP32
+    return esp_random();
+#elif defined(ESP8266)
+    return RANDOM_REG32;
+#else
+    // Fallback for other platforms - use system rand with better seeding
+    static bool seeded = false;
+    if (!seeded) {
+#ifdef ARDUINO
+      // Arduino-compatible seeding
+      srand(millis() ^ analogRead(A0));
+#else
+      // Non-Arduino platforms with std::chrono
+      auto now = std::chrono::steady_clock::now();
+      auto duration = now.time_since_epoch();
+      uint32_t seed =
+          std::chrono::duration_cast<std::chrono::microseconds>(duration)
+              .count();
+      srand(seed);
+#endif
+      seeded = true;
+    }
+    return ((uint32_t)rand() << 16) | rand();
+#endif
+  }
+
+  /**
+   * Generate random bytes into buffer
+   */
+  static void generate_bytes(uint8_t* buffer, size_t length) {
+    for (size_t i = 0; i < length; i += sizeof(uint32_t)) {
+      uint32_t random_val = generate();
+      size_t copy_len = std::min(sizeof(uint32_t), length - i);
+      memcpy(buffer + i, &random_val, copy_len);
+    }
+  }
+};
+
+}  // namespace validation
+}  // namespace painlessmesh
+
+#endif  // _PAINLESS_MESH_VALIDATION_HPP_