HS-Esslingen/esp-firewall
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

introduce namespace

Browse source
This commit is contained in:
Florian Hoss 2022-04-20 13:08:12 +02:00
parent 73533e5d15
commit beddd88653
7 changed files with 459 additions and 415 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
SourceCode/arduino/lib/Firewall/esp32Eeprom.cpp
View file

@ -1,11 +1,26 @@
#include "esp32Eeprom.hpp"
esp32Eeprom::esp32Eeprom(const uint16_t eeprom_size)
namespace firewall
{
Storage::Storage(const uint16_t eeprom_size)
{
this->eeprom_size = eeprom_size;
EEPROM.begin(this->eeprom_size);
}
set_amount_of_firewall_rules(EEPROM.read(this->settings_head));
log_i("Amount of Rules: %i", get_amount_of_firewall_rules());
}
esp32Eeprom::~esp32Eeprom()
{
Storage::~Storage()
{
}
uint8_t Storage::get_amount_of_firewall_rules()
{
return this->amount_of_rules;
}
void Storage::set_amount_of_firewall_rules(const uint8_t new_amount)
{
this->amount_of_rules = new_amount;
}
}

27
SourceCode/arduino/lib/Firewall/esp32Eeprom.hpp
View file

@ -2,15 +2,30 @@
#define ESP32_EEPROM_HPP
#include "EEPROM.h"
#include "FirewallTypes.h"
class esp32Eeprom
namespace firewall
{
private:
class Storage
{
private:
uint16_t eeprom_size;
uint16_t settings_start = 0;
uint16_t settings_head = settings_start;
uint16_t rules_start = 1000;
uint16_t rules_head = rules_start;
uint16_t certificate_start = 3000;
uint16_t certificate_head = certificate_start;
public:
esp32Eeprom(const uint16_t);
~esp32Eeprom();
};
protected:
uint8_t amount_of_rules;
uint8_t get_amount_of_firewall_rules();
void set_amount_of_firewall_rules(const uint8_t);
public:
Storage(const uint16_t = 4000);
~Storage();
};
}
#endif

83
SourceCode/arduino/lib/Firewall/esp32Firewall.cpp
View file

