Commit 0471141d authored by garciay's avatar garciay
Browse files

STF538: Finalise certificates generation ATS

parent 09a70883

ccsrc/Protocols/Security/certificates_loader.cc

+3 −4
Original line number Diff line number Diff line
@@ -43,7 +43,7 @@ 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<std::vector<unsigned char>, std::string>& p_hashed_id8s, std::map<std::vector<unsigned char>, std::string>& p_issuers) {

int certificates_loader::load_certificates(std::map<std::string, std::unique_ptr<security_db_record> >& p_certificates, std::map<std::vector<unsigned char>, std::string>& p_hashed_id8s) {

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



  // Sanity check
@@ -58,7 +58,7 @@ int certificates_loader::load_certificates(std::map<std::string, std::unique_ptr 
    return -1;

  }

  // Build the certificates cache

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

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

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

    return -1;

  }
@@ -116,7 +116,7 @@ int certificates_loader::retrieve_certificates_list(std::set<std::experimental:: 
  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<std::vector<unsigned char>, std::string>& p_hashed_id8s, std::map<std::vector<unsigned char>, std::string>& p_issuers) {

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<std::vector<unsigned char>, std::string>& p_hashed_id8s) {

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



  std::set<std::experimental::filesystem::path>::const_iterator it = p_files.cbegin();
@@ -242,7 +242,6 @@ int certificates_loader::build_certificates_cache(std::set<std::experimental::fi 
      return -1;

    }

    p_hashed_id8s.insert(std::pair<std::vector<unsigned char>, std::string>(i->second.get()->hashed_id(), i->first));

    p_issuers.insert(std::pair<std::vector<unsigned char>, std::string>(i->second.get()->issuer(), i->first));

    

    // Reset pointer

    it = p_files.cbegin();

ccsrc/Protocols/Security/certificates_loader.hh

+2 −2
Original line number Diff line number Diff line
@@ -71,13 +71,13 @@ public: /*! \publicsection */ 


  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<std::vector<unsigned char>, std::string>& p_hashed_id8s, std::map<std::vector<unsigned char>, std::string>& p_issuers);

  int load_certificates(std::map<std::string, std::unique_ptr<security_db_record> >& p_certificates, std::map<std::vector<unsigned char>, std::string>& p_hashed_id8s);

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

  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<std::vector<unsigned char>, std::string>& p_hashed_id8s, std::map<std::vector<unsigned char>, std::string>& p_issuers);

  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<std::vector<unsigned char>, std::string>& p_hashed_id8s);

  

}; // End of class certificates_loader

ccsrc/Protocols/Security/security_cache.cc

+2 −26
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ using namespace std; 


#include "loggers.hh"



security_cache::security_cache(): _certificates(), _hashed_id8s(), _issuers() {

security_cache::security_cache(): _certificates(), _hashed_id8s() {

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

} // End of ctor
@@ -22,7 +22,6 @@ int security_cache::clear() { 
  loggers::get_instance().log(">>> security_cache::clear");

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

  _hashed_id8s.clear();

  _issuers.clear();

  

  return 0;

} // End of clear method
@@ -41,20 +40,6 @@ int security_cache::get_certificate_id(const OCTETSTRING& p_hashed_id8, std::str 
  return 0;

}



int security_cache::get_certificate_id_by_issuer(const OCTETSTRING& p_issuer, std::string& p_certifcate_id) const {

  loggers::get_instance().log_msg(">>> security_cache::get_certificate_id_by_issuer: ", p_issuer);



  std::vector<unsigned char> key(static_cast<const unsigned char*>(p_issuer), p_issuer.lengthof() + static_cast<const unsigned char*>(p_issuer));

  std::map<std::vector<unsigned char>, std::string>::const_iterator it = _issuers.find(key);

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

    p_certifcate_id = "";

    return -1;

  }

  p_certifcate_id = it->second;



  return 0;

}



