CAASymCipher Class Reference

#include <CAASymCipher.hpp>

Collaboration diagram for CAASymCipher:

Public Member Functions
	CAASymCipher ()
	~CAASymCipher ()
SINT32	destroy ()
SINT32	decrypt (const UINT8 *from, UINT8 *to)
	Decrypts exactly one block which is stored in from. More...
SINT32	decryptOAEP (const UINT8 *from, UINT8 *to, UINT32 *len)
	Decrypts one OAEP encoded block which is stored in from. More...
SINT32	encrypt (const UINT8 *from, UINT8 *to)
	Encrypts exactly one block which is stored in from. More...
SINT32	encryptOAEP (const UINT8 *from, UINT32 fromlen, UINT8 *to, UINT32 *len)
	Encrypts one block of plain text using OAEP padding. More...
SINT32	encryptPKCS1 (const UINT8 *from, UINT32 fromlen, UINT8 *to, UINT32 *len)
	Encrypts one block of plain text using PKCS1 padding. More...
SINT32	generateKeyPair (UINT32 size)
	Generates a new random key-pair of size bits. More...
SINT32	getPublicKeyAsDOMElement (DOMElement *&elemRoot, XERCES_CPP_NAMESPACE::DOMDocument *docOwner)
SINT32	getPublicKeyAsXML (UINT8 *buff, UINT32 *len)
	Stores the public key in buff. More...
SINT32	setPublicKey (const CACertificate *pCert)
	Sets the public key which is used for encryption to the contained in the provided certificate. More...
SINT32	setPublicKeyAsXML (const UINT8 *buff, UINT32 len)
	Sets the public key to the values stored in key. More...
SINT32	setPublicKeyAsDOMNode (DOMNode *node)
SINT32	setPublicKey (const UINT8 *modulus, UINT32 moduluslen, const UINT8 *exponent, UINT32 exponentlen)

Static Public Member Functions
static SINT32	testSpeed ()

Private Member Functions
SINT32	addKeyPart (DOMElement *elemRoot, XERCES_CPP_NAMESPACE::DOMDocument *docOwner, const char *partName, BIGNUM *part)
SINT32	getKeyPart (BIGNUM **part, DOMNode *node)

Private Attributes
RSA *	m_pRSA

Detailed Description

Definition at line 47 of file CAASymCipher.hpp.

Constructor & Destructor Documentation

CAASymCipher()

CAASymCipher::CAASymCipher

(

)

Definition at line 46 of file CAASymCipher.cpp.

{
  m_pRSA = NULL;
}

References m_pRSA.

Referenced by testSpeed().

Here is the caller graph for this function:

~CAASymCipher()

CAASymCipher::~CAASymCipher

(

)

Definition at line 51 of file CAASymCipher.cpp.

{
  destroy();
}

References destroy().

Here is the call graph for this function:

Member Function Documentation

addKeyPart()

SINT32 CAASymCipher::addKeyPart ( DOMElement *  elemRoot, XERCES_CPP_NAMESPACE::DOMDocument *  docOwner, const char *  partName, BIGNUM *  part  )

private

Definition at line 853 of file CAASymCipher.cpp.

{
  DOMElement *node = createDOMElement(docOwner, partName);
  elemRoot->appendChild(node);
  UINT8 tmpBuff[256];
  UINT32 size = 256;
  BN_bn2bin(part, tmpBuff);
  CABase64::encode(tmpBuff, BN_num_bytes(part), tmpBuff, &size);
  tmpBuff[size] = 0;
  DOMText *tmpTextNode = createDOMText(docOwner, (const char *const)tmpBuff);
  node->appendChild(tmpTextNode);
  return E_SUCCESS;
}

References createDOMElement(), createDOMText(), E_SUCCESS, and CABase64::encode().

Referenced by getPublicKeyAsDOMElement().

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt()

SINT32 CAASymCipher::decrypt	(	const UINT8 *	from,
		UINT8 *	to
	)

Decrypts exactly one block which is stored in from.

The result of the decryption is stored in to.

Parameters

from	one block of cipher text
to	the decrypted plain text

Return values

E_UNKNOWN	in case of an error
E_SUCCESS	otherwise

