Commit b79ed7e9 authored by YannGarcia's avatar YannGarcia
Browse files

Validate execution of the second AtsMBR test case

parent 90d14af5

ccsrc/Protocols/Security/certificates_loader.cc

+18 −7
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ certificates_loader *certificates_loader::instance = nullptr; 


certificates_loader::certificates_loader()

  : _certificateExt{".oer"}, _privateKeyExt{".vkey"}, _privateEncKeyExt{".ekey"},

    _full_path(), _is_cache_initialized{false}, _directory_filter{".svn", "._.DS_Store", ".DS_Store"}, _hashed_id8s() {

    _full_path(), _is_cache_initialized{false}, _directory_filter{".svn", "._.DS_Store", ".DS_Store"}, _hashed_id8s(), _certificates_idx() {

  // loggers::get_instance().log(">>> certificates_loader::certificates_loader");

} // End of ctor
@@ -76,7 +76,7 @@ int certificates_loader::build_path(const std::string &p_root_directory) { 
  return 0;

} // End of method build_path



int certificates_loader::build_certificates_index(std::map<std::string, const OCTETSTRING> &p_certificates_idx) {

int certificates_loader::build_certificates_index() { // FIXME FSCOM Merge build_path and build_certificates_index methods in one

  loggers::get_instance().log(">>> certificates_loader::build_certificates_index");



  // Sanity check
@@ -101,12 +101,16 @@ int certificates_loader::build_certificates_index(std::map<std::string, const OC 
    p = certificate;

    certificate = p.stem();

    // Update index maps

    std::pair<std::map<std::string, const OCTETSTRING>::iterator, bool> result = p_certificates_idx.insert(std::pair<std::string, const OCTETSTRING>(certificate, h));

    if (result.second == false) {

      loggers::get_instance().warning("certificates_loader::build_certificates_index: Failed to insert new record '%s'", certificate.c_str());

    std::pair<std::map<OCTETSTRING, const std::string>::iterator, bool> r1 = _hashed_id8s.insert(std::pair<OCTETSTRING, const std::string>(h, certificate));

    if (r1.second == false) {

      loggers::get_instance().warning("certificates_loader::build_certificates_index (1): Failed to insert new record '%s'", certificate.c_str());

      continue;

    }

    std::pair<std::map<std::string, const OCTETSTRING>::iterator, bool> r2 = _certificates_idx.insert(std::pair<std::string, const OCTETSTRING>(certificate, h));

    if (r2.second == false) {

      loggers::get_instance().warning("certificates_loader::build_certificates_index (2): Failed to insert new record '%s'", certificate.c_str());

      continue;

    }

    _hashed_id8s.insert(std::pair<OCTETSTRING, const std::string>(h, certificate));

  } // End of 'while' statement

   is.close();
@@ -119,8 +123,12 @@ std::map<OCTETSTRING, const std::string, security_cache_comp>& certificates_load 
  return _hashed_id8s;

}



std::map<std::string, const OCTETSTRING>& certificates_loader::get_certificates() {

  return _certificates_idx;

}



int certificates_loader::load_certificate(const OCTETSTRING& p_hashed_id8, const std::string p_certificate_name, std::map<std::string, std::unique_ptr<const security_db_record>> & p_certificates) {

  loggers::get_instance().log_msg(">>> certificates_loader::load_certificate", p_hashed_id8);

  loggers::get_instance().log_msg(">>> certificates_loader::load_certificate: ", p_hashed_id8);

  loggers::get_instance().log(">>> certificates_loader::load_certificate: '%s'", p_certificate_name.c_str());



  std::experimental::filesystem::path p = _full_path.string() + "/" + p_certificate_name + _certificateExt;
@@ -480,6 +488,9 @@ int certificates_loader::save_certificate(const security_db_record &p_certificat 
                                                    std::experimental::filesystem::perms::group_all | std::experimental::filesystem::perms::others_all);

  }



  _hashed_id8s.insert(std::pair<OCTETSTRING, const std::string>(p_certificate.hashed_id(), p_certificate.certificate_id()));

  _certificates_idx.insert(std::pair<std::string, const OCTETSTRING>(p_certificate.certificate_id(), p_certificate.hashed_id()));



  return 0;

} // End of method save_certificate

ccsrc/Protocols/Security/certificates_loader.hh

+19 −13
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ class certificates_loader { 
  static certificates_loader *        instance;               //! Unique static object reference of this class

  std::map<OCTETSTRING, const std::string, security_cache_comp>    _hashed_id8s;  

                                                              //! List of the certificates indexed by the HashedId8

  std::map<std::string, const OCTETSTRING> _certificates_idx; //! List of the certificates indexed by the certificate identifier



  /*!

   * \brief Default private ctor
@@ -56,6 +57,7 @@ class certificates_loader { 
   */

  ~certificates_loader() {

    _hashed_id8s.clear();

    _certificates_idx.clear();

    if (instance != NULL) {

      delete instance;

      instance = NULL;
@@ -80,13 +82,11 @@ public: /*! \publicsection */ 
   */

  int build_path(const std::string &p_root_directory);

  /*!

   * \fn int build_certificates_index(std::map<std::string, OCTETSTRING> &p_certificates_idx);

   * \fn int build_certificates_index();

   * \brief Store in memory the index of the certitifcates as a tuple {HashedId8, Certificate Name}

   * \param[in] p_certificates_idx Memory stored index, key is the certificate name

   * \param[in] p_hashed_id8s Memory stored index, key is the HashedId8

   * \return 0 on success, -1 otherwise

   */

  int build_certificates_index(std::map<std::string, const OCTETSTRING> &p_certificates_idx);

  int build_certificates_index();

  /*!

   * \fn int load_certificate(const OCTETSTRING& p_hashed_id8, const std::string p_certificate_name, std::map<std::string, std::unique_ptr<const security_db_record>> & p_certificates);

   * \brief Store in memory the specified certificate
@@ -105,10 +105,16 @@ public: /*! \publicsection */ 
  int save_certificate(const security_db_record &p_certificate);

  /*!

   * \fn std::map<OCTETSTRING, const std::string, security_cache_comp>& get_hashed_id8s() const;

   * \brief Retrive the index of certificates name by whole hash certificate value

   * \brief Retrieve the index of certificates name by HashedId8 value

   * \return The reference to the index

   */

  std::map<OCTETSTRING, const std::string, security_cache_comp>& get_hashed_id8s();

  /*!

   * \fn std::map<OCTETSTRING, const std::string, security_cache_comp>& get_certificate() const;

   * \brief Retrieve the index of HashedId8 value by certificates name

   * \return The HashedId8 of the certificate

   */

  std::map<std::string, const OCTETSTRING>& get_certificates();



private: /*! \privatesection */

}; // End of class certificates_loader

ccsrc/Protocols/Security/security_cache.cc

+17 −25
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ using namespace std; // Required for isnan() 


#include "loggers.hh"



security_cache::security_cache() : _certificates_idx(), _certificates() { loggers::get_instance().log(">>> security_cache::security_cache"); } // End of ctor

security_cache::security_cache() : _certificates() { loggers::get_instance().log(">>> security_cache::security_cache"); } // End of ctor



security_cache::~security_cache() {

  loggers::get_instance().log(">>> security_cache::~security_cache");
@@ -33,7 +33,6 @@ security_cache::~security_cache() { 
int security_cache::clear() {

  loggers::get_instance().log(">>> security_cache::clear");

  _certificates.clear(); // Smart pointers will do the job

  _certificates_idx.clear();



  return 0;

} // End of clear method
@@ -42,8 +41,9 @@ int security_cache::load_certificate(const std::string &p_certificate_id, const 
  loggers::get_instance().log(">>> security_cache::load_certificate: '%s'", p_certificate_id.c_str());



  // Sanity check

  std::map<std::string, const OCTETSTRING>::const_iterator s = _certificates_idx.find(p_certificate_id);

  if (s == _certificates_idx.cend()) {

  std::map<std::string, const OCTETSTRING>& certificates = certificates_loader::get_instance().get_certificates();

  std::map<std::string, const OCTETSTRING>::const_iterator s = certificates.find(p_certificate_id);

  if (s == certificates.cend()) {

    loggers::get_instance().warning("security_cache::load_certificate: record not found");

    return -1;

  }
@@ -55,7 +55,6 @@ int security_cache::load_certificate(const std::string &p_certificate_id, const 
      return -1;

    } else {

      *p_record = _certificates[p_certificate_id].get();



      return 0;

    }

  }
@@ -183,8 +182,9 @@ int security_cache::get_issuer(const std::string &p_certificate_id, OCTETSTRING 
int security_cache::get_hashed_id(const std::string &p_certificate_id, OCTETSTRING &p_hashed_id) const {

  loggers::get_instance().log(">>> security_cache::get_hashed_id: '%s'", p_certificate_id.c_str());



  std::map<std::string, const OCTETSTRING>::const_iterator it = _certificates_idx.find(p_certificate_id);

  if (it == _certificates_idx.cend()) {

  std::map<std::string, const OCTETSTRING>& certificates = certificates_loader::get_instance().get_certificates();

  std::map<std::string, const OCTETSTRING>::const_iterator it = certificates.find(p_certificate_id);

  if (it == certificates.cend()) {

    loggers::get_instance().warning("security_cache::get_hashed_id: record not found");

    p_hashed_id = OCTETSTRING(0, nullptr);

    return -1;
@@ -382,31 +382,17 @@ int security_cache::store_certificate(const ec_elliptic_curves p_signing_algorit 
                                                 public_enc_comp_key // Public encryption compressed key, 33 or 49 bytes

  );

  if (p == nullptr) {

    loggers::get_instance().error("security_cache::store_certificate: Failed to allocate memory");

    return -1;

  }

  certificates_loader::get_instance().save_certificate(*p);



  std::map<std::string, std::unique_ptr<const security_db_record>>::const_iterator i = _certificates.find(key);

  if (i != _certificates.cend()) {

    _certificates.erase(i);

  }



  _certificates.insert(std::pair<std::string, std::unique_ptr<const security_db_record>>(key, std::unique_ptr<const security_db_record>(p)));



  std::map<OCTETSTRING, const std::string, security_cache_comp>& hashed_id8s = certificates_loader::get_instance().get_hashed_id8s();

  std::map<OCTETSTRING, const std::string>::const_iterator h = hashed_id8s.find(hashed_id8);

  if (h != hashed_id8s.cend()) {

    loggers::get_instance().log_msg("security_cache::store_certificate: Replace entry in hashed_id8s: ", h->first);

    hashed_id8s.erase(h);

  }

  std::map<std::string, const OCTETSTRING>::const_iterator k = _certificates_idx.find(h->second);

  if (k != _certificates_idx.cend()) {

    loggers::get_instance().log("security_cache::store_certificate: Replace entry in _certificates_idx: %s", k->first.c_str());

    _certificates_idx.erase(k);

  }

  loggers::get_instance().log_msg("security_cache::store_certificate: Add entry ", hashed_id8);

  loggers::get_instance().log("security_cache::store_certificate: Add entry for key %s", key.c_str());

  hashed_id8s.insert(std::pair<OCTETSTRING, const std::string>(hashed_id8, key));

  _certificates_idx.insert(std::pair<std::string, const OCTETSTRING>(key, hashed_id8));



  return 0;

}
@@ -436,4 +422,10 @@ void security_cache::dump() const { 
    loggers::get_instance().log_msg("security_cache::dump: Hashedid8 key = ", it->first);

    loggers::get_instance().log("security_cache::dump: Hashedid8 idx ==> %s", it->second.c_str());

  } // End of 'for' statement

  std::map<std::string, const OCTETSTRING>& certificates = certificates_loader::get_instance().get_certificates();

  loggers::get_instance().log("security_cache::dump: certificates table length: %d", certificates.size());

  for (std::map<std::string, const OCTETSTRING>::const_iterator it = certificates.cbegin(); it != certificates.cend(); ++it) {

    loggers::get_instance().log("security_cache::dump: certificates idx ==> %s", it->first.c_str());

    loggers::get_instance().log_msg("security_cache::dump: certificates key = ", it->second);

  } // End of 'for' statement

} // End of method dump

ccsrc/Protocols/Security/security_cache.hh

+0 −1
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ class security_cache { 


protected: /*! \protectedsection */

  // TODO Enforce with const security_cache_record, and const std::string

  std::map<std::string, const OCTETSTRING> _certificates_idx; //! List of the certificates indexed by the certificate identifier

  std::map<std::string, std::unique_ptr<const security_db_record>> _certificates; //! List of the certificates indexed by the certificate identifier



public: /*! \publicsection */

ccsrc/Protocols/Security/security_db.cc

+1 −1
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ int security_db::initialize_cache(const std::string &p_db_path) { 
  }



  // TODO Build the maps of couple {HasehedId8, Certificate}

  if (certificates_loader::get_instance().build_certificates_index(_certificates_idx) == -1) {

  if (certificates_loader::get_instance().build_certificates_index() == -1) {

    loggers::get_instance().log(">>> security_db::initialize_cache: certificates_loader::build_certificates_index method failed");

    return -1;

  }