@ -1,16 +1,18 @@
#include "esp32Firewall.hpp"
esp32Firewall::esp32Firewall()
namespace firewall
{
esp32Firewall::esp32Firewall()
{
this->setup_eeprom();
}
}
esp32Firewall::~esp32Firewall()
{
}
esp32Firewall::~esp32Firewall()
{
}
String esp32Firewall::protocol_to_string(firewall_protocol_t &protocol)
{
String esp32Firewall::protocol_to_string(firewall_protocol_t &protocol)
{
switch (protocol)
{
case FW_TCP:
@ -20,20 +22,20 @@ String esp32Firewall::protocol_to_string(firewall_protocol_t &protocol)
default:
return "ALL";
}
}
}
firewall_protocol_t esp32Firewall::string_to_protocol(std::string &protocol)
{
firewall_protocol_t esp32Firewall::string_to_protocol(std::string &protocol)
{
if (protocol.compare("TCP") == 0)
return FW_TCP;
else if (protocol.compare("UDP") == 0)
return FW_UDP;
else
return FW_ALL;
}
}
String esp32Firewall::target_to_string(firewall_target_t &target)
{
String esp32Firewall::target_to_string(firewall_target_t &target)
{
switch (target)
{
case FW_REJECT:
@ -43,20 +45,20 @@ String esp32Firewall::target_to_string(firewall_target_t &target)
default:
return "ACCEPT";
}
}
}
firewall_target_t esp32Firewall::string_to_target(std::string &target)
{
firewall_target_t esp32Firewall::string_to_target(std::string &target)
{
if (target.compare("REJECT") == 0)
return FW_REJECT;
else if (target.compare("DROP") == 0)
return FW_DROP;
else
return FW_ACCEPT;
}
}
void esp32Firewall::setup_eeprom()
{
void esp32Firewall::setup_eeprom()
{
EEPROM.begin(this->eeprom_size);
this->amount_of_rules = EEPROM.read(this->eeprom_settings_head);
uint8_t security_number = EEPROM.read(this->eeprom_settings_head + 1);
@ -69,10 +71,10 @@ void esp32Firewall::setup_eeprom()
}
log_i("Amount of existing Rules %i", this->amount_of_rules);
this->eeprom_read_firewall_rules();
}
}
void esp32Firewall::eeprom_write_firewall_rule(firewall_rule_t *rule_ptr)
{
void esp32Firewall::eeprom_write_firewall_rule(firewall_rule_t *rule_ptr)
{
EEPROM.write(this->eeprom_settings_head, this->amount_of_rules);
EEPROM.writeString(this->eeprom_rules_head, rule_ptr->source);
this->eeprom_rules_head += IPV4ADDRESS_LENGTH;
@ -83,10 +85,10 @@ void esp32Firewall::eeprom_write_firewall_rule(firewall_rule_t *rule_ptr)
EEPROM.write(this->eeprom_rules_head, rule_ptr->target);
this->eeprom_rules_head += sizeof(firewall_target_t);
EEPROM.commit();
}
}
void esp32Firewall::eeprom_write_firewall_rules()
{
void esp32Firewall::eeprom_write_firewall_rules()
{
this->eeprom_rules_head = eeprom_start_firewall_rules;
firewall_rule_t *rule_ptr = this->head;
while (rule_ptr != NULL)
@ -94,10 +96,10 @@ void esp32Firewall::eeprom_write_firewall_rules()
this->eeprom_write_firewall_rule(rule_ptr);
rule_ptr = rule_ptr->next;
}
}
}
void esp32Firewall::eeprom_read_firewall_rule(uint8_t &eeprom_address, uint8_t &rule_nr)
{
void esp32Firewall::eeprom_read_firewall_rule(uint8_t &eeprom_address, uint8_t &rule_nr)
{
firewall_rule_t *rule_ptr = (firewall_rule_t *)malloc(sizeof(firewall_rule_t));
rule_ptr->key = rule_nr;
strcpy(rule_ptr->source, EEPROM.readString(eeprom_address).c_str());
@ -114,19 +116,19 @@ void esp32Firewall::eeprom_read_firewall_rule(uint8_t &eeprom_address, uint8_t &
rule_ptr->destination,
protocol_to_string(rule_ptr->protocol),
target_to_string(rule_ptr->target));
}
}
void esp32Firewall::eeprom_read_firewall_rules()
{
void esp32Firewall::eeprom_read_firewall_rules()
{
uint8_t eeprom_address = eeprom_start_firewall_rules;
for (uint8_t i = 1; i <= this->amount_of_rules; i++)
{
eeprom_read_firewall_rule(eeprom_address, i);
}
}
}
void esp32Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
{
void esp32Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
{
firewall_rule_t *temp;
if (this->head == NULL)
{
@ -142,10 +144,10 @@ void esp32Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
temp->next = rule_ptr;
rule_ptr->next = NULL;
return;
}
}
firewall_rule_t *esp32Firewall::get_rule_from_firewall(uint8_t key)
{
firewall_rule_t *esp32Firewall::get_rule_from_firewall(uint8_t key)
{
firewall_rule_t *rule_ptr = this->head;
if (this->head == NULL)
{
@ -163,10 +165,10 @@ firewall_rule_t *esp32Firewall::get_rule_from_firewall(uint8_t key)
}
}
return rule_ptr;
}
}
bool esp32Firewall::delete_rule_from_firewall(uint8_t key)
{
bool esp32Firewall::delete_rule_from_firewall(uint8_t key)
{
if (this->head == NULL)
{
return false;
@ -205,4 +207,5 @@ bool esp32Firewall::delete_rule_from_firewall(uint8_t key)
this->amount_of_rules--;
this->eeprom_write_firewall_rules();
return true;
}
}

13
SourceCode/arduino/lib/Firewall/esp32Firewall.hpp
View file

@ -6,9 +6,11 @@
#define eeprom_start_firewall_rules 4
class esp32Firewall
namespace firewall
{
private:
class esp32Firewall
{
private:
uint16_t eeprom_size = 512;
uint8_t security_number = 93;
int eeprom_settings_head = 0;
@ -19,7 +21,7 @@ private:
void eeprom_read_firewall_rule(uint8_t &, uint8_t &);
void eeprom_read_firewall_rules();
protected:
protected:
uint8_t amount_of_rules = 0;
struct firewall_rule *head = NULL;
@ -34,9 +36,10 @@ protected:
String target_to_string(firewall_target_t &);
firewall_target_t string_to_target(std::string &);
public:
public:
esp32Firewall();
~esp32Firewall();
};
};
}
#endif