Definition at line 88 of file CAASymCipher.cpp.

{
  if (RSA_private_decrypt(RSA_SIZE, from, to, m_pRSA, RSA_NO_PADDING) == -1)
    return E_UNKNOWN;
  else
    return E_SUCCESS;
}

References E_SUCCESS, E_UNKNOWN, m_pRSA, and RSA_SIZE.

Referenced by decodeXMLEncryptedKey(), and CALastMixB::loop().

Here is the caller graph for this function:

decryptOAEP()

SINT32 CAASymCipher::decryptOAEP	(	const UINT8 *	from,
		UINT8 *	to,
		UINT32 *	len
	)

Decrypts one OAEP encoded block which is stored in from.

Parameters

from	one OAEP encoded block of cipher text
to	the plain text
len	on return contains the size of the plaintext

Return values

E_UNKNOWN	in case of an error
E_SUCCESS	otherwise

Definition at line 103 of file CAASymCipher.cpp.

  {
    SINT32 ret =RSA_private_decrypt(RSA_SIZE, from, to, m_pRSA, RSA_PKCS1_OAEP_PADDING);
    if (ret < 0)
      return E_UNKNOWN;
    *len = ret;
    return E_SUCCESS;
  }

References E_SUCCESS, E_UNKNOWN, len, m_pRSA, and RSA_SIZE.

Referenced by decryptXMLElement(), CALastMixA::loop(), and testSpeed().

Here is the caller graph for this function:

destroy()

SINT32 CAASymCipher::destroy

(

)

Definition at line 56 of file CAASymCipher.cpp.

{
  RSA_free(m_pRSA);
  m_pRSA = NULL;
  return E_SUCCESS;
}

References E_SUCCESS, and m_pRSA.

Referenced by ~CAASymCipher().

Here is the caller graph for this function:

encrypt()

SINT32 CAASymCipher::encrypt	(	const UINT8 *	from,
		UINT8 *	to
	)

Encrypts exactly one block which is stored in from.

The result of the encrpytion is stored in to.

Parameters

from	one block of plain text
to	the encrypted cipher text

Return values

E_UNKNOWN	in case of an error
E_SUCCESS	otherwise

Definition at line 157 of file CAASymCipher.cpp.

{
  if (RSA_public_encrypt(RSA_SIZE, from, to, m_pRSA, RSA_NO_PADDING) == -1)
    return E_UNKNOWN;
  else
    return E_SUCCESS;
}

References E_SUCCESS, E_UNKNOWN, m_pRSA, and RSA_SIZE.

Referenced by __encryptKey(), CALocalProxy::loop(), CAMsg::openEncryptedLog(), and CALocalProxy::processKeyExchange().

Here is the caller graph for this function:

encryptOAEP()

SINT32 CAASymCipher::encryptOAEP	(	const UINT8 *	from,
		UINT32	fromlen,
		UINT8 *	to,
		UINT32 *	len
	)

Encrypts one block of plain text using OAEP padding.

Parameters

from	pointer to one block of plain text
fromlen	size of the plain text
to	the OAEP encoded cipher text
len	on return contains the size of the ciphertext

Return values

E_UNKNOWN	in case of an error
E_SUCCESS	otherwise

Definition at line 120 of file CAASymCipher.cpp.

{
  SINT32 ret =
    RSA_public_encrypt(fromlen, from, to, m_pRSA, RSA_PKCS1_OAEP_PADDING);
  if (ret < 0)
    return E_UNKNOWN;
  *len = ret;
  return E_SUCCESS;
}

References E_SUCCESS, E_UNKNOWN, len, and m_pRSA.

Referenced by encryptXMLElement(), CALocalProxy::loop(), and testSpeed().

Here is the caller graph for this function:

encryptPKCS1()

SINT32 CAASymCipher::encryptPKCS1	(	const UINT8 *	from,
		UINT32	fromlen,
		UINT8 *	to,
		UINT32 *	len
	)

Encrypts one block of plain text using PKCS1 padding.

Parameters

from	pointer to one block of plain text
fromlen	size of the plain text
to	the OAEP encoded cipher text
len	on return contains the size of the ciphertext

Return values

