xAOD::SimpleEncrypter Class Reference

Provide simple asymmetric encryption for blinding of float values. More...

#include <SimpleEncrypter.h>

Inheritance diagram for xAOD::SimpleEncrypter:

Collaboration diagram for xAOD::SimpleEncrypter:

Public Types
typedef long long int	LLI_t
	Useful typedefs. More...
typedef unsigned long long int	ULLI_t

Public Member Functions
	SimpleEncrypter (const std::string &name="SimpleEncrypter")
	Main constructor. More...
virtual	~SimpleEncrypter ()
	Default destructor. More...
virtual std::pair< std::string, std::string >	genKeyPair ()
	Generate private and public keys. More...
virtual void	setPrivKey (std::string keystr)
	Set private key. More...
virtual void	setPubKey (std::string keystr)
	Set public key. More...
virtual std::string	getPrivKey () const
	Get private key. More...
virtual std::string	getPubKey () const
	Get public key. More...
virtual ULLI_t	encrypt (ULLI_t x)
	Encrypt a positive integer value. More...
virtual ULLI_t	decrypt (ULLI_t x)
	Decrypt a positive integer value. More...
virtual float	encrypt (float x)
	Encrypt a positive float value. More...
virtual float	decrypt (float x)
	Decrypt a positive float value. More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc. More...
Key generation utilities
Internally generate numeric representation of key pair
virtual void	genKeyPairInternal ()
virtual ULLI_t	genPrime () const
	Find a prime number. More...
virtual bool	isPrime (ULLI_t n) const
	Check for being a prime number. More...
virtual ULLI_t	greatestCommonDenominator (ULLI_t n1, ULLI_t n2) const
	Find greatest common denominator. More...
virtual ULLI_t	genCoprime (ULLI_t n) const
	Find a coprime number. More...
virtual ULLI_t	genDecryptionExponent (ULLI_t phi, ULLI_t e) const
	Find decryption exponent. More...
Key conversion utilities
Convert key to hex string
virtual std::string	keyToString (ULLI_t a, ULLI_t b) const
virtual std::pair< ULLI_t, ULLI_t >	decodeKeyString (std::string str) const
	Decode hex string to two integers. More...
float <-> int conversion utilities
Interpret bits of floating point number as integer
virtual ULLI_t	floatBitsToInt (float val) const
virtual float	intBitsToFloat (ULLI_t val) const
	Interpret bits of integer as floating point number. More...
Internal en-/decryption methods
Encrypt using format preserving encryption w.r.t. RSA modulus
ULLI_t	encryptFPECycle (ULLI_t a) const
ULLI_t	decryptFPECycle (ULLI_t a) const
	Decrypt using format preserving encryption w.r.t. More...
ULLI_t	encryptInternal (ULLI_t x) const
	Encrypt integer (internal) More...
ULLI_t	decryptInternal (ULLI_t x) const
	Decrypt integer (internal) More...
ULLI_t	powerMod (ULLI_t a, ULLI_t d, ULLI_t n) const
	Exponentiate a with d observing modulus n. More...
bool	isOkForEnc ()
	Check setup readiness for encryption. More...
bool	isOkForDec ()
	Check setup readiness for decryption. More...

Private Attributes
std::string	m_nm
	Message source name. More...
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...
Internal member variables
RSA modulus: common part of both keys
ULLI_t	m_n
ULLI_t	m_e
	encryption exponent: public key part II More...
ULLI_t	m_d
	decryption exponent: private key part II More...
bool	m_isOkForEnc
	indicates that keys are set and range checks are ok More...
bool	m_isOkForDec

Static Private Attributes
Internal static consts
Approximate range for prime numbers to be generated in
static const ULLI_t	m_MAXRANGE
static const ULLI_t	m_MINRANGE
static const unsigned int	m_MAXHEXDIGITS
	maximum number of hex digits for key parts More...

Detailed Description

Provide simple asymmetric encryption for blinding of float values.

Author

Wolfgang Walkowiak <Wolfg.nosp@m.ang..nosp@m.Walko.nosp@m.wiak.nosp@m.@cern.nosp@m..ch.>