95
SourceCode/arduino/lib/Firewall/esp32FirewallAPI.cpp
View file

@ -1,7 +1,9 @@
#include "esp32FirewallAPI.hpp"
esp32FirewallApi::esp32FirewallApi(const uint16_t port)
namespace firewall
{
esp32FirewallApi::esp32FirewallApi(const uint16_t port)
{
this->setup_certificate();
this->server = new HTTPSServer(this->certificate, port, 5);
this->setup_routing();
@ -11,19 +13,19 @@ esp32FirewallApi::esp32FirewallApi(const uint16_t port)
{
log_i("Server ready.");
}
}
}
esp32FirewallApi::~esp32FirewallApi()
{
}
esp32FirewallApi::~esp32FirewallApi()
{
}
void esp32FirewallApi::handle_clients()
{
void esp32FirewallApi::handle_clients()
{
this->server->loop();
}
}
void esp32FirewallApi::setup_certificate()
{
void esp32FirewallApi::setup_certificate()
{
log_i("Creating the certificate...");
this->certificate = new SSLCert();
int createCertResult = createSelfSignedCert(
@ -39,10 +41,10 @@ void esp32FirewallApi::setup_certificate()
delay(500);
}
log_i("Creating the certificate was successful");
}
}
void esp32FirewallApi::setup_routing()
{
void esp32FirewallApi::setup_routing()
{
ResourceNode *get_firewall_rule = new ResourceNode("/api/v1/firewall/*", "GET", std::bind(&esp32FirewallApi::get_firewall_rule_handler, this, std::placeholders::_1, std::placeholders::_2));
ResourceNode *get_firewall_rules = new ResourceNode("/api/v1/firewall", "GET", std::bind(&esp32FirewallApi::get_firewall_rules_handler, this, std::placeholders::_1, std::placeholders::_2));
ResourceNode *post_firewall = new ResourceNode("/api/v1/firewall", "POST", std::bind(&esp32FirewallApi::post_firewall_handler, this, std::placeholders::_1, std::placeholders::_2));
@ -55,22 +57,22 @@ void esp32FirewallApi::setup_routing()
this->server->registerNode(delete_firewall);
this->server->registerNode(restart_device);
this->server->setDefaultNode(not_found);
}
}
void esp32FirewallApi::restart_device_handler(HTTPRequest *request, HTTPResponse *response)
{
void esp32FirewallApi::restart_device_handler(HTTPRequest *request, HTTPResponse *response)
{
this->json_message_response(response, "restarting device in 2 sec", 200);
sleep(2000);
esp_restart();
}
}
void esp32FirewallApi::not_found_handler(HTTPRequest *request, HTTPResponse *response)
{
void esp32FirewallApi::not_found_handler(HTTPRequest *request, HTTPResponse *response)
{
this->json_message_response(response, "not found", 404);
}
}
void esp32FirewallApi::get_firewall_rule_handler(HTTPRequest *request, HTTPResponse *response)
{
void esp32FirewallApi::get_firewall_rule_handler(HTTPRequest *request, HTTPResponse *response)
{
ResourceParameters *params = request->getParams();
int rule_number = atoi(params->getPathParameter(0).c_str());
firewall_rule_t *rule_ptr = this->get_rule_from_firewall(rule_number);
@ -84,20 +86,20 @@ void esp32FirewallApi::get_firewall_rule_handler(HTTPRequest *request, HTTPRespo
response->setStatusCode(200);
response->print(this->construct_json_firewall_rule(rule_ptr));
}
}
}
void esp32FirewallApi::get_firewall_rules_handler(HTTPRequest *request, HTTPResponse *response)
{
void esp32FirewallApi::get_firewall_rules_handler(HTTPRequest *request, HTTPResponse *response)
{
this->json_generic_response(response, this->construct_json_firewall(), 200);
}
}
bool esp32FirewallApi::request_has_firewall_parameter(ResourceParameters *params)
{
bool esp32FirewallApi::request_has_firewall_parameter(ResourceParameters *params)
{
return params->isQueryParameterSet("source") || params->isQueryParameterSet("destination") || params->isQueryParameterSet("protocol") || params->isQueryParameterSet("target");
}
}
void esp32FirewallApi::post_firewall_handler(HTTPRequest *request, HTTPResponse *response)
{
void esp32FirewallApi::post_firewall_handler(HTTPRequest *request, HTTPResponse *response)
{
ResourceParameters *params = request->getParams();
if (request_has_firewall_parameter(params))
{
@ -127,10 +129,10 @@ void esp32FirewallApi::post_firewall_handler(HTTPRequest *request, HTTPResponse
{
this->json_message_response(response, "not enough parameter", 400);
}
}
}
void esp32FirewallApi::delete_firewall_handler(HTTPRequest *request, HTTPResponse *response)
{
void esp32FirewallApi::delete_firewall_handler(HTTPRequest *request, HTTPResponse *response)
{
ResourceParameters *params = request->getParams();
int rule_number = atoi(params->getPathParameter(0).c_str());
if (this->delete_rule_from_firewall(rule_number))
@ -141,17 +143,17 @@ void esp32FirewallApi::delete_firewall_handler(HTTPRequest *request, HTTPRespons
{
this->json_message_response(response, "cannot delete firewall rule", 500);
}
}
}
void esp32FirewallApi::json_generic_response(HTTPResponse *response, String serialized, const uint16_t response_code)
{
void esp32FirewallApi::json_generic_response(HTTPResponse *response, String serialized, const uint16_t response_code)
{
response->setHeader("Content-Type", "application/json");
response->setStatusCode(response_code);
response->println(serialized);
}
}
void esp32FirewallApi::json_message_response(HTTPResponse *response, String message, const uint16_t response_code)
{
void esp32FirewallApi::json_message_response(HTTPResponse *response, String message, const uint16_t response_code)
{
response->setHeader("Content-Type", "application/json");
response->setStatusCode(response_code);
StaticJsonDocument<96> json;
@ -159,10 +161,10 @@ void esp32FirewallApi::json_message_response(HTTPResponse *response, String mess
json["message"] = message;
serializeJson(json, serialized);
response->println(serialized);
}
}
String esp32FirewallApi::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
{
String esp32FirewallApi::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
{
StaticJsonDocument<256> doc;
doc["key"] = rule_ptr->key;
doc["source"] = rule_ptr->source;
@ -172,10 +174,10 @@ String esp32FirewallApi::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
String response;
serializeJson(doc, response);
return response;
}
}
String esp32FirewallApi::construct_json_firewall()
{
String esp32FirewallApi::construct_json_firewall()
{
firewall_rule_t *rule_ptr = this->head;
// Size for approx. 12 Rules
StaticJsonDocument<2048> doc;
@ -194,4 +196,5 @@ String esp32FirewallApi::construct_json_firewall()
}
serializeJson(doc, response);
return response;
}
}

11
SourceCode/arduino/lib/Firewall/esp32FirewallAPI.hpp
View file

@ -11,9 +11,11 @@
using namespace httpsserver;
class esp32FirewallApi : public esp32Firewall
namespace firewall
{
private:
class esp32FirewallApi : public esp32Firewall
{
private:
HTTPSServer *server;
SSLCert *certificate;
@ -32,10 +34,11 @@ private:
String construct_json_firewall_rule(firewall_rule_t *);
String construct_json_firewall();
public:
public:
esp32FirewallApi(const uint16_t = 8080);
~esp32FirewallApi();
void handle_clients();
};
};
}
#endif

10
SourceCode/arduino/src/main.cpp
View file

@ -1,10 +1,11 @@
#include "theSecrets.h"
#include "WiFi.h"
#include "esp32Firewall.hpp"
#include "esp32FirewallAPI.hpp"
#include "esp32Eeprom.hpp"
esp32FirewallApi *firewall_api;
firewall::esp32FirewallApi *firewall_api;
firewall::Storage *storage;
void setup_wifi()
{
@ -24,10 +25,11 @@ void setup_wifi()
void setup()
{
setup_wifi();
firewall_api = new esp32FirewallApi;
// firewall_api = new esp32FirewallApi;
storage = new firewall::Storage;
}
void loop()
{
firewall_api->handle_clients();
// firewall_api->handle_clients();
}