Commit 929120f9 authored by YannGarcia's avatar YannGarcia
Browse files

Fixed bug issue #11 (#11) and... 

Fixed bug issue #11 (#11) and bug issue #6 (#6)
parent ddaab7bb

ccsrc/Protocols/Security/certificates_loader.cc

+195 −264
Original line number Diff line number Diff line
@@ -53,120 +53,60 @@ int certificates_loader::build_path(const std::string &p_root_directory) { 
  return 0;

} // End of method build_path



int certificates_loader::load_certificates(std::map<std::string, std::unique_ptr<security_db_record>> &                            p_certificates,

                                           std::map<OCTETSTRING /*std::vector<unsigned char>*/, std::string, security_cache_comp> &p_hashed_id8s) {

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

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

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



  // Sanity check

  if (_is_cache_initialized) {

    return 0;

  }



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

  /*if (build_certificates_index() == -1) {

    loggers::get_instance().warning("certificates_loader::build_certificates_index: Failed to build the list of certificate files");

    return -1;

  }*/

  // TODO Initialize the cache mechanism

  /*if (initialize_certificates_cache(files, p_certificates, p_hashed_id8s) == -1) {

    loggers::get_instance().warning("certificates_loader::initialize_certificates_cache: Failed to build the certificate cache");

    return -1;

  }*/

  // No certificate will be loded here



  // Retrieve the list of the files in the path

  std::set<std::experimental::filesystem::path> files;

  if (retrieve_certificates_list(files) == -1) {

    loggers::get_instance().warning("certificates_loader::load_certificates: Failed to build the list of certificate files");

  // Load index file

  std::experimental::filesystem::path p = _full_path.string() + "/index.lst";

  loggers::get_instance().log("certificates_loader::build_certificates_index: Caching certificate '%s'", p.string().c_str());

  std::ifstream is(p, ios::in);

  if (!is.is_open()) {

    loggers::get_instance().warning("certificates_loader::build_certificates_index: Failed to open index file");

    return -1;

  }

  // Build the certificates cache

  if (build_certificates_cache(files, p_certificates, p_hashed_id8s) == -1) {

    loggers::get_instance().warning("certificates_loader::build_certificates_cache: Failed to build the certificate cache");

    return -1;

  std::string hashed_id8, certificate;

  while (is >> hashed_id8 >> certificate) { // Process lines

    //loggers::get_instance().log("certificates_loader::build_certificates_index: Processing  '%s - %s'", hashed_id8.c_str(), certificate.c_str());

    // Convert HashedId8 into oectet string_to_into

    OCTETSTRING h = str2oct(CHARSTRING(static_cast<const char*>(hashed_id8.c_str())));

    // Remove extension file

    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());

      continue;

    }

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

  } // End of 'while' statement

   is.close();



  _is_cache_initialized = true;



  return 0;

} // End of method load_certificates



int certificates_loader::retrieve_certificates_list(std::set<std::experimental::filesystem::path> &p_files) {

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



  // Walk through directories

  std::set<std::experimental::filesystem::path> folders;

  for (const std::experimental::filesystem::directory_entry it : std::experimental::filesystem::recursive_directory_iterator(_full_path.string())) {

    // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Processing directory '%s'", it.path().string().c_str());

    if (std::experimental::filesystem::is_directory(it)) {

      std::set<std::string>::const_iterator i = _directory_filter.find(it.path().filename());

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

        // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Exclude directory '%s'", it.path().string().c_str());

        continue;

      }

      // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Add directory '%s'", it.path().string().c_str());

      folders.insert(it.path());

    }

  } // End of 'for' statement

} // End of method build_certificates_index



  if (folders.size() == 0) {

    loggers::get_instance().warning("certificates_loader::retrieve_certificates_list: No folder after filtering");

    folders.insert(_full_path);

  }

  // Process files

  p_files.clear();

  for (std::set<std::experimental::filesystem::path>::const_reverse_iterator f = folders.crbegin(); f != folders.crend(); ++f) {

    // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Processing directory '%s'", f->string().c_str());

    for (const std::experimental::filesystem::directory_entry it : std::experimental::filesystem::recursive_directory_iterator(*f)) {

      // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Processing file '%s'", it.path().filename().string().c_str());

      if (std::experimental::filesystem::is_regular_file(it)) {

        // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Check extension '%s'", it.path().extension().string().c_str());

        if (it.path().extension().string().compare(_certificateExt) == 0) {

          // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: Add file '%s'", it.path().filename().string().c_str());

          p_files.insert(it);

        }

      }

    } // End of 'for' statement

  }   // End of 'for' statement

  // loggers::get_instance().log("certificates_loader::retrieve_certificates_list: # of files to cache: %d", p_files.size());

  if (p_files.size() == 0) {

    loggers::get_instance().warning("certificates_loader::retrieve_certificates_list: No certificate found");

    return -1;

  }

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(">>> certificates_loader::load_certificate: %s", p_certificate_name.c_str());



  return 0;

} // End of method retrieve_certificates_list