Provides asymmetric key encryption for blinding of positive float values. Internally it uses a simple RSA encryption of bits in the floating point numbers. This class is used by the BPhysBlindingTool.

Definition at line 36 of file SimpleEncrypter.h.

Member Typedef Documentation

LLI_t

typedef long long int xAOD::SimpleEncrypter::LLI_t

Useful typedefs.

Definition at line 40 of file SimpleEncrypter.h.

ULLI_t

typedef unsigned long long int xAOD::SimpleEncrypter::ULLI_t

Definition at line 41 of file SimpleEncrypter.h.

Constructor & Destructor Documentation

SimpleEncrypter()

xAOD::SimpleEncrypter::SimpleEncrypter

(

const std::string &

name = "SimpleEncrypter"

)

Main constructor.

Parameters

[in]

name

of instance

Definition at line 42 of file SimpleEncrypter.cxx.

                                                        :
    asg::AsgMessaging(name), m_n(0), m_e(0), m_d(0),
    m_isOkForEnc(false), m_isOkForDec(false) {
 
    // initialize random number generator
    srand(static_cast<unsigned>(time(0)));
  }

~SimpleEncrypter()

xAOD::SimpleEncrypter::~SimpleEncrypter ( )

virtual

Default destructor.

Definition at line 53 of file SimpleEncrypter.cxx.

                                    {
 
  }

Member Function Documentation

decodeKeyString()

std::pair< SimpleEncrypter::ULLI_t, SimpleEncrypter::ULLI_t > xAOD::SimpleEncrypter::decodeKeyString ( std::string  str ) const

privatevirtual

Decode hex string to two integers.

Definition at line 310 of file SimpleEncrypter.cxx.

                                                       {
    
    std::pair<ULLI_t, ULLI_t> keys(0,0);
    
    TString str(hstr);
    if (str.IsHex() && str.Length() > 3) {
      str.ToLower();
      unsigned int ndigits = strtoul(TString(str(0,2)).Data(), nullptr, 16);
      unsigned int ra = strtoul(TString(str(2,2)).Data(), nullptr, 16); 
      unsigned int rb = strtoul(TString(str(4,2)).Data(), nullptr, 16);
      if ( str.Length() == (int)(2*ndigits + 6) ) {
        keys.first  = strtoll(TString(str(ndigits+6-ra, ra)).Data(),
                              nullptr, 16);
        keys.second = strtoll(TString(str(2*ndigits+6-rb, rb)).Data(),
                              nullptr, 16);
      } else {
        ATH_MSG_ERROR("Private/public key must be a hex string of " <<
                      2*m_MAXHEXDIGITS+6 << " digits!");
      } // if Length()
    } else {
      ATH_MSG_ERROR("Private/public key must be a hex string of " <<
                    2*m_MAXHEXDIGITS+6 << " digits!");
    } // if IsHex() ...
    
    return keys;
  }

decrypt() [1/2]

float xAOD::SimpleEncrypter::decrypt ( float  x )

virtual

Decrypt a positive float value.

Parameters

[in]

positive

float value to be decrypted

Returns

encrypted float value

Definition at line 162 of file SimpleEncrypter.cxx.

                                        {
 
    float b = a;
 
    // As nan is a valid encrypted value, decrypt it as well.
    if ( a > 0. || std::isnan(a) ) {
      if ( isOkForDec() ) {
        ULLI_t ia = floatBitsToInt(a);
        ULLI_t ib = decryptFPECycle(ia);
        b = intBitsToFloat(ib);
      }
    } else {
      ATH_MSG_WARNING("Decrypt: Float value not positive: "
                      << a << Form(" (%a) !", a));
    } // if a > 0
    return b;
  }

decrypt() [2/2]

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::decrypt ( ULLI_t  x )

virtual

Decrypt a positive integer value.

Parameters

[in]

unsigned

integer value to be decrypted

Returns

encrypted unsigned integer value

Definition at line 130 of file SimpleEncrypter.cxx.

                                                         {
 
    ULLI_t b = a;
 
    if ( isOkForDec() ) {
      b = decryptFPECycle(a);
    }
    return b;
  }

decryptFPECycle()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::decryptFPECycle ( ULLI_t  a ) const

private

Decrypt using format preserving encryption w.r.t.

