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

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

explicit

Definition at line 10 of file Cipher.cc.

References Blowfish_Init(), gen::k, and m_ctx.

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

cond::auth::Cipher::~Cipher

(

)

Definition at line 16 of file Cipher.cc.

References m_ctx.

                       {
  delete m_ctx;
}

Member Function Documentation

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

(

const std::string &

input

)

Definition at line 117 of file Cipher.cc.

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

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

                                                            {
  if( b64in.empty() ) return "";
  char* input = 0;
  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;
}

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

(

const std::string &

input

)

Definition at line 105 of file Cipher.cc.

References base64_encode_alloc(), bf_process_alloc(), funct::false, MillePedeFileConverter_cfg::out, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cond::CredentialStore::addUser(), cond::CredentialStore::installAdmin(), cond::CredentialStore::setPermission(), cond::CredentialStore::updateConnection(), and cond::CredentialStore::updatePrincipal().

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

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 20 of file Cipher.cc.

References Blowfish_Decrypt(), Blowfish_Encrypt(), mps_fire::i, dttmaxenums::L, m_ctx, and dttmaxenums::R.

Referenced by b64encrypt(), decrypt(), and encrypt().

                                     {
  assert(input_size != 0);

  uInt32 L, R;
  unsigned int j = sizeof(uInt32);

  unsigned int output_size=0;

  if( !input_size ) {
    output = 0;
    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;
}

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

Definition at line 79 of file Cipher.cc.

References bf_process_alloc(), mps_fire::i, MillePedeFileConverter_cfg::out, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by b64decrypt(), and cond::auth::DecodingKey::init().

                                                                               {
  if( !inputSize ) return ""; 
  unsigned char* out = 0;
  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;
}

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

Definition at line 71 of file Cipher.cc.

References bf_process_alloc(), funct::false, and convertSQLitetoXML_cfg::output.

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

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

Member Data Documentation

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

private

Definition at line 34 of file Cipher.h.

Referenced by bf_process_alloc(), Cipher(), and ~Cipher().