E_UNKNOWN	in case of an error
E_SUCCESS	otherwise Temporarly will be removed soon.

Definition at line 140 of file CAASymCipher.cpp.

{
  SINT32 ret = RSA_public_encrypt(fromlen, from, to, m_pRSA, RSA_PKCS1_PADDING);
  if (ret < 0)
    return E_UNKNOWN;
  *len = ret;
  return E_SUCCESS;
}

References E_SUCCESS, E_UNKNOWN, len, and m_pRSA.

generateKeyPair()

SINT32 CAASymCipher::generateKeyPair

(

UINT32

size

)

Generates a new random key-pair of size bits.

Parameters

size	keysize of the new keypair

Return values

E_UNKNOWN	in case of an error
E_SUCCESS	otherwise

Definition at line 170 of file CAASymCipher.cpp.

{
  RSA_free(m_pRSA);
  m_pRSA = NULL;
#if  OPENSSL_VERSION_NUMBER >= 0x1000204fL
  m_pRSA=::RSA_new();
  BIGNUM* e = BN_new();
  BN_set_word(e, 65537);
  SINT32 ret=::RSA_generate_key_ex(m_pRSA,size, e, NULL);
  if (ret != 1)
    {
      RSA_free(m_pRSA);
      m_pRSA = NULL;
    }
#else
  m_pRSA = ::RSA_generate_key(size, 65537, NULL, NULL);
#endif
  if (m_pRSA == NULL)
    return E_UNKNOWN;
  ::setRSAFlags(m_pRSA);
  return E_SUCCESS;
}

References E_SUCCESS, E_UNKNOWN, m_pRSA, and setRSAFlags().

Referenced by CALastMix::init(), CAMiddleMix::init(), and testSpeed().

Here is the call graph for this function:

Here is the caller graph for this function:

getKeyPart()

SINT32 CAASymCipher::getKeyPart ( BIGNUM **  part, DOMNode *  node  )

private

Definition at line 642 of file CAASymCipher.cpp.

{
  if (*part != NULL)
    BN_free(*part);
  UINT8 *tmpStr = new UINT8[4096];
  UINT32 tmpStrLen = 4096;
  getDOMElementValue(node, tmpStr, &tmpStrLen);
  UINT8 decBuff[4096];
  UINT32 decLen = 4096;
  CABase64::decode(tmpStr, tmpStrLen, decBuff, &decLen);
  delete[] tmpStr;
  tmpStr = NULL;
  *part = BN_bin2bn(decBuff, decLen, NULL);
  return E_SUCCESS;
}

References CABase64::decode(), E_SUCCESS, and getDOMElementValue().

Referenced by setPublicKeyAsDOMNode().

Here is the call graph for this function:

Here is the caller graph for this function:

getPublicKeyAsDOMElement()

SINT32 CAASymCipher::getPublicKeyAsDOMElement	(	DOMElement *&	elemRoot,
		XERCES_CPP_NAMESPACE::DOMDocument *	docOwner
	)

Definition at line 870 of file CAASymCipher.cpp.

{
  if (m_pRSA == NULL)
    return E_UNKNOWN;
  elemRoot = createDOMElement(docOwner, "RSAKeyValue");
  BIGNUM* n = NULL;
  BIGNUM* e = NULL;
#if  OPENSSL_VERSION_NUMBER > 0x100020cfL
  RSA_get0_key(m_pRSA,(const BIGNUM**) &n,(const BIGNUM**) &e, NULL );
#else
  n = m_pRSA->n;
  e = m_pRSA->e;
#endif
  addKeyPart(elemRoot, docOwner, "Modulus", n);
  addKeyPart(elemRoot, docOwner, "Exponent", e);
 
  return E_SUCCESS;
}

References addKeyPart(), createDOMElement(), E_SUCCESS, E_UNKNOWN, and m_pRSA.

Referenced by getPublicKeyAsXML(), CALastMix::processKeyExchange(), and CAMiddleMix::processKeyExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

getPublicKeyAsXML()

SINT32 CAASymCipher::getPublicKeyAsXML	(	UINT8 *	buff,
		UINT32 *	len
	)

Stores the public key in buff.

The format is as follows:

  \li \c SIZE-N [2 bytes] - number of bytes which are needed for the