RSA modulus

Definition at line 440 of file SimpleEncrypter.cxx.

                                                                         {
 
    ULLI_t dec = 0;
    if ( enc > 0 ) {
      ULLI_t r = (int)(std::log2(m_n));
      ULLI_t rmask = pow(2,r)-1;
      ULLI_t d = enc & rmask;
      ULLI_t b = enc - d;
      do {
        d = decryptInternal(d);
      } while ( d > rmask );
      dec = d + b;
    } // if
    return dec;
  }

decryptInternal()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::decryptInternal ( ULLI_t  x ) const

private

Decrypt integer (internal)

Definition at line 465 of file SimpleEncrypter.cxx.

                                                                       {
    
    return powerMod(x, m_d, m_n);
  }

encrypt() [1/2]

float xAOD::SimpleEncrypter::encrypt ( float  x )

virtual

Encrypt a positive float value.

Parameters

[in]

positive

float value to be encrypted

Returns

encrypted float value

Definition at line 142 of file SimpleEncrypter.cxx.

                                        {
 
    float b = a;
 
    if ( a > 0. ) {
      if ( isOkForEnc() ) {
        ULLI_t ia = floatBitsToInt(a);
        ULLI_t ib = encryptFPECycle(ia);
        b = intBitsToFloat(ib);
      }
    } else {
      ATH_MSG_WARNING("Encrypt: Float value not positive: "
                      << a << Form(" (%a) !", a));
    } // if a > 0
    return b;
  }

encrypt() [2/2]

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::encrypt ( ULLI_t  x )

virtual

Encrypt a positive integer value.

Parameters

[in]

unsigned

integer value to be encrypted

Returns

encrypted unsigned integer value

Definition at line 118 of file SimpleEncrypter.cxx.

                                                         {
 
    ULLI_t b = a;
 
    if ( isOkForEnc() ) {
      b = encryptFPECycle(a);
    }
    return b;
  }

encryptFPECycle()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::encryptFPECycle ( ULLI_t  a ) const

private

Definition at line 421 of file SimpleEncrypter.cxx.

                                                                       {
    
    ULLI_t enc = 0;
    if ( a > 0 ) {
      ULLI_t r = (int)(std::log2(m_n));
      ULLI_t rmask = pow(2,r)-1;
      ULLI_t c = a & rmask;
      ULLI_t b = a - c;
      do {
        c = encryptInternal(c);
      } while ( c > rmask );    
      enc = b + c;
    } // if
    return enc;
  }

encryptInternal()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::encryptInternal ( ULLI_t  x ) const

private

Encrypt integer (internal)

Definition at line 458 of file SimpleEncrypter.cxx.

                                                                       {
    
    return powerMod(x, m_e, m_n);
  }

floatBitsToInt()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::floatBitsToInt ( float  val ) const

privatevirtual

Definition at line 339 of file SimpleEncrypter.cxx.

                                                                       {
 
    ULLI_t res(0);
 
    if ( val < 0. ) {
      ATH_MSG_ERROR("Float value needs to be positive!");
    } else {
      // convert floating point number to ULLI_t if size fits
      if ( sizeof(float) <= sizeof(ULLI_t) ) {
        // check whether a quick conversion is possible
        if ( sizeof(float) == sizeof(int) ) {
          union {
            float f;
            int i;
          } fint;
          fint.f = val;
          res = fint.i;
        } else {
        // do a slow conversion
          char* pval = reinterpret_cast<char*>(&val);
          // loop over bytes
          for (unsigned int i=0; i<sizeof(float); ++i) {
            // loop over bits
            for (unsigned int j=0; j<CHAR_BIT; ++j) {
              unsigned int n = i*CHAR_BIT + j;
              unsigned int bit = (*(pval+i) >> j) & 1;
              if ( bit > 0 ) res |= 1 << n;
            } // for bits
          } // for bytes
        } // if sizeof
      } else {
        ATH_MSG_ERROR("sizeof(float) > sizeof(ULLI_t): "
                      << sizeof(float) << " > " << sizeof(LLI_t));
      } // if sizeof
    } // if val < 0.
 
    return res;
  }

genCoprime()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::genCoprime ( ULLI_t  n ) const