int security_cache::get_certificate(const std::string& p_certificate_id, OCTETSTRING& p_certificate) const {

  loggers::get_instance().log(">>> security_cache::get_certificate: '%s'", p_certificate_id.c_str());
@@ -158,7 +143,7 @@ int security_cache::store_certificate(const CHARSTRING& p_cert_id, const OCTETST 
                                                 key,          // Certificate id

                                                 cert,         // Certificate

                                                 decoded_certificate,

                                                 issuer,       // Hashed ID fo the issuer

                                                 issuer,       // Hashed ID for the issuer

                                                 hashed_id8,   // Hashed ID

                                                 private_key,  // Private key

                                                 public_key_x, // Public key X
@@ -175,13 +160,8 @@ int security_cache::store_certificate(const CHARSTRING& p_cert_id, const OCTETST 
  if (h != _hashed_id8s.cend()) {

    _hashed_id8s.erase(h);

  }

  h = _issuers.find(issuer);

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

    _issuers.erase(h);

  }

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

  _hashed_id8s.insert(std::pair<std::vector<unsigned char>, std::string&>(hashed_id8, key));

  _issuers.insert(std::pair<std::vector<unsigned char>, std::string&>(issuer, key));

  dump();



  return 0;
@@ -195,7 +175,6 @@ void security_cache::dump() const { 
    loggers::get_instance().log_to_hexa("security_cache::dump: certificate = ", p->certificate().data(), p->certificate().size());

    loggers::get_instance().log_msg("security_cache::dump: decoded certificate = ", p->decoded_certificate());

    loggers::get_instance().log_to_hexa("security_cache::dump: hashed_id = ", p->hashed_id().data(), p->hashed_id().size());

    loggers::get_instance().log_to_hexa("security_cache::dump: hashed_id_issuer = ", p->issuer().data(), p->issuer().size());

    loggers::get_instance().log_to_hexa("security_cache::dump: private_key = ", p->private_key().data(), p->private_key().size());

    loggers::get_instance().log_to_hexa("security_cache::dump: public_key_x = ", p->public_key_x().data(), p->public_key_x().size());

    loggers::get_instance().log_to_hexa("security_cache::dump: public_key_y = ", p->public_key_y().data(), p->public_key_y().size());
@@ -203,7 +182,4 @@ void security_cache::dump() const { 
  for (std::map<std::vector<unsigned char>, std::string>::const_iterator it = _hashed_id8s.cbegin(); it != _hashed_id8s.cend(); ++it) {

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

  } // End of 'for' statement

  for (std::map<std::vector<unsigned char>, std::string>::const_iterator it = _issuers.cbegin(); it != _issuers.cend(); ++it) {

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

  } // End of 'for' statement

} // End of method dump

ccsrc/Protocols/Security/security_cache.hh

+1 −3
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ protected: /*! \protectedsection */ 
  // TODO Enforce with const security_cache_record, and const std::string

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

  std::map<std::vector<unsigned char>, std::string> _hashed_id8s; //! List of the certificates indexed by the HashedId8

  std::map<std::vector<unsigned char>, std::string> _issuers; //! List of the certificates indexed by the IssuerIdentifier

  

public: /*! \publicsection */

  /*!
@@ -32,7 +31,6 @@ public: /*! \publicsection */ 
  virtual ~security_cache();



  int get_certificate_id(const OCTETSTRING& p_hashed_id8, std::string& p_certificate_id) const;

  int get_certificate_id_by_issuer(const OCTETSTRING& p_issuer, std::string& p_certificate_id) const;

  int get_certificate(const std::string& p_certificate_id, OCTETSTRING& p_certificate) const;

  int get_certificate(const std::string& p_certificate_id, IEEE1609dot2::CertificateBase& p_certificate) const;

  int get_issuer(const std::string& p_certificate_id, OCTETSTRING& p_hashed_id_issuer) const;
@@ -42,7 +40,7 @@ public: /*! \publicsection */ 


  virtual int store_certificate(const CHARSTRING& p_cert_id, const OCTETSTRING& p_cert, const OCTETSTRING& p_private_key, const OCTETSTRING& p_public_key_x, const OCTETSTRING& p_public_key_y, const OCTETSTRING& p_hashid8, const OCTETSTRING& p_issuer);



  //virtual int store_certificate(const std::sring& p_cert_id, const std::vector<unsigned char>& p_cert, const std::vector<unsigned char>& p_private_key, const std::vector<unsigned char>& p_public_key_x, const std::vector<unsigned char>& p_public_key_y, const std::vector<unsigned char>& p_hashid8, const std::vector<unsigned char>& p_issuer);

  //virtual int store_certificate(const std::sring& p_cert_id, const std::vector<unsigned char>& p_cert, const std::vector<unsigned char>& p_private_key, const std::vector<unsigned char>& p_public_key_x, const std::vector<unsigned char>& p_public_key_y, const std::vector<unsigned char>& p_hashid8, const OCTETSTRING& p_issuer);

  virtual int clear();

  

  void dump() const;

ccsrc/Protocols/Security/security_db.cc

+1 −1
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ int security_db::load_from_files(const std::string& p_db_path) { 
    return -1;

  }

  

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

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

    return -1;

  }