#include <DecodingKey.h>

Public Member Functions
void	addDefaultService (const std::string &connectionString)

void	addService (const std::string &serviceName, const std::string &connectionString, const std::string &userName, const std::string &password)

size_t	createFromInputFile (const std::string &inputFileName, size_t generatedKeySize=0)

	DecodingKey ()

void	flush ()

size_t	init (const std::string &keyFileName, const std::string &password, bool readMode=true)

bool	isNominal () const

void	list (std::ostream &out)

const std::string &	ownerName () const

const std::string &	principalKey () const

const std::string &	principalName () const

const std::map< std::string, ServiceCredentials > &	services () const

const std::string &	version () const

virtual	~DecodingKey ()

Static Public Member Functions
static std::string	templateFile ()

Static Public Attributes
static constexpr size_t	DEFAULT_KEY_SIZE = 100

static constexpr const char *const	FILE_NAME = "db.key"

static constexpr const char *const	FILE_PATH = ".cms_cond/db.key"

static constexpr const char *const	KEY_FMT_VERSION = "2.0"

Private Attributes
std::string	m_fileName

bool	m_mode

std::string	m_owner

std::string	m_principalKey

std::string	m_principalName

std::string	m_pwd

std::map< std::string, ServiceCredentials >	m_services

std::string	m_version

Detailed Description

Definition at line 31 of file DecodingKey.h.

Constructor & Destructor Documentation

◆ DecodingKey()

cond::auth::DecodingKey::DecodingKey ( )

inline

Definition at line 96 of file DecodingKey.h.

     : m_fileName(""),
       m_version(""),
       m_mode(true),
       m_pwd(""),
       m_principalName(""),
       m_principalKey(""),
       m_owner(""),
       m_services() {}

◆ ~DecodingKey()

virtual cond::auth::DecodingKey::~DecodingKey ( )

inlinevirtual

Definition at line 43 of file DecodingKey.h.

43 {}

Member Function Documentation

◆ addDefaultService()

void cond::auth::DecodingKey::addDefaultService ( const std::string & connectionString )

Definition at line 299 of file DecodingKey.cc.

References FastTimer::addService(), l1RCTOmdsFedVectorProducer_cfi::connectionString, and DEFAULT_SERVICE().

                                                                              {
   addService(DEFAULT_SERVICE, connectionString, "", "");
 }

◆ addService()

void cond::auth::DecodingKey::addService	(	const std::string &	serviceName,
		const std::string &	connectionString,
		const std::string &	userName,
		const std::string &	password
	)

Definition at line 303 of file DecodingKey.cc.

References l1RCTOmdsFedVectorProducer_cfi::connectionString, EcalCondDBWriter_cfi::password, serviceName, and EcalCondDBWriter_cfi::userName.

                                                                     {
   std::map<std::string, ServiceCredentials>::iterator iK = m_services.find(serviceName);
   if (iK == m_services.end()) {
     iK = m_services.insert(std::make_pair(serviceName, ServiceCredentials())).first;
   }
   iK->second.connectionString = connectionString;
   iK->second.userName = userName;
   iK->second.password = password;
 }

◆ createFromInputFile()

size_t cond::auth::DecodingKey::createFromInputFile	(	const std::string &	inputFileName,
		size_t	generatedKeySize = `0`
	)

Definition at line 195 of file DecodingKey.cc.

References CONNECTIONPREFIX(), cond::auth::ServiceCredentials::connectionString, relval_steps::gen(), makeListRunsInFiles::inputFile, InefficientDoubleROC::inputFileName, KEYPREFIX(), mps_splice::line, mps_check::msg, NAMEPREFIX(), OWNERPREFIX(), submitPVValidationJobs::params, cond::parseLineForNamedParams(), cond::auth::ServiceCredentials::password, PASSWORDPREFIX(), serviceName, SERVICEPREFIX(), AlCaHLTBitMon_QueryRunRegistry::string, cond::throwException(), cond::auth::ServiceCredentials::userName, USERPREFIX(), and VERSIONPREFIX().

                                                                                                        {
   size_t nelem = 0;
   if (inputFileName.empty()) {
     std::string msg("Provided input file name is empty.");
     throwException(msg, "DecodingKey::readFromInputFile");
   }
   m_version.clear();
   m_principalName.clear();
   m_principalKey.clear();
   m_owner.clear();
   m_services.clear();
   std::ifstream inputFile(inputFileName.c_str());
   if (inputFile.is_open()) {
     std::map<std::string, std::string> params;
     while (inputFile.good()) {
       std::string line;
       getline(inputFile, line);
       params.clear();
       if (line.size() > 3) {
         if (line.substr(0, 2) == VERSIONPREFIX) {
           m_version = line.substr(2);
         } else if (line.substr(0, 2) == NAMEPREFIX) {
           m_principalName = line.substr(2);
         } else if (line.substr(0, 2) == KEYPREFIX) {
           m_principalKey = line.substr(2);
         } else if (line.substr(0, 2) == OWNERPREFIX) {
           m_owner = line.substr(2);
         } else if (line.substr(0, 2) == SERVICEPREFIX) {
           parseLineForNamedParams(line, params);
           std::string& serviceName = params[SERVICEPREFIX];
           ServiceCredentials creds;
           creds.connectionString = params[CONNECTIONPREFIX];
           creds.userName = params[USERPREFIX];
           creds.password = params[PASSWORDPREFIX];
           m_services.insert(std::make_pair(serviceName, creds));
           nelem++;
         }
       }
     }
     inputFile.close();
     if (m_principalKey.empty() && generatedKeySize) {
       KeyGenerator gen;
       m_principalKey = gen.make(generatedKeySize);
     }
 
   } else {
     std::string msg = "Provided Input File \"" + inputFileName + "\n is invalid.";
     throwException(msg, "DecodingKey::readFromInputFile");
   }
   return nelem;
 }

