cond::auth::DecodingKey Class Reference

#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.

{}

Member Function Documentation

addDefaultService()

void cond::auth::DecodingKey::addDefaultService

(

const std::string &

connectionString

)

Definition at line 299 of file DecodingKey.cc.

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

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

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.

                                                                    {
  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;
}

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

createFromInputFile()

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

Definition at line 195 of file DecodingKey.cc.

                                                                                                       {
  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;
}

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

flush()

void cond::auth::DecodingKey::flush

(

)

Definition at line 261 of file DecodingKey.cc.

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

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

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.

                                                                                                       {
  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;
}

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

isNominal()

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

inline

Definition at line 112 of file DecodingKey.h.

{ return !m_owner.empty(); }

list()

void cond::auth::DecodingKey::list

(

std::ostream &

out

)

Definition at line 247 of file DecodingKey.cc.

                                              {
  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;
  }
}

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

ownerName()

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

inline

Definition at line 114 of file DecodingKey.h.

{ return m_owner; }

principalKey()

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

inline

Definition at line 110 of file DecodingKey.h.

{ return m_principalKey; }

principalName()

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

inline

Definition at line 108 of file DecodingKey.h.

{ return m_principalName; }

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.

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

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

version()

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

inline

Definition at line 106 of file DecodingKey.h.

{ return m_version; }

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

Member Data Documentation

DEFAULT_KEY_SIZE

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

staticconstexpr

Definition at line 36 of file DecodingKey.h.

FILE_NAME

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

staticconstexpr

Definition at line 34 of file DecodingKey.h.

FILE_PATH

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

staticconstexpr

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"

staticconstexpr

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.