EepromSecureData.h

/*
   Copyright (C) 2023 epsilonrt <epsilonrt@gmail.com>
   SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include <EEPROM.h>
#include <assert.h>
#include <stdio.h>
#if defined(ESP32) && __has_include(<Preferences.h>)
#include <Preferences.h>
#endif
#include "CrcIButton.h"
#include "EepromBase.h"
#pragma once
 
enum class EepromSecureBackend : uint8_t {
  Auto,
  EEPROM,
  Preferences
};
 
template <class T>
class EepromSecureData {
 
  public:
    EepromSecureData (EepromSecureBackend backend = EepromSecureBackend::Auto, bool crcEnabled = true) :
      m_backend (resolveBackend (backend)), m_crcEnabled (crcEnabled), m_eem (EepromBase::counter) {
      EepromBase::counter += size();
      // assert (EepromBase::counter < EEPROM.length());
    }
 
    EepromSecureData (const T &data, EepromSecureBackend backend = EepromSecureBackend::Auto, bool crcEnabled = true) :
      EepromSecureData (backend, crcEnabled) {
      m_data = data;
    }
 
    ~EepromSecureData() {
      save();
    }
 
    bool save() {
 
      updateCrc();
      if (m_backend == EepromSecureBackend::Preferences) {
 
        #if defined(ESP32) && __has_include(<Preferences.h>)
        return saveToPreferences();
        #else
        return false;
        #endif
      }
      return saveToEeprom();
    }
 
    bool load (const T &defaultData = T()) {
 
      bool loaded = false;
      uint8_t crc = 0;
 
      if (m_backend == EepromSecureBackend::Preferences) {
 
        #if defined(ESP32) && __has_include(<Preferences.h>)
        loaded = loadFromPreferences (crc);
        #endif
      }
      else {
 
        loaded = loadFromEeprom (crc);
      }
 
      if (!loaded) {
        m_data = defaultData;
        updateCrc();
        save();
        return false;
      }
      updateCrc();
 
      if (m_crcEnabled && (m_crc.value () != crc)) {
        m_data = defaultData;
        updateCrc();
        save();
        return false;
      }
      return true;
    }
 
    void setCrcEnabled (bool enabled) {
      m_crcEnabled = enabled;
    }
 
    bool crcEnabled() const {
      return m_crcEnabled;
    }
 
    EepromSecureBackend backend() const {
      return m_backend;
    }
 
    inline uint16_t size() const {
      return sizeof (T) + sizeof (m_crc);
    }
 
    T &data() {
      return m_data;
    }
 
    const T &data() const {
      return m_data;
    }
 
    operator T &() {
      return m_data;
    }
 
    operator const T &() const {
      return m_data;
    }
 
    T *operator&() {
      return & m_data;
    }
 
    const T *operator&() const {
      return & m_data;
    }
 
    T &operator= (const T &t) {
      m_data = t;
      updateCrc();
      return m_data;
    }
 
    EepromSecureData &operator = (const EepromSecureData &rhs) {
      m_data = rhs.m_data;
      return *this;
    }
 
    bool  operator == (const EepromSecureData &rhs) const {
      return m_data == rhs.m_data;
    }
 
    bool  operator != (const EepromSecureData &rhs) const {
      return ! (*this == rhs);
    }
 
  protected:
    bool saveToEeprom () {
      EEPROM.put (m_eem, m_data);
      EEPROM.write (m_eem + sizeof (T), storedCrcValue());
      #if defined(ESP32) || defined(ESP8266)
      return EEPROM.commit();
      #else
      return true;
      #endif
    }
 
    bool loadFromEeprom (uint8_t &crc) {
      EEPROM.get (m_eem, m_data);
      crc = EEPROM.read (m_eem + sizeof (T));
      return true;
    }
 
    #if defined(ESP32) && __has_include(<Preferences.h>)
    bool saveToPreferences () {
      Preferences prefs;
      if (!prefs.begin (kNamespace, false)) {
        return false;
      }
 
      char dataKey[16];
      char crcKey[16];
      makeKeys (dataKey, crcKey, sizeof (dataKey), sizeof (crcKey));
 
      size_t bytes = prefs.putBytes (dataKey, &m_data, sizeof (T));
      size_t crcBytes = prefs.putUChar (crcKey, storedCrcValue());
      prefs.end();
      return (bytes == sizeof (T)) && (crcBytes == 1);
    }
 
    bool loadFromPreferences (uint8_t &crc) {
      Preferences prefs;
      if (!prefs.begin (kNamespace, true)) {
        return false;
      }
 
      char dataKey[16];
      char crcKey[16];
      makeKeys (dataKey, crcKey, sizeof (dataKey), sizeof (crcKey));
 
      size_t expected = sizeof (T);
      size_t storedLen = prefs.getBytesLength (dataKey);
      if (storedLen != expected) {
        prefs.end();
        return false;
      }
 
      size_t bytes = prefs.getBytes (dataKey, &m_data, sizeof (T));
      crc = prefs.getUChar (crcKey, kMissingCrcValue);
      prefs.end();
      if (bytes != sizeof (T)) {
        return false;
      }
      if (!m_crcEnabled) {
        return true;
      }
      return crc != kMissingCrcValue;
    }
 
    void makeKeys (char *dataKey, char *crcKey, size_t dataKeySize, size_t crcKeySize) const {
      snprintf (dataKey, dataKeySize, "d%u", static_cast<unsigned> (m_eem));
      snprintf (crcKey, crcKeySize, "c%u", static_cast<unsigned> (m_eem));
    }
    #endif
 
    static EepromSecureBackend resolveBackend (EepromSecureBackend backend) {
      if (backend == EepromSecureBackend::Auto) {
        #if defined(ESP32) && __has_include(<Preferences.h>)
        return EepromSecureBackend::Preferences;
        #else
        return EepromSecureBackend::EEPROM;
        #endif
      }
 
      #if defined(ESP32) && __has_include(<Preferences.h>)
      return backend;
      #else
      if (backend == EepromSecureBackend::Preferences) {
        return EepromSecureBackend::EEPROM;
      }
      return backend;
      #endif
    }
 
    uint8_t storedCrcValue () const {
      if (!m_crcEnabled) {
        return kCrcDisabledValue;
      }
      return m_crc.value();
    }
 
    // update CRC
    void updateCrc () {
      m_crc.reset ();
      m_crc.update (m_data);
    }
 
  protected:
    static constexpr const char *kNamespace = "EepSecData";
    static constexpr uint8_t kMissingCrcValue = 0xFF;
    static constexpr uint8_t kCrcDisabledValue = 0xA5;
    EepromSecureBackend m_backend;
    bool m_crcEnabled;
    uint16_t m_eem; // EEPROM memory address of the object
    T m_data; // data object itself (RAM)
    CrcIButton <T> m_crc; // CRC object
};