ch/Sesame-Device
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Improve configuration, refactoring

Browse Source
This commit is contained in:
Christoph Hagen 2023-08-09 15:02:24 +02:00
parent b99245085e
commit e84e388521
10 changed files with 235 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
include/controller.h
View File

@ -7,21 +7,50 @@
#include "fresh.h"
#include <ESPAsyncWebServer.h>
struct WifiConfiguration {
// The WiFi network to connect to
const char* ssid;
// The WiFi password to connect to the above network
const char* password;
// The name of the device on the network
const char* networkName;
// The interval to reconnect to WiFi if the connection is broken
uint32_t reconnectInterval;
};
struct KeyConfiguration {
const uint8_t* remoteKey;
const uint8_t* localKey;
};
class SesameController: public ServerConnectionCallbacks {
public:
SesameController(ServerConnection* server, ServoController* servo, AsyncWebServer* local, TimeCheck* timeCheck, uint8_t remoteDeviceCount);
SesameController(uint16_t localWebServerPort, uint8_t remoteDeviceCount);
void configure();
void configure(ServoConfiguration servoConfig, ServerConfiguration serverConfig, TimeConfiguration timeConfig, WifiConfiguration wifiConfig, KeyConfiguration keyConfig);
void loop(uint32_t millis);
private:
ServerConnection* server;
ServoController* servo;
AsyncWebServer* local;
TimeCheck* timeCheck;
ServerConnection server;
ServoController servo;
AsyncWebServer localWebServer;
TimeCheck timeCheck;
Storage storage;
WifiConfiguration wifiConfig;
KeyConfiguration keyConfig;
bool isReconnecting = false;
// The buffer to hold a received message while it is read
uint8_t receivedMessageBuffer[AUTHENTICATED_MESSAGE_SIZE];
@ -31,6 +60,9 @@ private:
AuthenticatedMessage* responseMessage;
uint16_t responseSize = 0;
void ensureWiFiConnection(uint32_t time);
void ensureWebSocketConnection();
void handleLocalMessage(AsyncWebServerRequest *request);
// Based on https://stackoverflow.com/a/23898449/266720
bool convertHexMessageToBinary(const char* str);

6
include/example_config.h
View File

@ -52,11 +52,7 @@ constexpr uint32_t wifiReconnectInterval = 10000;
/* Local server */
// The port for the local server to directly receive messages over WiFi
constexpr uint16_t localPort = 80;
// The url parameter to send the message to the local server
constexpr char messageUrlParameter[] = "m";
constexpr uint16_t localWebServerPort = 80;
/* Server */

77
include/fresh.h
View File

@ -1,7 +1,34 @@
#pragma once
#include <stdint.h>
#include "config.h"
struct TimeConfiguration {
/**
* @brief The timezone offset in seconds
*/
int32_t offsetToGMT;
/**
* @brief The daylight savings offset in seconds
*/
int32_t offsetDaylightSavings;
/**
* @brief The url of the NTP server
*/
const char* ntpServerUrl;
/**
* @brief The allowed discrepancy between the time of a received message
* and the device time (in seconds)
*
* A stricter (lower) value better prevents against replay attacks,
* but may lead to issues when dealing with slow networks and other
* routing delays.
*/
uint32_t allowedTimeOffset;
};
class TimeCheck {
@ -9,26 +36,18 @@ public:
/**
* @brief Create a time checker instance
*
* Specify the allowed discrepancy between the time of a received message
* and the device time (in seconds).
*
* A stricter (lower) value better prevents against replay attacks,
* but may lead to issues when dealing with slow networks and other
* routing delays.
*
* @param offset The allowed time discrepancy in both directions (seconds)
*/
TimeCheck(uint32_t allowedTimeOffset = 60);
TimeCheck();
/**
* @brief Configure an NTP server to get the current time
*
* @param offsetToGMT The timezone offset in seconds
* @param offsetDaylightSavings The daylight savings offset in seconds
* @param serverUrl The url of the NTP server
* @brief Set the configuration
*/
void configureNTP(int32_t offsetToGMT, int32_t offsetDaylightSavings, const char* serverUrl);
void configure(TimeConfiguration configuration);
/**
* @brief Configure the NTP server to get the current time
*/
void startNTP();
/**
* @brief Print the current time to the serial output
@ -42,20 +61,6 @@ public:
*/
uint32_t getEpochTime();
/**
* @brief The allowed time discrepancy (in seconds)
*
* Specifies the allowed discrepancy between the time of a received message
* and the device time (in seconds).
*
* A stricter (lower) value better prevents against replay attacks,
* but may lead to issues when dealing with slow networks and other
* routing delays.
*
* @param offset The offset in both directions (seconds)
*/
void setMessageTimeAllowedOffset(uint32_t offset);
/**
* @brief Check wether the time of a message is within the allowed bounds regarding freshness.
*
@ -71,13 +76,5 @@ public:
private:
/**
* @brief The allowed discrepancy between the time of a received message
* and the device time (in seconds)
*
* A stricter (lower) value better prevents against replay attacks,
* but may lead to issues when dealing with slow networks and other
* routing delays.
*/
uint32_t allowedOffset;
TimeConfiguration config;
};

48
include/server.h
View File

@ -6,6 +6,32 @@
#include <WiFiClientSecure.h>
#include <WebSocketsClient.h>
struct ServerConfiguration {
/**
* @brief The url of the remote server to connect to
*/
const char* url;
/**
* @brief The server port
*/
int port;
/**
* @brief The path on the server
*/
const char* path;
/**
* @brief The authentication key for the server
*/
const char* key;
uint32_t reconnectTime;
};
class ServerConnectionCallbacks {
public:
@ -18,18 +44,18 @@ class ServerConnection {
public:
ServerConnection(const char* url, int port, const char* path);
void connect(const char* key, uint32_t reconnectTime = 5000);
void loop();
ServerConnection();
/**
* @brief Set the handler
* @brief Set the configuration and the callback handler
*
* @param callback The handler to handle messages and errors
*/
void setCallbackHandler(ServerConnectionCallbacks* callbacks);
void configure(ServerConfiguration configuration, ServerConnectionCallbacks* callbacks);
void connect();
void loop();
/**
* @brief Send a response message over the socket
@ -45,13 +71,7 @@ public:
private:
const char* url;
int port;
const char* path;
const char* key = NULL;
ServerConfiguration configuration;
// Indicator that the socket is connected.
bool socketIsConnected = false;

5
include/servo.h
View File

@ -3,7 +3,7 @@
#include <stdint.h>
#include <ESP32Servo.h> // To control the servo
typedef struct ServoConfiguration {
struct ServoConfiguration {
/**
* @brief The timer to use for the servo control
* number 0-3 indicating which timer to allocate in this library
@ -34,6 +34,7 @@ typedef struct ServoConfiguration {
* @brief The servo value (in µs) that specifies the 'released' state
*/
int releasedValue;
};
/**
@ -70,7 +71,7 @@ public:
* There is no required interval to call this function, but the accuracy of
* the opening interval is dependent on the calling frequency.
*/
void loop();
void loop(uint32_t millis);
/**
* Push the door opener button down by moving the servo arm.

77
src/controller.cpp
View File

@ -1,33 +1,58 @@
#include "controller.h"
#include "config.h"
#include "fresh.h"
#include "crypto.h"
#include "config.h"
SesameController::SesameController(ServerConnection* server, ServoController* servo, AsyncWebServer* local, TimeCheck* timeCheck, uint8_t remoteDeviceCount) :
server(server), servo(servo), local(local), timeCheck(timeCheck), storage(remoteDeviceCount) {
#include <WiFi.h>
// The url parameter to send the message to the local server
constexpr char messageUrlParameter[] = "m";
SesameController::SesameController(uint16_t localWebServerPort, uint8_t remoteDeviceCount) :
storage(remoteDeviceCount), localWebServer(localWebServerPort) {
// Set up response buffer
responseStatus = (SesameEvent*) responseBuffer;
responseMessage = (AuthenticatedMessage*) (responseBuffer + 1);
}
void SesameController::configure() {
void SesameController::configure(ServoConfiguration servoConfig, ServerConfiguration serverConfig, TimeConfiguration timeConfig, WifiConfiguration wifiConfig, KeyConfiguration keyConfig) {
this->wifiConfig = wifiConfig;
this->keyConfig = keyConfig;
// Prepare EEPROM for reading and writing
storage.configure();
Serial.println("[INFO] Storage configured");
servo.configure(servoConfig);
Serial.println("[INFO] Servo configured");
// Direct messages and errors over the websocket to the controller
server->setCallbackHandler(this);
server.configure(serverConfig, this);
Serial.println("[INFO] Server connection configured");
timeCheck.configure(timeConfig);
// Direct messages from the local web server to the controller
local->on("/message", HTTP_POST, [this] (AsyncWebServerRequest *request) {
localWebServer.on("/message", HTTP_POST, [this] (AsyncWebServerRequest *request) {
this->handleLocalMessage(request);
this->sendPreparedLocalResponse(request);
});
Serial.println("[INFO] Local web server configured");
//storage.resetMessageCounters();
storage.printMessageCounters();
}
void SesameController::loop(uint32_t millis) {
server.loop();
servo.loop(millis);
ensureWiFiConnection(millis);
ensureWebSocketConnection();
}
// MARK: Local
void
@ -69,7 +94,7 @@ void SesameController::handleServerMessage(uint8_t* payload, size_t length) {
}
void SesameController::sendPreparedServerResponse() {
server->sendResponse(responseBuffer, responseSize);
server.sendResponse(responseBuffer, responseSize);
Serial.printf("[INFO] Server response %u (%u bytes)\n", responseBuffer[0], responseSize);
}
@ -90,7 +115,7 @@ void SesameController::processMessage(AuthenticatedMessage* message) {
* @return The response to signal to the server.
*/
SesameEvent SesameController::verifyAndProcessReceivedMessage(AuthenticatedMessage* message) {
if (!isAuthenticMessage(message, remoteKey, keySize)) {
if (!isAuthenticMessage(message, keyConfig.remoteKey, keySize)) {
return SesameEvent::MessageAuthenticationFailed;
}
if (!storage.isDeviceIdValid(message->message.device)) {
@ -99,13 +124,13 @@ SesameEvent SesameController::verifyAndProcessReceivedMessage(AuthenticatedMessa
if (!storage.isMessageCounterValid(message->message.id, message->message.device)) {
return SesameEvent::MessageCounterInvalid;
}
if (!timeCheck->isMessageTimeAcceptable(message->message.time)) {
if (!timeCheck.isMessageTimeAcceptable(message->message.time)) {
return SesameEvent::MessageTimeMismatch;
}
storage.didUseMessageCounter(message->message.id, message->message.device);
// Move servo
servo->pressButton();
servo.pressButton();
Serial.printf("[Info] Accepted message %d\n", message->message.id);
return SesameEvent::MessageAccepted;
}
@ -127,16 +152,42 @@ uint16_t SesameController::prepareResponseBuffer(SesameEvent event, uint8_t devi
if (!allowMessageResponse(event)) {
return 1;
}
responseMessage->message.time = timeCheck->getEpochTime();
responseMessage->message.time = timeCheck.getEpochTime();
responseMessage->message.id = storage.getNextMessageCounter(deviceId);
responseMessage->message.device = deviceId;
if (!authenticateMessage(responseMessage, localKey, keySize)) {
if (!authenticateMessage(responseMessage, keyConfig.localKey, keySize)) {
*responseStatus = SesameEvent::InvalidResponseAuthentication;
return 1;
}
return 1 + AUTHENTICATED_MESSAGE_SIZE;
}
// MARK: Reconnecting
void SesameController::ensureWiFiConnection(uint32_t millis) {
static uint32_t nextWifiReconnect = 0;
// Reconnect to WiFi
if(millis > nextWifiReconnect && WiFi.status() != WL_CONNECTED) {
Serial.println("[INFO] Reconnecting WiFi...");
WiFi.setHostname(wifiConfig.networkName);
WiFi.begin(wifiConfig.ssid, wifiConfig.password);
isReconnecting = true;
nextWifiReconnect = millis + wifiConfig.reconnectInterval;
}
}
void SesameController::ensureWebSocketConnection() {
if (isReconnecting && WiFi.status() == WL_CONNECTED) {
isReconnecting = false;
Serial.print("WiFi IP address: ");
Serial.println(WiFi.localIP());
server.connect();
timeCheck.startNTP();
timeCheck.printLocalTime();
localWebServer.begin();
}
}
// MARK: Helper
// Based on https://stackoverflow.com/a/23898449/266720

14
src/fresh.cpp
View File

@ -3,12 +3,14 @@
#include <Arduino.h> // configTime()
#include <time.h>
TimeCheck::TimeCheck(uint32_t allowedTimeOffset) {
allowedOffset = allowedTimeOffset;
TimeCheck::TimeCheck() { }
void TimeCheck::configure(TimeConfiguration configuration) {
config = configuration;
}
void TimeCheck::configureNTP(int32_t offsetToGMT, int32_t offsetDaylightSavings, const char* serverUrl) {
configTime(offsetToGMT, offsetDaylightSavings, serverUrl);
void TimeCheck::startNTP() {
configTime(config.offsetToGMT, config.offsetDaylightSavings, config.ntpServerUrl);
}
void TimeCheck::printLocalTime() {
@ -37,10 +39,10 @@ bool TimeCheck::isMessageTimeAcceptable(uint32_t t) {
Serial.println("No epoch time available");
return false;
}
if (t > localTime + allowedOffset) {
if (t > localTime + config.allowedTimeOffset) {
return false;
}
if (t < localTime - allowedOffset) {
if (t < localTime - config.allowedTimeOffset) {
return false;
}
return true;

102
src/main.cpp
View File

@ -6,87 +6,61 @@
* physical button.
*/
#include <Arduino.h>
#include <WiFi.h>
#include <ESPAsyncWebServer.h>
#include "crypto.h"
#include "fresh.h"
#include "message.h"
#include "server.h"
#include "servo.h"
#include "config.h"
#include "controller.h"
#include "config.h"
/* Global variables */
TimeCheck timeCheck{};
ServerConnection server(serverUrl, serverPort, serverPath);
ServoController servo{};
AsyncWebServer local(localPort);
SesameController controller(&server, &servo, &local, &timeCheck, remoteDeviceCount);
// Forward declare monitoring functions
void ensureWiFiConnection(uint32_t time);
void ensureWebSocketConnection(uint32_t time);
/* Logic */
SesameController controller(localWebServerPort, remoteDeviceCount);
void setup() {
Serial.begin(serialBaudRate);
Serial.setDebugOutput(true);
Serial.println("[INFO] Device started");
ServoConfiguration servoConfig;
servoConfig.pwmTimer = pwmTimer;
servoConfig.pwmFrequency = servoFrequency;
servoConfig.pin = servoPin;
servoConfig.openDuration = lockOpeningDuration;
servoConfig.pressedValue = servoPressedState;
servoConfig.releasedValue = servoReleasedState;
ServoConfiguration servoConfig {
.pwmTimer = pwmTimer,
.pwmFrequency = servoFrequency,
.pin = servoPin,
.openDuration = lockOpeningDuration,
.pressedValue = servoPressedState,
.releasedValue = servoReleasedState,
};
servo.configure(servoConfig);
Serial.println("[INFO] Servo configured");
ServerConfiguration serverConfig {
.url = serverUrl,
.port = serverPort,
.path = serverPath,
.key = serverAccessKey,
.reconnectTime = 5000,
};
controller.configure();
TimeConfiguration timeConfig {
.offsetToGMT = timeOffsetToGMT,
.offsetDaylightSavings = timeOffsetDaylightSavings,
.ntpServerUrl = ntpServerUrl,
.allowedTimeOffset = 60,
};
WifiConfiguration wifiConfig {
.ssid = wifiSSID,
.password = wifiPassword,
.networkName = networkName,
.reconnectInterval = wifiReconnectInterval,
};
KeyConfiguration keyConfig {
.remoteKey = remoteKey,
.localKey = localKey,
};
controller.configure(servoConfig, serverConfig, timeConfig, wifiConfig, keyConfig);
}
void loop() {
uint32_t time = millis();
server.loop();
servo.loop();
ensureWiFiConnection(time);
ensureWebSocketConnection(time);
}
uint32_t nextWifiReconnect = 0;
bool isReconnecting = false;
void ensureWiFiConnection(uint32_t time) {
// Reconnect to WiFi
if(time > nextWifiReconnect && WiFi.status() != WL_CONNECTED) {
Serial.println("[INFO] Reconnecting WiFi...");
WiFi.setHostname(networkName);
WiFi.begin(wifiSSID, wifiPassword);
isReconnecting = true;
nextWifiReconnect = time + wifiReconnectInterval;
}
}
void ensureWebSocketConnection(uint32_t time) {
if (isReconnecting && WiFi.status() == WL_CONNECTED) {
isReconnecting = false;
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
Serial.println("[INFO] WiFi connected, opening socket");
server.connect(serverAccessKey);
timeCheck.configureNTP(timeOffsetToGMT, timeOffsetDaylightSavings, ntpServerUrl);
timeCheck.printLocalTime();
local.begin();
}
controller.loop(time);
}

19
src/server.cpp
View File

@ -4,12 +4,14 @@ constexpr int32_t pingInterval = 10000;
constexpr uint32_t pongTimeout = 5000;
uint8_t disconnectTimeoutCount = 3;
ServerConnection::ServerConnection(const char* url, int port, const char* path) :
url(url), port(port), path(path) {
ServerConnection::ServerConnection() { }
void ServerConnection::configure(ServerConfiguration configuration, ServerConnectionCallbacks *callbacks) {
controller = callbacks;
this->configuration = configuration;
}
void ServerConnection::connect(const char* key, uint32_t reconnectTime) {
void ServerConnection::connect() {
if (socketIsConnected) {
return;
}
@ -17,25 +19,20 @@ void ServerConnection::connect(const char* key, uint32_t reconnectTime) {
Serial.println("[ERROR] No callbacks set for server");
return;
}
this->key = key;
webSocket.beginSSL(url, port, path);
webSocket.beginSSL(configuration.url, configuration.port, configuration.path);
std::function<void(WStype_t, uint8_t *, size_t)> f = [this](WStype_t type, uint8_t *payload, size_t length) {
this->webSocketEventHandler(type, payload, length);
};
webSocket.onEvent(f);
webSocket.setReconnectInterval(reconnectTime);
webSocket.setReconnectInterval(configuration.reconnectTime);
}
void ServerConnection::loop() {
webSocket.loop();
}
void ServerConnection::setCallbackHandler(ServerConnectionCallbacks* callbacks) {
controller = callbacks;
}
void ServerConnection::webSocketEventHandler(WStype_t type, uint8_t * payload, size_t length) {
switch(type) {
case WStype_DISCONNECTED:
@ -44,7 +41,7 @@ switch(type) {
break;
case WStype_CONNECTED:
socketIsConnected = true;
webSocket.sendTXT(key);
webSocket.sendTXT(configuration.key);
Serial.printf("[INFO] Socket connected to url: %s\n", payload);
webSocket.enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
break;

4
src/servo.cpp
View File

@ -25,8 +25,8 @@ void ServoController::releaseButton() {
buttonIsPressed = false;
}
void ServoController::loop() {
if (buttonIsPressed && millis() > openingEndTime) {
void ServoController::loop(uint32_t millis) {
if (buttonIsPressed && millis > openingEndTime) {
releaseButton();
}
}