privatevirtual

Find a coprime number.

Definition at line 260 of file SimpleEncrypter.cxx.

                                                                  {
    
    // make sure coprime is larger than 5th Fermat number (2^16+1 = 65537)
    //coverity[dont_call]
    ULLI_t i = (65537 + rand()) % (m_MAXRANGE -1);
    do {
      ++i;
    } while (greatestCommonDenominator(n, i) != 1);
    return i;
  }

genDecryptionExponent()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::genDecryptionExponent ( ULLI_t  phi, ULLI_t  e  ) const

privatevirtual

Find decryption exponent.

Definition at line 274 of file SimpleEncrypter.cxx.

                                                                   {
    
    for (ULLI_t i=1; i<m_MAXRANGE; ++i) {
      if ( ((phi * i + 1) % e) == 0 ) {
        return (ULLI_t)((phi * i + 1) / e);
      }
    }
    return 0;
  }

genKeyPair()

std::pair< std::string, std::string > xAOD::SimpleEncrypter::genKeyPair ( )

virtual

Generate private and public keys.

Returns

key pair as string: [private key, public key]

Definition at line 60 of file SimpleEncrypter.cxx.

                                                            {
 
    // default preset
    std::pair<std::string, std::string> keys =
      std::make_pair("__NO_PRIV_KEY__", "__NO_PUB_KEY__");
 
    // generate keys
    genKeyPairInternal();
 
    if ( isOkForEnc() && isOkForDec() ) {
      keys = std::make_pair(getPrivKey(), getPubKey());
    }
    return keys;
  }

genKeyPairInternal()

void xAOD::SimpleEncrypter::genKeyPairInternal ( )

privatevirtual

Definition at line 187 of file SimpleEncrypter.cxx.

                                           {
 
    // Generate prime numbers p != q
    ULLI_t p(1);
    ULLI_t q(1);
    // Euler's phi function
    ULLI_t phi(1);
    
    // reset encryption and decryption exponent
    m_e = 0;
    m_d = 0;
    while ( p == q || m_e < 2 || m_e >= phi || m_d < 2
            || m_e*m_d % phi != 1 ) {
      double dlog2 = 0.;
      while ( p == q || dlog2 < 0.1 || dlog2 > 30. ) {
        p = genPrime();
        q = genPrime();
        dlog2 = fabs(log2(p)-log2(q));
      } // inner while loop
      phi = (p-1)*(q-1);
      m_n = p*q;
      m_e = genCoprime(phi);
      m_d = genDecryptionExponent(phi, m_e);
    } // outer while loop
    m_isOkForDec = false;
    m_isOkForEnc = false;
  }

genPrime()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::genPrime ( ) const

privatevirtual

Find a prime number.

Definition at line 217 of file SimpleEncrypter.cxx.

                                                        {
    //coverity[dont_call]
    ULLI_t t = (m_MINRANGE + rand()) % (m_MAXRANGE-1);
    do {
      t++;
    } while ( !isPrime(t) || t < m_MINRANGE );
    return t;
  }

getPrivKey()

std::string xAOD::SimpleEncrypter::getPrivKey ( ) const

virtual

Get private key.

Returns

hex string with private key

Definition at line 104 of file SimpleEncrypter.cxx.

                                              {
  
    return keyToString(m_n, m_d);
  }

getPubKey()

std::string xAOD::SimpleEncrypter::getPubKey ( ) const

virtual

Get public key.

Returns

hex string with public key

Definition at line 111 of file SimpleEncrypter.cxx.

                                             {
 
    return keyToString(m_e, m_n);    
  }

greatestCommonDenominator()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::greatestCommonDenominator ( ULLI_t  n1, ULLI_t  n2  ) const

privatevirtual

Find greatest common denominator.

Definition at line 245 of file SimpleEncrypter.cxx.

                                                                       {
 
    std::vector<LLI_t> r;
    LLI_t i = 1;
    r.push_back(std::max(n1, n2));
    r.push_back(std::min(n1, n2));
    while (r[i] != 0) {
      ++i;
      r.push_back(r[i-2] % r[i-1]);
    }
    return r[i-1];
  }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  m_lvl = m_imsg ?
    static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
    MSG::INFO;
}