int certificates_loader::build_certificates_cache(std::set<std::experimental::filesystem::path> &                                         p_files,

                                                  std::map<std::string, std::unique_ptr<security_db_record>> &                            p_certificates,

                                                  std::map<OCTETSTRING /*std::vector<unsigned char>*/, std::string, security_cache_comp> &p_hashed_id8s) {

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



  std::set<std::experimental::filesystem::path>::const_iterator                         it = p_files.cbegin();

  std::pair<std::map<std::string, std::unique_ptr<security_db_record>>::iterator, bool> result;

  do {

    loggers::get_instance().log("certificates_loader::build_certificates_cache: Caching '%s'", it->string().c_str());

    std::experimental::filesystem::path p   = *it;

  std::experimental::filesystem::path p = _full_path.string() + "/" + p_certificate_name + _certificateExt;

  const std::string& key = p.stem();

    // loggers::get_instance().log("certificates_loader::build_certificates_cache: Key = '%s'", key.c_str());



    // Load certificate file

    it = p_files.find(p.replace_extension(_certificateExt));

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

      loggers::get_instance().warning("certificates_loader::build_certificates_cache: Certificate file not found for '%s'", key.c_str());

      return -1;

    }

    // loggers::get_instance().log("certificates_loader::build_certificates_cache: Caching certificate '%s'", it->string().c_str());

    std::ifstream is(it->string(), ios::in | ios::binary);

  loggers::get_instance().log("certificates_loader::load_certificate: Caching certificate '%s'", p.string().c_str());

  std::ifstream is(p.string().c_str(), ios::in | ios::binary);

  if (!is.is_open()) {

      loggers::get_instance().warning("certificates_loader::build_certificates_cache: Failed to open certificate file");

    loggers::get_instance().warning("certificates_loader::load_certificate: Failed to open certificate file");

    return -1;

  }

    OCTETSTRING certificate = int2oct(0, std::experimental::filesystem::file_size(*it));

  OCTETSTRING certificate = int2oct(0, std::experimental::filesystem::file_size(p));

  is.read((char *)static_cast<const unsigned char *>(certificate), certificate.lengthof());

  is.close();

    // Remove items from the list

    p_files.erase(it);



  // Load private key file

  OCTETSTRING private_key;
@@ -206,6 +146,7 @@ int certificates_loader::build_certificates_cache(std::set<std::experimental::fi 
    is.close();

  }



  std::pair<std::map<std::string, std::unique_ptr<const security_db_record>>::iterator, bool> result;

  // Build DB record

  etsi_ts103097_certificate_codec codec;

  Ieee1609Dot2::CertificateBase   decoded_certificate;
@@ -327,26 +268,16 @@ int certificates_loader::build_certificates_cache(std::set<std::experimental::fi 
      public_enc_key_y,   // Public encryption key Y-coordinate

      public_enc_comp_key // Public compressed encryption key

    );

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

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

    if (result.second == false) {

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

      delete p;

      return -1;

    }

      // loggers::get_instance().log_msg("certificates_loader::build_certificates_cache: add key: ", result.first->second.get()->hashed_id());

      // loggers::get_instance().log("certificates_loader::build_certificates_cache: for : %s", result.first->first.c_str());

      p_hashed_id8s.insert(std::pair<OCTETSTRING, std::string>(result.first->second.get()->hashed_id(), result.first->first));

      /*std::vector<unsigned char> v(static_cast<const unsigned char*>(result.first->second.get()->hashed_id()),

      result.first->second.get()->hashed_id().lengthof() + static_cast<const unsigned char*>(result.first->second.get()->hashed_id()));

      loggers::get_instance().log_to_hexa("security_cache::store_certificate: Converted hashed_id8: ", v.data(), v.size());

      p_hashed_id8s.insert(std::pair<std::vector<unsigned char>, std::string>(v, result.first->first));*/

  }

    // Reset pointer

    it = p_files.cbegin();

  } while (it != p_files.cend());



  return 0;

} // End of method build_certificates_cache

}