◆ flush()

void cond::auth::DecodingKey::flush ( )

Definition at line 261 of file DecodingKey.cc.

References Skims_PA_cff::content, cond::auth::Cipher::encrypt(), ItemSeparator, KEY_HEADER(), KEYPREFIX(), LineSeparator, mps_check::msg, NAMEPREFIX(), MillePedeFileConverter_cfg::out, L1TdeCSCTF_cfi::outFile, OWNERPREFIX(), SERVICEPREFIX(), AlCaHLTBitMon_QueryRunRegistry::string, cond::throwException(), and VERSIONPREFIX().

                                 {
   std::ofstream outFile(m_fileName.c_str(), std::ios::binary);
   if (outFile.is_open()) {
     std::stringstream content;
     content << KEY_HEADER << LineSeparator;
     if (!m_version.empty()) {
       content << VERSIONPREFIX << m_version << LineSeparator;
     }
     if (!m_principalName.empty()) {
       content << NAMEPREFIX << m_principalName << LineSeparator;
     }
     if (!m_principalKey.empty()) {
       content << KEYPREFIX << m_principalKey << LineSeparator;
     }
     if (!m_owner.empty()) {
       content << OWNERPREFIX << m_owner << LineSeparator;
     }
     for (std::map<std::string, ServiceCredentials>::const_iterator iD = m_services.begin(); iD != m_services.end();
          ++iD) {
       content << SERVICEPREFIX << iD->first << ItemSeparator;
       content << iD->second.connectionString << ItemSeparator;
       content << iD->second.userName << ItemSeparator;
       content << iD->second.password << ItemSeparator;
       content << LineSeparator;
     }
     Cipher cipher(m_pwd);
     unsigned char* out;
     size_t outSize = cipher.encrypt(content.str(), out);
     outFile.write(reinterpret_cast<char*>(out), outSize);
     free(out);
   } else {
     std::string msg("");
     msg += "Provided Key File \"" + m_fileName + "\n is invalid.";
     throwException(msg, "DecodingKey::flush");
   }
   outFile.close();
 }

◆ init()

size_t cond::auth::DecodingKey::init	(	const std::string &	keyFileName,
		const std::string &	password,
		bool	readMode = `true`
	)

Definition at line 113 of file DecodingKey.cc.

