This class could be used for encryption/decryption of data (streams) with AES using 128bit GCM mode. More...

#include <CASymCipherGCM.hpp>

Inheritance diagram for CASymCipherGCM:

Collaboration diagram for CASymCipherGCM:

Public Member Functions
	CASymCipherGCM ()

	~CASymCipherGCM ()

bool	isKeyValid ()

void	setGCMKeys (UINT8 keyRecv, UINT8 keySend)

SINT32	encryptMessage (const UINT8 in, UINT32 inlen, UINT8 out)

SINT32	decryptMessage (const UINT8 in, UINT32 inlen, UINT8 out, bool integrityCheck)

Public Member Functions inherited from CALockAble
	CALockAble ()

virtual	~CALockAble ()

SINT32	lock ()
	Locks the lockable object by threadsafe incrementing a reference counter. More...

SINT32	unlock ()
	Unlocks the lockable object by threadsafe decrementing a reference counter. More...

Protected Attributes
bool	m_bKeySet

Private Attributes
CAMutex *	m_pcsEnc

CAMutex *	m_pcsDec

gcm_ctx_64k *	m_pGCMCtxEnc

gcm_ctx_64k *	m_pGCMCtxDec

UINT32	m_nEncMsgCounter

UINT32 *	m_pEncMsgIV

UINT32	m_nDecMsgCounter

UINT32 *	m_pDecMsgIV

Additional Inherited Members
Protected Member Functions inherited from CALockAble
SINT32	waitForDestroy ()
	If called checks if the reference counter equals zero. More...

Detailed Description

This class could be used for encryption/decryption of data (streams) with AES using 128bit GCM mode.

Definition at line 38 of file CASymCipherGCM.hpp.

Constructor & Destructor Documentation

◆ CASymCipherGCM()

CASymCipherGCM::CASymCipherGCM ( )

inline

Definition at line 44 of file CASymCipherGCM.hpp.

         {
           m_bKeySet=false;
  
  
           m_nEncMsgCounter = 0;
           m_pEncMsgIV = new UINT32[3];
           memset(m_pEncMsgIV, 0, 12);
           m_nDecMsgCounter = 0;
           m_pDecMsgIV = new UINT32[3];
           memset(m_pDecMsgIV, 0, 12);
  
           m_pGCMCtxEnc = NULL;
           m_pGCMCtxDec = NULL;
  
           m_pcsEnc = new CAMutex();
           m_pcsDec = new CAMutex();
         }

References m_bKeySet, m_nDecMsgCounter, m_nEncMsgCounter, m_pcsDec, m_pcsEnc, m_pDecMsgIV, m_pEncMsgIV, m_pGCMCtxDec, and m_pGCMCtxEnc.

◆ ~CASymCipherGCM()

CASymCipherGCM::~CASymCipherGCM ( )

inline

Definition at line 63 of file CASymCipherGCM.hpp.

         {
 #ifndef ONLY_LOCAL_PROXY
           waitForDestroy();
 #endif
  
           delete [] m_pEncMsgIV;
           m_pEncMsgIV = NULL;
           delete [] m_pDecMsgIV;
           m_pDecMsgIV = NULL;
  
 #ifndef USE_OPENSSL_GCM
           delete m_pGCMCtxEnc;
           delete m_pGCMCtxDec;
 #else
           CRYPTO_gcm128_release(m_pGCMCtxEnc);
           CRYPTO_gcm128_release(m_pGCMCtxDec);
 #endif
  
           m_pGCMCtxEnc = NULL;
           m_pGCMCtxDec = NULL;
  
           delete m_pcsEnc;
           m_pcsEnc = NULL;
           delete m_pcsDec;
           m_pcsDec = NULL;
         }

References m_pcsDec, m_pcsEnc, m_pDecMsgIV, m_pEncMsgIV, m_pGCMCtxDec, m_pGCMCtxEnc, and CALockAble::waitForDestroy().

Here is the call graph for this function:

Member Function Documentation

◆ decryptMessage()

SINT32 CASymCipherGCM::decryptMessage	(	const UINT8 *	in,
		UINT32	inlen,
		UINT8 *	out,
		bool	integrityCheck
	)

inline