modulus n (in network byte order..)

• N [SIZE-N bytes] - the modulus n as integer (in network byte order)
• SIZE-E [2 bytes] - number of bytes which are needed for the exponent e (in network byte order..)
• E [SIZE-E bytes] - the exponent e as integer (in network byte order)

    @param buff byte array in which the public key should be stored
    @param len on input holds the size of \c buff, on return it contains
  

  the number of bytes needed to store the public key

  Return values

  E_UNKNOWN	in case of an error
  E_SUCCESS	otherwise

  See also

  getPublicKeySize()

  setPublicKey() Returns the number of bytes needed to store we public key. This is the number of bytes needed for a call of getPublicKey().

  Returns

  E_UNKOWN in case of an error number of bytes otherwise

  See also

  getPublicKey Sets the public key to the vaules stored in key. The format must match the format described for getPublicKey().

  Parameters

  key	byte array which holds the new public key
  len	on input,size of key byte array, on successful return number of bytes 'consumed'

  Return values

  E_UNKNOWN	in case of an error, the cipher is the uninitialized (no key is set)
  E_SUCCESS	otherwise

  See also

  getPublicKey Stores the public key in buff as XML. The format is as follows:

    \verbatim
  <RSAKeyValue>
    <Modulus>
      the modulus of the Key as ds::CryptoBinary
    </Modulus>
    <Exponent>
      the exponent of the key as ds::CryptoBinary
    </Exponent>
  <RSAKeyValue>

  There is NO \0 at the end.

  Parameters

  buff	byte array in which the public key should be stored
  len	on input holds the size of buff, on return it contains the number of bytes needed to store the public key

  Return values

  E_UNKNOWN	in case of an error
  E_SUCCESS	otherwise

  See also

  setPublicKeyAsXML()

Definition at line 333 of file CAASymCipher.cpp.

{
  if (m_pRSA == NULL || buff == NULL)
    return E_UNKNOWN;
  XERCES_CPP_NAMESPACE::DOMDocument *pDoc = createDOMDocument();
  DOMElement *elemRoot = NULL;
  getPublicKeyAsDOMElement(elemRoot, pDoc);
  DOM_Output::dumpToMem(elemRoot, buff, len);
  if (pDoc != NULL)
    {
      pDoc->release();
      pDoc = NULL;
    }
  return E_SUCCESS;
}

References createDOMDocument(), DOM_Output::dumpToMem(), E_SUCCESS, E_UNKNOWN, getPublicKeyAsDOMElement(), len, and m_pRSA.

Here is the call graph for this function:

setPublicKey() [1/2]

SINT32 CAASymCipher::setPublicKey

(

const CACertificate *

pCert

)

Sets the public key which is used for encryption to the contained in the provided certificate.

The key has to be a RSA public key.

Return values

E_SUCCESS	if successful
E_UNKNOWN	otherwise (in this case the key leaves untouched)

Definition at line 710 of file CAASymCipher.cpp.

{
  if (pCert == NULL)
    return E_UNKNOWN;
  EVP_PKEY *pubkey = X509_get_pubkey(pCert->m_pCert);
  int keyType = 0;
#if  OPENSSL_VERSION_NUMBER >= 0x1000204fL
  keyType = EVP_PKEY_id(pubkey);
#else
  keyType = pubkey->type;
#endif
 
  if (pubkey == NULL || (keyType != EVP_PKEY_RSA && keyType != EVP_PKEY_RSA2))
    return E_UNKNOWN;
  RSA *r = NULL;
#if  OPENSSL_VERSION_NUMBER >= 0x1000204fL
  r = EVP_PKEY_get1_RSA(pubkey);
#else
  r = pubkey->pkey.rsa;
#endif
 
  if (RSA_size(r) != 128)
    return E_UNKNOWN;
  if (m_pRSA != NULL)
    RSA_free(m_pRSA);
  m_pRSA = r;
  ::setRSAFlags(m_pRSA);
  return E_SUCCESS;
}

References E_SUCCESS, E_UNKNOWN, CACertificate::m_pCert, m_pRSA, and setRSAFlags().

Referenced by CAMsg::openEncryptedLog().

Here is the call graph for this function:

Here is the caller graph for this function:

setPublicKey() [2/2]

SINT32 CAASymCipher::setPublicKey	(	const UINT8 *	modulus,
		UINT32	moduluslen,
		const UINT8 *	exponent,
		UINT32	exponentlen
	)

Definition at line 741 of file CAASymCipher.cpp.

{
  RSA *tmpRSA = RSA_new();
  UINT32 decLen = 4096;
  UINT8 decBuff[4096];
  CABase64::decode(m, mlen, decBuff, &decLen);
  BIGNUM* bnE = BN_bin2bn(decBuff, decLen, NULL);
  decLen = 4096;
  CABase64::decode(e, elen, decBuff, &decLen);
  BIGNUM* bnN = BN_bin2bn(decBuff, decLen, NULL);
  if (bnN != NULL && bnE != NULL)
    {
      if (m_pRSA != NULL)
        RSA_free(m_pRSA);
      m_pRSA = tmpRSA;
      #if  OPENSSL_VERSION_NUMBER > 0x100020cfL
        RSA_set0_key(m_pRSA,bnN,bnE, NULL );
      #else
        m_pRSA->n=bnN;
        m_pRSA->e=bnE;
      #endif
      ::setRSAFlags(m_pRSA);
      return E_SUCCESS;
    }
  RSA_free(tmpRSA);
  return E_UNKNOWN;
}

References CABase64::decode(), E_SUCCESS, E_UNKNOWN, m_pRSA, and setRSAFlags().

Here is the call graph for this function:

setPublicKeyAsDOMNode()

SINT32 CAASymCipher::setPublicKeyAsDOMNode

(

DOMNode *

node

)

Definition at line 658 of file CAASymCipher.cpp.

{
  DOMNode *root = node;
  while (root != NULL)
    {
      if (equals(root->getNodeName(), "RSAKeyValue"))
        {
          RSA *tmpRSA = RSA_new();
          BIGNUM* n = NULL;
          BIGNUM* e = NULL;
          DOMNode *child = root->getFirstChild();
          while (child != NULL)
            {
              if (equals(child->getNodeName(), "Modulus"))
                {
                  getKeyPart(&n, child);
                }
              else if (equals(child->getNodeName(), "Exponent"))
                {
                  getKeyPart(&e, child);
                }
              child = child->getNextSibling();
            }
          if (n != NULL && e != NULL)
            {
              if (m_pRSA != NULL)
                RSA_free(m_pRSA);
              m_pRSA = tmpRSA;
              #if  OPENSSL_VERSION_NUMBER > 0x100020cfL
                RSA_set0_key(m_pRSA,n,e, NULL );
              #else
                m_pRSA->n=n;
                m_pRSA->e=e;
              #endif
              ::setRSAFlags(m_pRSA);
              return E_SUCCESS;
            }
          RSA_free(tmpRSA);
          return E_UNKNOWN;
        }
      root = root->getNextSibling();
    }
  return E_UNKNOWN;
}

References E_SUCCESS, E_UNKNOWN, equals(), getKeyPart(), m_pRSA, and setRSAFlags().

Referenced by CAMiddleMix::processKeyExchange(), and setPublicKeyAsXML().

Here is the call graph for this function:

Here is the caller graph for this function:

setPublicKeyAsXML()

SINT32 CAASymCipher::setPublicKeyAsXML	(	const UINT8 *	key,
		UINT32	len
	)

Sets the public key to the values stored in key.

The format must match the format XML described for getPublicKeyAsXML().

Parameters

key	byte array which holds the new public key
len	on input,size of key byte array, on successful return number of bytes 'consumed'

Return values

E_UNKNOWN	in case of an error, the cipher is the uninitialized (no key is set)
E_SUCCESS	otherwise

See also

getPublicKeyAsXML

Definition at line 622 of file CAASymCipher.cpp.

{
  if (key == NULL)
    return E_UNKNOWN;
 
  XERCES_CPP_NAMESPACE::DOMDocument *doc = parseDOMDocument(key, len);
  if (doc == NULL)
    {
      return E_UNKNOWN;
    }
  DOMElement *root = doc->getDocumentElement();
  if (root == NULL)
    {
      return E_UNKNOWN;
    }
  return setPublicKeyAsDOMNode(root);
}