References Skims_PA_cff::content, cond::auth::Cipher::decrypt(), cond::getLoginName(), recoMuon::in, ItemSeparator, KEY_HEADER(), keyFile(), KEYPREFIX(), mps_splice::line, LineSeparator, mps_check::msg, NAMEPREFIX(), OWNERPREFIX(), EcalCondDBWriter_cfi::password, SERVICEPREFIX(), str, AlCaHLTBitMon_QueryRunRegistry::string, cond::throwException(), and VERSIONPREFIX().

                                                                                                        {
   if (keyFileName.empty()) {
     std::string msg("Provided key file name is empty.");
     throwException(msg, "DecodingKey::init");
   }
   m_fileName = keyFileName;
   m_pwd = password;
   m_mode = readMode;
   m_version.clear();
   m_principalName.clear();
   m_principalKey.clear();
   m_owner.clear();
   m_services.clear();
   size_t nelem = 0;
   if (m_mode) {
     std::ifstream keyFile(m_fileName.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
     if (keyFile.is_open()) {
       size_t fsize = keyFile.tellg();
       unsigned char* buff = (unsigned char*)malloc(fsize);
       keyFile.seekg(0, std::ios::beg);
       keyFile.read(reinterpret_cast<char*>(buff), fsize);
       Cipher cipher(m_pwd);
       std::string content = cipher.decrypt(buff, fsize);
       free(buff);
       // skip the header + line separator
       if (content.substr(0, KEY_HEADER.size()) != KEY_HEADER) {
         std::string msg("Provided key content is invalid.");
         throwException(msg, "DecodingKey::init");
       }
       std::stringstream str(content.substr(KEY_HEADER.size() + 1));
       while (str.good()) {
         std::string line;
         getline(str, line, LineSeparator);
         if (line.size() > 3) {
           if (line.substr(0, 2) == VERSIONPREFIX) {
             m_version = line.substr(2);
           } else if (line.substr(0, 2) == NAMEPREFIX) {
             m_principalName = line.substr(2);
           } else if (line.substr(0, 2) == KEYPREFIX) {
             m_principalKey = line.substr(2);
           } else if (line.substr(0, 2) == OWNERPREFIX) {
             m_owner = line.substr(2);
           } else if (line.substr(0, 2) == SERVICEPREFIX) {
             std::stringstream serviceStr(line.substr(2));
             std::vector<std::string> sdata;
             while (serviceStr.good()) {
               sdata.push_back(std::string(""));
               getline(serviceStr, sdata.back(), ItemSeparator);
             }
             std::map<std::string, ServiceCredentials>::iterator iS =
                 m_services.insert(std::make_pair(sdata[0], ServiceCredentials())).first;
             iS->second.connectionString = sdata[1];
             iS->second.userName = sdata[2];
             iS->second.password = sdata[3];
             nelem++;
           }
         }
       }
       keyFile.close();
       if (m_principalName.empty() || m_principalKey.empty()) {
         std::string msg = "Provided key is invalid.";
         throwException(msg, "DecodingKey::init");
       }
       if (!m_owner.empty()) {
         std::string currentUser = getLoginName();
         if (m_owner != currentUser) {
           m_principalName.clear();
           m_principalKey.clear();
           m_owner.clear();
           m_services.clear();
           std::string msg = "Provided key is invalid for user=" + currentUser;
           throwException(msg, "DecodingKey::init");
         }
       }
     } else {
       std::string msg = "Required Key File \"" + m_fileName + "\" is missing or unreadable.";
       throwException(msg, "DecodingKey::init");
     }
   }
   return nelem;
 }

◆ isNominal()

bool cond::auth::DecodingKey::isNominal ( ) const

inline

Definition at line 112 of file DecodingKey.h.

112 { return !m_owner.empty(); }

cond::auth::DecodingKey::m_owner

std::string m_owner

Definition: DecodingKey.h:85

◆ list()

void cond::auth::DecodingKey::list ( std::ostream & out )

Definition at line 247 of file DecodingKey.cc.

References CONNECTIONPREFIX(), KEYPREFIX(), NAMEPREFIX(), MillePedeFileConverter_cfg::out, OWNERPREFIX(), PASSWORDPREFIX(), SERVICEPREFIX(), USERPREFIX(), and VERSIONPREFIX().

                                               {
   out << VERSIONPREFIX << m_version << std::endl;
   out << NAMEPREFIX << m_principalName << std::endl;
   out << KEYPREFIX << m_principalKey << std::endl;
   out << OWNERPREFIX << m_owner << std::endl;
   for (std::map<std::string, ServiceCredentials>::const_iterator iS = m_services.begin(); iS != m_services.end();
        iS++) {
     out << SERVICEPREFIX << iS->first << ";";
     out << CONNECTIONPREFIX << iS->second.connectionString << ";";
     out << USERPREFIX << iS->second.userName << ";";
     out << PASSWORDPREFIX << iS->second.password << ";" << std::endl;
   }
 }

◆ ownerName()

const std::string & cond::auth::DecodingKey::ownerName ( ) const

inline

Definition at line 114 of file DecodingKey.h.

114 { return m_owner; }

cond::auth::DecodingKey::m_owner

std::string m_owner

Definition: DecodingKey.h:85

◆ principalKey()

const std::string & cond::auth::DecodingKey::principalKey ( ) const

inline

Definition at line 110 of file DecodingKey.h.

110 { return m_principalKey; }

cond::auth::DecodingKey::m_principalKey

std::string m_principalKey

Definition: DecodingKey.h:83

◆ principalName()

const std::string & cond::auth::DecodingKey::principalName ( ) const

inline

Definition at line 108 of file DecodingKey.h.

108 { return m_principalName; }

cond::auth::DecodingKey::m_principalName

std::string m_principalName

Definition: DecodingKey.h:81

◆ services()

const std::map< std::string, cond::auth::ServiceCredentials > & cond::auth::DecodingKey::services ( ) const

inline

Definition at line 116 of file DecodingKey.h.

                                                                                                 {
   return m_services;
 }

◆ templateFile()

std::string cond::auth::DecodingKey::templateFile ( )

static

Definition at line 97 of file DecodingKey.cc.

References CONNECTIONPREFIX(), KEYPREFIX(), NAMEPREFIX(), OWNERPREFIX(), PASSWORDPREFIX(), alignCSCRings::s, SERVICEPREFIX(), USERPREFIX(), and VERSIONPREFIX().

                                             {
   std::stringstream s;
   s << VERSIONPREFIX << KEY_FMT_VERSION << std::endl;
   s << NAMEPREFIX << "<principal_name>" << std::endl;
   s << OWNERPREFIX << "<owner_name, optional>" << std::endl;
   s << KEYPREFIX << "<key, leave empty if generated>" << std::endl;
   //s<<DATEPREFIX<<"<expiring date, optional>"<<std::endl;
   s << SERVICEPREFIX << "<service_name0>;" << CONNECTIONPREFIX << "<service0_connection_string>;" << USERPREFIX
     << "<user0_name>;" << PASSWORDPREFIX << "<password0>;" << std::endl;
   s << SERVICEPREFIX << "<service_name1>;" << CONNECTIONPREFIX << "<service1_connection_string>;" << USERPREFIX
     << "<user1_name>;" << PASSWORDPREFIX << "<password1>;" << std::endl;
   s << SERVICEPREFIX << "<service_name2>;" << CONNECTIONPREFIX << "<service2_connection_string>;" << USERPREFIX
     << "<user2_name>;" << PASSWORDPREFIX << "<password2>;" << std::endl;
   return s.str();
 }

◆ version()

const std::string & cond::auth::DecodingKey::version ( ) const

inline

Definition at line 106 of file DecodingKey.h.

Referenced by validation.Sample::datasetpattern(), and validation.Sample::filename().

106 { return m_version; }

cond::auth::DecodingKey::m_version

std::string m_version

Definition: DecodingKey.h:75

Member Data Documentation

◆ DEFAULT_KEY_SIZE

constexpr size_t cond::auth::DecodingKey::DEFAULT_KEY_SIZE = 100

static

Definition at line 36 of file DecodingKey.h.

◆ FILE_NAME

constexpr const char* const cond::auth::DecodingKey::FILE_NAME = "db.key"

static

Definition at line 34 of file DecodingKey.h.

◆ FILE_PATH

constexpr const char* const cond::auth::DecodingKey::FILE_PATH = ".cms_cond/db.key"

static

Definition at line 35 of file DecodingKey.h.

Referenced by cond::CredentialStore::setUpForService().

◆ KEY_FMT_VERSION

constexpr const char* const cond::auth::DecodingKey::KEY_FMT_VERSION = "2.0"

static

Definition at line 33 of file DecodingKey.h.

◆ m_fileName

std::string cond::auth::DecodingKey::m_fileName

private

Definition at line 73 of file DecodingKey.h.

◆ m_mode

bool cond::auth::DecodingKey::m_mode

private

Definition at line 77 of file DecodingKey.h.

◆ m_owner

std::string cond::auth::DecodingKey::m_owner

private

Definition at line 85 of file DecodingKey.h.

◆ m_principalKey

std::string cond::auth::DecodingKey::m_principalKey

private

Definition at line 83 of file DecodingKey.h.

◆ m_principalName

std::string cond::auth::DecodingKey::m_principalName

private

Definition at line 81 of file DecodingKey.h.

◆ m_pwd

std::string cond::auth::DecodingKey::m_pwd

private

Definition at line 79 of file DecodingKey.h.

◆ m_services

std::map<std::string, ServiceCredentials> cond::auth::DecodingKey::m_services

private

Definition at line 87 of file DecodingKey.h.

◆ m_version

std::string cond::auth::DecodingKey::m_version

private

Definition at line 75 of file DecodingKey.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DecodingKey()

◆ ~DecodingKey()

Member Function Documentation

◆ addDefaultService()

◆ addService()

◆ createFromInputFile()

◆ flush()

◆ init()

◆ isNominal()

◆ list()

◆ ownerName()

◆ principalKey()

◆ principalName()

◆ services()

◆ templateFile()

◆ version()

Member Data Documentation

◆ DEFAULT_KEY_SIZE

◆ FILE_NAME

◆ FILE_PATH

◆ KEY_FMT_VERSION

◆ m_fileName

◆ m_mode

◆ m_owner

◆ m_principalKey

◆ m_principalName

◆ m_pwd

◆ m_services

◆ m_version