intBitsToFloat()

float xAOD::SimpleEncrypter::intBitsToFloat ( ULLI_t  val ) const

privatevirtual

Interpret bits of integer as floating point number.

Definition at line 380 of file SimpleEncrypter.cxx.

                                                        {
 
    float res(0.);
 
    // number of bits needed
    unsigned int r = (int)(std::log2(val))+1;
    
    // convert ULLI_t to floating point number if size fits
    if ( sizeof(float)*CHAR_BIT >= r ) {
      // check whether a quick conversion is possible
      if ( sizeof(float) == sizeof(int) ) {
        union {
          float f;
          ULLI_t i;
        } ficnv;
        ficnv.i = val;
        res = ficnv.f;
      } else {
        // do a slow conversion
        char* pres = reinterpret_cast<char*>(&res);
        // loop over bytes
        for (unsigned int i=0; i<sizeof(float); ++i) {
          // loop over bits
          for (unsigned int j=0; j<CHAR_BIT; ++j) {
            unsigned int n = i*CHAR_BIT + j;
            unsigned int bit = (val >> n) & 1;
            if ( bit > 0 ) *(pres+i) |= 1 << j;
          } // for bits
        } // for bytes
      } // if sizeof
    } else {
      ATH_MSG_WARNING("sizeof(float)*CHAR_BIT < r: "
                      << sizeof(float)*CHAR_BIT << " < " << r);
    } // if sizeof
    
    return res;
  }

isOkForDec()

bool xAOD::SimpleEncrypter::isOkForDec ( )

private

Check setup readiness for decryption.

Definition at line 515 of file SimpleEncrypter.cxx.

                                   {
 
    if ( !m_isOkForDec ) {
      if ( m_n > 0 && m_d > 1 && m_d < m_n ) {
        m_isOkForDec = true;
      } else {
        ATH_MSG_ERROR("Setup not OK for decryption: private key set?");
      }
    } // if ! m_isOkForDec
    
    return m_isOkForDec;
  }

isOkForEnc()

bool xAOD::SimpleEncrypter::isOkForEnc ( )

private

Check setup readiness for encryption.

Definition at line 499 of file SimpleEncrypter.cxx.

                                   {
 
    if ( !m_isOkForEnc ) {
      if ( m_n > 0 && m_e > 1 && m_e < m_n ) {
        m_isOkForEnc = true;
      } else {
        ATH_MSG_ERROR("Setup not OK for encryption: public key set?");
      }
    } // if ! m_isOkForEnc
    
    return m_isOkForEnc;
  }

isPrime()

bool xAOD::SimpleEncrypter::isPrime ( ULLI_t  n ) const

privatevirtual

Check for being a prime number.

Definition at line 228 of file SimpleEncrypter.cxx.

                                              {
    
    bool isPrime = true;
    if (n != 2) {
      for (LLI_t i = 2; i < (LLI_t)sqrt(n) + 1; ++i) {
        if (n % i == 0) {
          isPrime = false;
          break;
        }
      }
    }
    return isPrime;
  }

keyToString()

std::string xAOD::SimpleEncrypter::keyToString ( ULLI_t  a, ULLI_t  b  ) const

privatevirtual

Definition at line 286 of file SimpleEncrypter.cxx.

                                                                 {
 
    // length of keys w.r.t. hex digits
    unsigned int ra = (unsigned int)(log(a)/log(16.))+1;
    unsigned int rb = (unsigned int)(log(b)/log(16.))+1;
 
    // random numbers for padding
    //coverity[dont_call]
    unsigned int r1 = rand() & ((1 << 4*(m_MAXHEXDIGITS-ra))-1);
    //coverity[dont_call]
    unsigned int r2 = rand() & ((1 << 4*(m_MAXHEXDIGITS-rb))-1);
 
    // format string
    TString tstr = Form("%02x%02x%02x%0*x%0*llx%0*x%0*llx",
                        m_MAXHEXDIGITS, ra, rb,
                        m_MAXHEXDIGITS-ra, r1, ra, a,
                        m_MAXHEXDIGITS-rb, r2, rb, b);
    
    return std::string(tstr.Data());
  }

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level  lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level  lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