int certificates_loader::save_certificate(const security_db_record &p_certificate) {

  loggers::get_instance().log(">>> certificates_loader::save_certificate: certificate_id=%s", p_certificate.certificate_id().c_str());

ccsrc/Protocols/Security/certificates_loader.hh

+38 −11
Original line number Diff line number Diff line
@@ -65,22 +65,49 @@ public: /*! \publicsection */ 
    return *instance;

  };



  /*!

   * \fn int build_path(const std::string &p_root_directory);

   * \brief Build the full path to the certitifcates storage location

   * \param[in] p_root_directory The root path to the certificates storage

   * \return 0 on success, -1 otherwise

   */

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



  int load_certificates(std::map<std::string, std::unique_ptr<security_db_record>> &                            p_certificates,

                        std::map<OCTETSTRING /*std::vector<unsigned char>*/, std::string, security_cache_comp> &p_hashed_id8s);

  // int load_certificate(std::unique_ptr<security_db_record> >& p_certificate, std::map<const OCTETSTRING, const std::string&>& p_hashed_id8s);

  /*!

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

   * \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, std::map<OCTETSTRING, const std::string, security_cache_comp> &p_hashed_id8s);

  /*!

   * \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

   * \param[in] p_hashed_id8 The HashedId8 of the certificate

   * \param[in] p_certificate_name The certificate name

   * \param[inout] p_certificates The map of the loaded in memory certificates

   * \return 0 on success, -1 otherwise

   */

  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);

  /*!

   * \fn int save_certificate(const security_db_record &p_certificate);

   * \brief Save the specified certificate and update the internal maps

   * \param[in] p_certificate The certificate to save

   * \return 0 on success, -1 otherwise

   */

  int save_certificate(const security_db_record &p_certificate);



private:

  int retrieve_certificates_list(std::set<std::experimental::filesystem::path> &p_files);



  int build_certificates_cache(std::set<std::experimental::filesystem::path> &                                         p_files,

                               std::map<std::string, std::unique_ptr<security_db_record>> &                            p_certificates,

                               std::map<OCTETSTRING /*std::vector<unsigned char>*/, std::string, security_cache_comp> &p_hashed_id8s);



private: /*! \privatesection */

  /*!

   * \fn int fill_public_key_vectors(const ec_elliptic_curves p_elliptic_curve, const Ieee1609Dot2BaseTypes::EccP256CurvePoint &p_ecc_point, OCTETSTRING &p_public_comp_key, OCTETSTRING &p_public_key_x, OCTETSTRING &p_public_key_y);

   * \brief Initialize public key vectors, based on 256 bits curve

   */

  void fill_public_key_vectors(const ec_elliptic_curves p_elliptic_curve, const Ieee1609Dot2BaseTypes::EccP256CurvePoint &p_ecc_point,

                               OCTETSTRING &p_public_comp_key, OCTETSTRING &p_public_key_x, OCTETSTRING &p_public_key_y);

  /*!

   * \fn int fill_public_key_vectors(const ec_elliptic_curves p_elliptic_curve, const Ieee1609Dot2BaseTypes::EccP256CurvePoint &p_ecc_point, OCTETSTRING &p_public_comp_key, OCTETSTRING &p_public_key_x, OCTETSTRING &p_public_key_y);

   * \brief Initialize public key vectors, based on 384 bits curve

   */

  void fill_public_key_vectors(const ec_elliptic_curves p_elliptic_curve, const Ieee1609Dot2BaseTypes::EccP384CurvePoint &p_ecc_point,

                               OCTETSTRING &p_public_comp_key, OCTETSTRING &p_public_key_x, OCTETSTRING &p_public_key_y);

}; // End of class certificates_loader

ccsrc/Protocols/Security/security_cache.cc

+132 −138

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/Protocols/Security/security_cache.hh

+143 −15

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/Protocols/Security/security_db.cc

+7 −8
Original line number Diff line number Diff line
@@ -16,23 +16,22 @@ using namespace std; // Required for isnan() 
security_db::security_db(const std::string &p_db_path) {

  loggers::get_instance().log(">>> security_db::security_db: '%s'", p_db_path.c_str());



  load_from_files(p_db_path);

  dump();

  initialize_cache(p_db_path);

} // End of ctor



security_db::~security_db() { loggers::get_instance().log(">>> security_db::~security_db"); } // End of dtor



int security_db::load_from_files(const std::string &p_db_path) {

  loggers::get_instance().log(">>> security_db::load_from_files: '%s'", p_db_path.c_str());

int security_db::initialize_cache(const std::string &p_db_path) {

  loggers::get_instance().log(">>> security_db::initialize_cache: '%s'", p_db_path.c_str());



  if (certificates_loader::get_instance().build_path(p_db_path) == -1) {

    loggers::get_instance().log(">>> security_db::load_from_files: certificates_loader::build_path method failed");

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

    return -1;

  }



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

  if (certificates_loader::get_instance().load_certificates(_certificates, _hashed_id8s) == -1) {

    loggers::get_instance().log(">>> security_db::load_from_files: certificates_loader::load_certificates method failed");

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

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

    return -1;

  }
@@ -52,7 +51,7 @@ int security_db::store_certificate(const CHARSTRING &p_cert_id, const OCTETSTRIN 
    return -1;

  }



  std::map<std::string, std::unique_ptr<security_db_record>>::const_iterator it = _certificates.find(std::string(static_cast<const char *>(p_cert_id)));

  std::map<std::string, std::unique_ptr<const security_db_record>>::const_iterator it = _certificates.find(std::string(static_cast<const char *>(p_cert_id)));

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

    loggers::get_instance().warning("security_db::get_certificate: record not found");

    return -1;