cond::auth::Cipher Class Reference

#include <Cipher.h>

Public Member Functions
std::string	b64decrypt (const std::string &input)
std::string	b64encrypt (const std::string &input)
	Cipher (const std::string &key)
std::string	decrypt (const unsigned char *input, size_t inputSize)
size_t	encrypt (const std::string &input, unsigned char *&output)
	~Cipher ()

Private Member Functions
size_t	bf_process_alloc (const unsigned char *input, size_t input_size, unsigned char *&output, bool decrypt=false)

Private Attributes
BLOWFISH_CTX *	m_ctx

Detailed Description

Definition at line 13 of file Cipher.h.

Constructor & Destructor Documentation

Cipher()

cond::auth::Cipher::Cipher ( const std::string &  key )

explicit

Definition at line 10 of file Cipher.cc.

                                           : m_ctx(new BLOWFISH_CTX) {
  char* k = const_cast<char*>(key.c_str());
  Blowfish_Init(m_ctx, reinterpret_cast<unsigned char*>(k), key.size());
}

References Blowfish_Init(), dqmdumpme::k, crabWrapper::key, and m_ctx.

~Cipher()

cond::auth::Cipher::~Cipher

(

)

Definition at line 15 of file Cipher.cc.

{ delete m_ctx; }

Member Function Documentation

b64decrypt()

std::string cond::auth::Cipher::b64decrypt

(

const std::string &

input

)

Definition at line 122 of file Cipher.cc.

                                                           {
  if (b64in.empty())
    return "";
  char* input = nullptr;
  size_t inputSize = 0;
  if (!base64_decode_alloc(b64in.c_str(), b64in.size(), &input, &inputSize)) {
    throwException("Input provided is not a valid base64 string.", "Cipher::b64decrypt");
  }
  std::string ret = decrypt(reinterpret_cast<const unsigned char*>(input), inputSize);
  free(input);
  return ret;
}

References base64_decode_alloc, input, runTheMatrix::ret, AlCaHLTBitMon_QueryRunRegistry::string, and cond::throwException().

Referenced by cond::CredentialStore::exportAll(), cond::CredentialStore::importForPrincipal(), cond::CredentialStore::listConnections(), cond::CredentialStore::resetAdmin(), cond::CredentialStore::selectForUser(), cond::CredentialStore::setPermission(), cond::CredentialStore::startSession(), cond::updateConnectionData(), cond::CredentialStore::updatePrincipal(), and cond::updatePrincipalData().

b64encrypt()

std::string cond::auth::Cipher::b64encrypt

(

const std::string &

input

)

Definition at line 109 of file Cipher.cc.

                                                           {
  if (input.empty())
    return "";
  unsigned char* out = nullptr;
  size_t outSize = bf_process_alloc(reinterpret_cast<const unsigned char*>(input.c_str()), input.size(), out, false);
  char* b64out = nullptr;
  size_t b64size = base64_encode_alloc(reinterpret_cast<const char*>(out), outSize, &b64out);
  std::string ret(b64out, b64size);
  free(out);
  free(b64out);
  return ret;
}

References base64_encode_alloc(), input, MillePedeFileConverter_cfg::out, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::setPermissionData(), cond::updateConnectionData(), and cond::updatePrincipalData().

bf_process_alloc()

size_t cond::auth::Cipher::bf_process_alloc ( const unsigned char *  input, size_t  input_size, unsigned char *&  output, bool  decrypt = false  )

private

Definition at line 17 of file Cipher.cc.

                                                          {
  assert(input_size != 0);
 
  uInt32 L, R;
  unsigned int j = sizeof(uInt32);
 
  unsigned int output_size = 0;
 
  if (!input_size) {
    output = nullptr;
    return 0;
  }
 
  for (unsigned int i = 0; i < input_size; i += (j * 2)) {
    output_size = i + 2 * j;
  }
  output = (unsigned char*)malloc(output_size);
  memset(output, 0, output_size);
 
  for (unsigned int i = 0; i < input_size; i += (j * 2)) {
    L = R = 0;
    unsigned int nl = 0;
    unsigned int nr = 0;
    if (input_size > i + j) {
      nl = j;
      if (input_size > i + 2 * j) {
        nr = j;
      } else {
        nr = input_size - i - j;
      }
    } else {
      nl = input_size - i;
      nr = 0;
    }
    if (nl)
      memcpy(&L, input + i, nl);
    if (nr)
      memcpy(&R, input + i + j, nr);
    if (!decrypt) {
      Blowfish_Encrypt(m_ctx, &L, &R);
    } else {
      Blowfish_Decrypt(m_ctx, &L, &R);
    }
    memcpy(output + i, &L, j);
    memcpy(output + i + j, &R, j);
  }
 
  return output_size;
}

References cms::cuda::assert(), Blowfish_Decrypt(), Blowfish_Encrypt(), mps_fire::i, input, dqmiolumiharvest::j, dttmaxenums::L, EgHLTOffHistBins_cfi::nr, convertSQLitetoXML_cfg::output, and dttmaxenums::R.

decrypt()

std::string cond::auth::Cipher::decrypt	(	const unsigned char *	input,
		size_t	inputSize
	)

Definition at line 79 of file Cipher.cc.

                                                                              {
  if (!inputSize)
    return "";
  unsigned char* out = nullptr;
  size_t outSize = bf_process_alloc(input, inputSize, out, true);
  size_t i = 0;
  for (i = 0; i < outSize; i++) {
    if (out[i] == 0)
      break;
  }
 
  char* sout = reinterpret_cast<char*>(out);
  // the output can still contain one or more \0 chars...
  //size_t soutSize = strlen( sout );
  size_t soutSize = 0;
  for (soutSize = 0; soutSize < outSize; soutSize++)
    if (out[soutSize] == 0)
      break;
 
  if (soutSize < outSize) {
    outSize = soutSize;
  }
 
  std::string ret("");
  if (outSize)
    ret = std::string(sout, outSize);
  free(out);
  return ret;
}

References mps_fire::i, input, MillePedeFileConverter_cfg::out, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::auth::DecodingKey::init().

encrypt()

size_t cond::auth::Cipher::encrypt	(	const std::string &	input,
		unsigned char *&	output
	)

Definition at line 70 of file Cipher.cc.

                                                                             {
  if (input.empty()) {
    output = nullptr;
    return 0;
  }
  return bf_process_alloc(reinterpret_cast<const unsigned char*>(input.c_str()), input.size(), output, false);
  ;
}

References input, and convertSQLitetoXML_cfg::output.

Referenced by cond::auth::DecodingKey::flush().

Member Data Documentation

m_ctx

BLOWFISH_CTX* cond::auth::Cipher::m_ctx

private

Definition at line 34 of file Cipher.h.

Referenced by Cipher().