References E_UNKNOWN, len, parseDOMDocument(), and setPublicKeyAsDOMNode().

Referenced by CAMiddleMix::init().

Here is the call graph for this function:

Here is the caller graph for this function:

testSpeed()

SINT32 CAASymCipher::testSpeed ( )

static

Definition at line 778 of file CAASymCipher.cpp.

{
  const UINT32 runs = 10000;
  UINT8 *inBuff = new UINT8[128];
  UINT8 *outBuff = new UINT8[128];
  getRandom(inBuff, 128);
  inBuff[0] &= 0x7F;
#ifdef INTEL_IPP_CRYPTO
  int size = 0;
  ippsRSAGetSize(1024, 512, IppRSAprivate, &size);
  IppsRSAState *pCtx = (IppsRSAState *)new UINT8[size];
  IppStatus ret = ippsRSAInit(1024, 512, IppRSAprivate, pCtx);
  if (ret != ippStsNoErr)
    {
      printf("Error in RSA init!\n");
      return E_UNKNOWN;
    }
  ippsBigNumGetSize(1, &size);
  IppsBigNumState *pE = (IppsBigNumState *)(new UINT8[size]);
  ippsBigNumInit(1, pE);
  UINT32 pEValue[] = {0x010001};
  ret = ippsSet_BN(IppsBigNumPOS, 1, pEValue, pE);
  if (ret != ippStsNoErr)
    {
      printf("Error in setBN(e)!\n");
      return E_UNKNOWN;
    }
  ippsRSAGenerate(pE, 1024, 512, 1024, pCtx, myIppBitSupplier, NULL);
  if (ret != ippStsNoErr)
    {
      printf("Error in RSA generate key!\n");
      return E_UNKNOWN;
    }
 
  ippsBigNumGetSize(32, &size);
  IppsBigNumState *pY = (IppsBigNumState *)(new UINT8[size]);
  ippsBigNumInit(32, pY);
 
  IppsBigNumState *pX = (IppsBigNumState *)(new UINT8[size]);
  ippsBigNumInit(32, pX);
  UINT32 *pXValue = new UINT32[32];
  memcpy(pXValue, inBuff, 128);
  pXValue[0] &= 0x7FFFFFFF;
  ippsSet_BN(IppsBigNumPOS, 32, pXValue, pX);
 
#else
  CAASymCipher *pCipher = new CAASymCipher();
  pCipher->generateKeyPair(1024);
  UINT32 iLen = 128;
  pCipher->encryptOAEP(inBuff, 86, inBuff, &iLen);
#endif
  UINT64 start, end;
  getcurrentTimeMillis(start);
  for (UINT32 i = 0; i < runs; i++)
    {
#ifdef INTEL_IPP_CRYPTO
      IppStatus ret = ippsRSADecrypt(pX, pY, pCtx);
      if (ret != ippStsNoErr)
        {
          printf("Error in RSADEcrypt %i!\n", ret);
          return E_UNKNOWN;
        }
#else
      pCipher->decryptOAEP(inBuff, outBuff, &iLen);
//        pCipher->decrypt(inBuff,outBuff);
#endif
    }
  getcurrentTimeMillis(end);
  UINT32 d = diff64(end, start);
  printf("CAASymCiper::testSpeed() takes %u ms for %u decrypts!\n", d, runs);
  return E_SUCCESS;
}

References CAASymCipher(), decryptOAEP(), diff64(), E_SUCCESS, E_UNKNOWN, encryptOAEP(), generateKeyPair(), getcurrentTimeMillis(), and getRandom().

Here is the call graph for this function:

Member Data Documentation

m_pRSA

RSA* CAASymCipher::m_pRSA

private

Definition at line 99 of file CAASymCipher.hpp.

Referenced by CAASymCipher(), decrypt(), decryptOAEP(), destroy(), encrypt(), encryptOAEP(), encryptPKCS1(), generateKeyPair(), getPublicKeyAsDOMElement(), getPublicKeyAsXML(), setPublicKey(), and setPublicKeyAsDOMNode().

---

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

• CAASymCipher.hpp
• CAASymCipher.cpp