Definition at line 156 of file CASymCipherGCM.hpp.

       {
 #ifdef NO_ENCRYPTION
         memmove(out, in, inlen);
         return E_SUCCESS;
 #endif
  
         SINT32 ret = E_UNKNOWN;
         //m_pcsDec->lock();
         m_pDecMsgIV[2] = htonl(m_nDecMsgCounter);
         if (integrityCheck)
         {
           m_nDecMsgCounter++;
 #ifndef USE_OPENSSL_GCM
           ret = ::gcm_decrypt_64k(m_pGCMCtxDec, m_pDecMsgIV, in, inlen - 16, in + inlen - 16, out);
 #else
           CRYPTO_gcm128_setiv(m_pGCMCtxDec, (UINT8*)m_pDecMsgIV, 12);
           CRYPTO_gcm128_decrypt(m_pGCMCtxDec, in, out, inlen - 16);
           ret = CRYPTO_gcm128_finish(m_pGCMCtxDec, in + inlen - 16, 16);
 #endif
         }
         else
         {
 #ifndef USE_OPENSSL_GCM
           ret = ::gcm_decrypt_64k(m_pGCMCtxDec, m_pDecMsgIV, in, inlen, out);
 #else
           CRYPTO_gcm128_setiv(m_pGCMCtxDec, (UINT8*)m_pDecMsgIV, 12);
           ret = CRYPTO_gcm128_decrypt(m_pGCMCtxDec, in, out, inlen);
 #endif
         }
         //m_pcsDec->unlock();
 #ifndef USE_OPENSSL_GCM
         if (ret == 0)
 #else
         if (ret != 0)
 #endif
           return E_UNKNOWN;
         return E_SUCCESS;
  
       }

References E_SUCCESS, E_UNKNOWN, m_nDecMsgCounter, m_pDecMsgIV, and m_pGCMCtxDec.

Referenced by CALastMixA::loop().

Here is the caller graph for this function:

◆ encryptMessage()

SINT32 CASymCipherGCM::encryptMessage	(	const UINT8 *	in,
		UINT32	inlen,
		UINT8 *	out
	)

inline

Definition at line 136 of file CASymCipherGCM.hpp.

       {
 #ifdef NO_ENCRYPTION
         memmove(out, in, inlen);
         return E_SUCCESS;
 #endif
  
         //m_pcsEnc->lock();
         m_pEncMsgIV[2] = htonl(m_nEncMsgCounter);
         m_nEncMsgCounter++;
 #ifndef USE_OPENSSL_GCM
         gcm_encrypt_64k(m_pGCMCtxEnc, m_pEncMsgIV, in, inlen, out, (UINT32*)(out + inlen));
 #else
         CRYPTO_gcm128_setiv(m_pGCMCtxEnc, (UINT8*)m_pEncMsgIV, 12);
         CRYPTO_gcm128_encrypt(m_pGCMCtxEnc, in, out, inlen);
         CRYPTO_gcm128_tag(m_pGCMCtxEnc, out + inlen, 16);
 #endif
         //m_pcsEnc->unlock();
         return E_SUCCESS;
       }

References E_SUCCESS, m_nEncMsgCounter, m_pEncMsgIV, and m_pGCMCtxEnc.

Referenced by CALastMixA::loop().

Here is the caller graph for this function:

◆ isKeyValid()

bool CASymCipherGCM::isKeyValid ( )

inline

Definition at line 90 of file CASymCipherGCM.hpp.

         {
           return m_bKeySet;
         }

References m_bKeySet.

◆ setGCMKeys()

void CASymCipherGCM::setGCMKeys	(	UINT8 *	keyRecv,
		UINT8 *	keySend
	)

inline

Definition at line 95 of file CASymCipherGCM.hpp.

       {
  
 #ifndef USE_OPENSSL_GCM
         m_pGCMCtxEnc = new gcm_ctx_64k;
         m_pGCMCtxDec = new gcm_ctx_64k;
 #else
         //Note the have to provide *some* key (OpenSSL API enforced --> so the use the variables we have anyway..)
         // The Key will be overriden by a call to setKeyGCM in any case!
         AES_set_encrypt_key(m_iv1, 128, m_keyAES1);
         m_pGCMCtxEnc = CRYPTO_gcm128_new(m_keyAES1, (block128_f)AES_encrypt);
         m_pGCMCtxDec = CRYPTO_gcm128_new(m_keyAES1, (block128_f)AES_encrypt);
 #endif
  
  
  
 #ifndef USE_OPENSSL_GCM
         if (m_pGCMCtxDec != NULL)
           delete m_pGCMCtxDec;
         if (m_pGCMCtxEnc != NULL)
           delete m_pGCMCtxEnc;
  
         m_pGCMCtxEnc = new gcm_ctx_64k;
         m_pGCMCtxDec = new gcm_ctx_64k;
         gcm_init_64k(m_pGCMCtxEnc, keySend, 128);
         gcm_init_64k(m_pGCMCtxDec, keyRecv, 128);
 #else
         AES_set_encrypt_key(keyRecv, 128, m_keyAES1);
         AES_set_encrypt_key(keySend, 128, m_keyAES2);
         CRYPTO_gcm128_release(m_pGCMCtxEnc);
         CRYPTO_gcm128_release(m_pGCMCtxDec);
         m_pGCMCtxEnc = CRYPTO_gcm128_new(m_keyAES2, (block128_f)AES_encrypt);
         m_pGCMCtxDec = CRYPTO_gcm128_new(m_keyAES1, (block128_f)AES_encrypt);
 #endif
         //reset IV
         m_nEncMsgCounter = 0;
         memset(m_pEncMsgIV, 0, 12);
         m_nDecMsgCounter = 0;
         memset(m_pDecMsgIV, 0, 12);
  
       }