powerMod()

SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::powerMod ( ULLI_t  a, ULLI_t  d, ULLI_t  n  ) const

private

Exponentiate a with d observing modulus n.

Definition at line 473 of file SimpleEncrypter.cxx.

                                                              {
 
    int    bin[sizeof(ULLI_t)*CHAR_BIT];
    ULLI_t dec[sizeof(ULLI_t)*CHAR_BIT];
    
    ULLI_t r = (ULLI_t)(std::log2(d))+1;
    ULLI_t tmp = d;
    // decompose exponent into binary number (reverse order!)
    for (ULLI_t i=0; i < r; ++i) {
      bin[r-i-1] = tmp % 2;
      tmp = (LLI_t)(tmp/2);
    } // for i
    
    // perform the exponentiation taking modulus into account
    dec[0] = a;
    for (ULLI_t i=1; i < r; ++i) {
      ULLI_t d2 = dec[i-1]*dec[i-1] % n;
      if ( bin[i] > 0 ) d2 *= a;
      dec[i] = d2 % n;
    } // for i
    
    return dec[r-1];
  }

setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setPrivKey()

void xAOD::SimpleEncrypter::setPrivKey ( std::string  keystr )

virtual

Set private key.

Parameters

[in]

hex

string with private key

Definition at line 78 of file SimpleEncrypter.cxx.

                                                   {
  
    std::pair<ULLI_t, ULLI_t> keys = decodeKeyString(std::move(keystr));
    
    if ( m_n > 0 && m_n != keys.first ) {
      ATH_MSG_WARNING("RSA module already set!");
    }
    m_n = keys.first;
    m_d = keys.second;
    m_isOkForDec = false;
  }

setPubKey()

void xAOD::SimpleEncrypter::setPubKey ( std::string  keystr )

virtual

Set public key.

Parameters

[in]

hex

string with public key

Definition at line 92 of file SimpleEncrypter.cxx.

                                                  {
    std::pair<ULLI_t, ULLI_t> keys = decodeKeyString(std::move(keystr));
    if ( m_n > 0 && m_n != keys.second ) {
      ATH_MSG_WARNING("RSA module already set!");
    }
    m_e = keys.first;
    m_n = keys.second;
    m_isOkForEnc = false;
  }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_d

ULLI_t xAOD::SimpleEncrypter::m_d

private

decryption exponent: private key part II

Definition at line 233 of file SimpleEncrypter.h.

m_e

ULLI_t xAOD::SimpleEncrypter::m_e

private

encryption exponent: public key part II

Definition at line 231 of file SimpleEncrypter.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_isOkForDec

bool xAOD::SimpleEncrypter::m_isOkForDec

private

Definition at line 237 of file SimpleEncrypter.h.

m_isOkForEnc

bool xAOD::SimpleEncrypter::m_isOkForEnc

private

indicates that keys are set and range checks are ok

Definition at line 236 of file SimpleEncrypter.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

m_MAXHEXDIGITS

const unsigned int xAOD::SimpleEncrypter::m_MAXHEXDIGITS

staticprivate

Initial value:

=
    (unsigned int)(log(pow(SimpleEncrypter::m_MAXRANGE,2))/log(16.))+3

maximum number of hex digits for key parts

Definition at line 223 of file SimpleEncrypter.h.

m_MAXRANGE

const SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::m_MAXRANGE

staticprivate

Initial value:

=
    (SimpleEncrypter::ULLI_t)pow(static_cast<double>(std::numeric_limits<ULLI_t>::max()), 0.25)

Definition at line 220 of file SimpleEncrypter.h.

m_MINRANGE

const SimpleEncrypter::ULLI_t xAOD::SimpleEncrypter::m_MINRANGE

staticprivate

Initial value:

=
    (SimpleEncrypter::ULLI_t)SimpleEncrypter::m_MAXRANGE/10

Definition at line 221 of file SimpleEncrypter.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_n

ULLI_t xAOD::SimpleEncrypter::m_n

private

Definition at line 229 of file SimpleEncrypter.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

The documentation for this class was generated from the following files:

• SimpleEncrypter.h
• SimpleEncrypter.cxx