CASymCipherOFB Class Reference

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

#include <CASymCipherOFB.hpp>

Inheritance diagram for CASymCipherOFB:

Collaboration diagram for CASymCipherOFB:

Public Member Functions
	CASymCipherOFB ()
	~CASymCipherOFB ()
bool	isKeyValid ()
SINT32	setKey (const UINT8 *key)
	Sets the keys for crypt1() and crypt2() to the same key. More...
SINT32	setKeys (const UINT8 *key, UINT32 keysize)
	Sets the keys for crypt1() and crypt2() either to the same key (if keysize==KEY_SIZE) or to different values, if keysize==2* KEY_SIZE. More...
SINT32	setKey (const UINT8 *key, bool bEncrypt)
	Sets the key1 and key2 used for encryption/decryption to the same value of key. More...
SINT32	setIVs (const UINT8 *p_iv)
	Sets iv1 and iv2 to p_iv. More...
SINT32	setIV2 (const UINT8 *p_iv)
	Sets iv2 to p_iv. More...
SINT32	crypt1 (const UINT8 *in, UINT8 *out, UINT32 len)
	Encryptes/Decrpytes in to out using iv1 and key1. More...
SINT32	crypt2 (const UINT8 *in, UINT8 *out, UINT32 len)
	Decryptes in to out using iv2 and key2. More...
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...

Static Public Member Functions
static SINT32	testSpeed ()
Static Public Member Functions inherited from CASymChannelCipher
static const UINT8 *const	getAlgorithmName (SYMCHANNELCIPHER_ALGORITHM alg)

Protected Attributes
AES_KEY *	m_keyAES1
AES_KEY *	m_keyAES2
UINT8 *	m_iv1
UINT8 *	m_iv2
bool	m_bKeySet

Private Attributes
CAMutex *	m_pcsEnc
CAMutex *	m_pcsDec
UINT32 *	m_pEncMsgIV
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 OFB mode.

Because of the OFB mode technical encryption and decrpytion are the same (depending on the kind of input). Therefore there is only a general crypt() function. This class has a 2-in-1 feature: Two independent IVs are available. Therefore we have crypt1() and crypt2() depending on the used IV.

Definition at line 43 of file CASymCipherOFB.hpp.

Constructor & Destructor Documentation

CASymCipherOFB()

CASymCipherOFB::CASymCipherOFB ( )

inline

Definition at line 47 of file CASymCipherOFB.hpp.

        {
          m_bKeySet=false;
#ifdef INTEL_IPP_CRYPTO
          int size=0;
          ippsRijndael128GetSize(&size);
          m_keyAES1=(IppsRijndael128Spec*)new UINT8[size];
          m_keyAES2=(IppsRijndael128Spec*)new UINT8[size];
#else
          m_keyAES1=new AES_KEY;
          m_keyAES2=new AES_KEY;
#endif
 
          m_iv1=new UINT8[16];
          m_iv2=new UINT8[16];
 
          m_pcsEnc = new CAMutex();
          m_pcsDec = new CAMutex();
        }

References m_bKeySet, m_iv1, m_iv2, m_keyAES1, m_keyAES2, m_pcsDec, and m_pcsEnc.

~CASymCipherOFB()

CASymCipherOFB::~CASymCipherOFB ( )

inline

Definition at line 67 of file CASymCipherOFB.hpp.

        {
#ifndef ONLY_LOCAL_PROXY
          waitForDestroy();
#endif
#ifdef INTEL_IPP_CRYPTO
          delete[] (UINT8*)m_keyAES1;
          delete[] (UINT8*)m_keyAES2;
#else
          delete m_keyAES1;
          delete m_keyAES2;
#endif
          m_keyAES1 = NULL;
          m_keyAES2 = NULL;
          delete[] m_iv1;
          m_iv1 = NULL;
          delete[] m_iv2;
          m_iv2 = NULL;
 
          delete m_pcsEnc;
          m_pcsEnc = NULL;
          delete m_pcsDec;
          m_pcsDec = NULL;
        }

References m_iv1, m_iv2, m_keyAES1, m_keyAES2, m_pcsDec, m_pcsEnc, and CALockAble::waitForDestroy().

Here is the call graph for this function:

Member Function Documentation

crypt1()

SINT32 CASymCipherOFB::crypt1 ( const UINT8 *  in, UINT8 *  out, UINT32  len  )

virtual

Encryptes/Decrpytes in to out using iv1 and key1.

AES is used for encryption and the encryption is done with a special 128bit-OFB mode: In the case that (len mod 16 !=0) the unused cipher output bits are discarded and NOT used next time encryptAES() is called. That means that every time encrpytAES() is called at first new cipher output is created by calling AES-encrypt(iv).

Parameters

in	input (plain text) bytes
out	output (encrpyted) bytes
len	len of input. because the cipher preserves the size, len of output=len of input

Return values

E_SUCCESS

Implements CASymChannelCipher.

Definition at line 136 of file CASymCipherOFB.cpp.

{
#ifdef INTEL_IPP_CRYPTO
  UINT32 k=len&0xFFFFFFF0;
  ippsRijndael128EncryptOFB(in,out,k,16, m_keyAES1,m_iv1);
//        if((len%16)!=0)
//          {
  ippsRijndael128EncryptOFB(in+k,out+k,len%16,len%16, m_keyAES1,m_iv1);
//          }
  return E_SUCCESS;
#endif
  UINT32 i=0;
  while(i+15<len)
    {
#ifdef INTEL_IPP_CRYPTO
      ippsRijndael128EncryptECB(m_iv1,m_iv1,KEY_SIZE, m_keyAES1, IppsCPPaddingNONE);
#else
#ifdef AES_NI
//    int outlen = 16;
//    EVP_EncryptUpdate(m_ctxAES1, m_iv1, &outlen, m_iv1, 16);
      aesni_encrypt(m_iv1,m_iv1,m_keyAES1);
#else
      AES_encrypt(m_iv1,m_iv1,m_keyAES1);
#endif
#endif
      out[i]=in[i]^m_iv1[0];
      i++;
      out[i]=in[i]^m_iv1[1];
      i++;
      out[i]=in[i]^m_iv1[2];
      i++;
      out[i]=in[i]^m_iv1[3];
      i++;
      out[i]=in[i]^m_iv1[4];
      i++;
      out[i]=in[i]^m_iv1[5];
      i++;
      out[i]=in[i]^m_iv1[6];
      i++;
      out[i]=in[i]^m_iv1[7];
      i++;
      out[i]=in[i]^m_iv1[8];
      i++;
      out[i]=in[i]^m_iv1[9];
      i++;
      out[i]=in[i]^m_iv1[10];
      i++;
      out[i]=in[i]^m_iv1[11];
      i++;
      out[i]=in[i]^m_iv1[12];
      i++;
      out[i]=in[i]^m_iv1[13];
      i++;
      out[i]=in[i]^m_iv1[14];
      i++;
      out[i]=in[i]^m_iv1[15];
      i++;
    }
  if(i<len) //In this case len-i<16 !
    {
#ifdef INTEL_IPP_CRYPTO
      ippsRijndael128EncryptECB(m_iv1,m_iv1,KEY_SIZE, m_keyAES1, IppsCPPaddingNONE);
#else
#ifdef AES_NI
    //int outlen = 16;
    //EVP_EncryptUpdate(m_ctxAES1, m_iv1, &outlen, m_iv1, 16);
      aesni_encrypt(m_iv1,m_iv1,m_keyAES1);
 
#else
      AES_encrypt(m_iv1,m_iv1,m_keyAES1);
#endif
#endif
      len-=i;
      for(UINT32 k=0; k<len; k++)
        {
          out[i]=in[i]^m_iv1[k];
          i++;
        }
    }
  return E_SUCCESS;
}

References E_SUCCESS, KEY_SIZE, len, m_iv1, and m_keyAES1.

crypt2()

SINT32 CASymCipherOFB::crypt2 ( const UINT8 *  in, UINT8 *  out, UINT32  len  )

virtual

Decryptes in to out using iv2 and key2.

Parameters

in	input (encrypted) bytes
out	output (decrpyted) bytes
len	len of input. because the cipher preserves the size, len of output=len of input

Return values

E_SUCCESS

Implements CASymChannelCipher.

Definition at line 225 of file CASymCipherOFB.cpp.

{
 
  UINT32 i=0;
  while(i+15<len)
    {
#ifdef INTEL_IPP_CRYPTO
      ippsRijndael128EncryptECB(m_iv1,m_iv1,KEY_SIZE, m_keyAES2, IppsCPPaddingNONE);
#else
#ifdef AES_NI
      aesni_encrypt(m_iv2,m_iv2,m_keyAES2);
#else
      AES_encrypt(m_iv2,m_iv2,m_keyAES2);
#endif
#endif
      out[i]=in[i]^m_iv2[0];
      i++;
      out[i]=in[i]^m_iv2[1];
      i++;
      out[i]=in[i]^m_iv2[2];
      i++;
      out[i]=in[i]^m_iv2[3];
      i++;
      out[i]=in[i]^m_iv2[4];
      i++;
      out[i]=in[i]^m_iv2[5];
      i++;
      out[i]=in[i]^m_iv2[6];
      i++;
      out[i]=in[i]^m_iv2[7];
      i++;
      out[i]=in[i]^m_iv2[8];
      i++;
      out[i]=in[i]^m_iv2[9];
      i++;
      out[i]=in[i]^m_iv2[10];
      i++;
      out[i]=in[i]^m_iv2[11];
      i++;
      out[i]=in[i]^m_iv2[12];
      i++;
      out[i]=in[i]^m_iv2[13];
      i++;
      out[i]=in[i]^m_iv2[14];
      i++;
      out[i]=in[i]^m_iv2[15];
      i++;
    }
  if(i<len)
    {
#ifdef INTEL_IPP_CRYPTO
      ippsRijndael128EncryptECB(m_iv1,m_iv1,KEY_SIZE, m_keyAES2, IppsCPPaddingNONE);
#else
#ifdef AES_NI
      aesni_encrypt(m_iv2,m_iv2,m_keyAES2);
#else
      AES_encrypt(m_iv2,m_iv2,m_keyAES2);
#endif
#endif
      len-=i;
      for(UINT32 k=0; k<len; k++)
        {
          out[i]=in[i]^m_iv2[k];
          i++;
        }
    }
  return E_SUCCESS;
}

References E_SUCCESS, KEY_SIZE, len, m_iv1, m_iv2, and m_keyAES2.

isKeyValid()

bool CASymCipherOFB::isKeyValid ( )

inlinevirtual

Implements CASymChannelCipher.

Definition at line 91 of file CASymCipherOFB.hpp.

        {
          return m_bKeySet;
        }

References m_bKeySet.

setIV2()

SINT32 CASymCipherOFB::setIV2 ( const UINT8 *  p_iv )

inlinevirtual

Sets iv2 to p_iv.

Parameters

p_iv	16 random bytes used for new iv2.

Return values

E_SUCCESS

Implements CASymChannelCipher.

Definition at line 120 of file CASymCipherOFB.hpp.

        {
          memcpy(m_iv2,p_iv,16);
          return E_SUCCESS;
        }

References E_SUCCESS, and m_iv2.

setIVs()

SINT32 CASymCipherOFB::setIVs ( const UINT8 *  p_iv )

inlinevirtual

Sets iv1 and iv2 to p_iv.

Parameters

p_iv	16 random bytes used for new iv1 and iv2.

Return values

E_SUCCESS

Implements CASymChannelCipher.

Definition at line 109 of file CASymCipherOFB.hpp.

        {
          memcpy(m_iv1,p_iv,16);
          memcpy(m_iv2,p_iv,16);
          return E_SUCCESS;
        }

References E_SUCCESS, m_iv1, and m_iv2.

setKey() [1/2]

SINT32 CASymCipherOFB::setKey ( const UINT8 *  key )

virtual

Sets the keys for crypt1() and crypt2() to the same key.

Sets the key1 and key2 used for encryption/decryption.

Also resets the IVs to zero!

Parameters

key	16 random bytes used as key

Return values

E_SUCCESS

Implements CASymChannelCipher.

Definition at line 48 of file CASymCipherOFB.cpp.

{
  return setKey(key,true);
}

Referenced by setKeys().

Here is the caller graph for this function:

setKey() [2/2]

SINT32 CASymCipherOFB::setKey	(	const UINT8 *	key,
		bool	bEncrypt
	)

Sets the key1 and key2 used for encryption/decryption to the same value of key.

Also resets the IVs to zero!

Parameters

key	16 random bytes used as key
bEncrypt	if true, the key should be used for encryption (otherwise it will be used for decryption)

Return values

E_SUCCESS

Definition at line 58 of file CASymCipherOFB.cpp.

{
  memset(m_iv1,0,16);
  memset(m_iv2,0,16);
 
#ifdef INTEL_IPP_CRYPTO
  ippsRijndael128Init(key, IppsRijndaelKey128,m_keyAES1);
  ippsRijndael128Init(key, IppsRijndaelKey128,m_keyAES2);
#else
  if(bEncrypt)
    {
#ifdef AES_NI
  aesni_set_encrypt_key(key,128,m_keyAES1);
  aesni_set_encrypt_key(key,128,m_keyAES2);
 
#else
      AES_set_encrypt_key(key,128,m_keyAES1);
      AES_set_encrypt_key(key,128,m_keyAES2);
#endif
    }
  else
    {
#ifdef AES_NI
      aesni_set_decrypt_key(key,128,m_keyAES1);
      aesni_set_decrypt_key(key,128,m_keyAES2);
#else
      AES_set_decrypt_key(key,128,m_keyAES1);
      AES_set_decrypt_key(key,128,m_keyAES2);
#endif
    }
#endif
  m_bKeySet=true;
  return E_SUCCESS;
}

References E_SUCCESS, m_bKeySet, m_iv1, m_iv2, m_keyAES1, and m_keyAES2.

setKeys()

SINT32 CASymCipherOFB::setKeys ( const UINT8 *  key, UINT32  keysize  )

virtual

Sets the keys for crypt1() and crypt2() either to the same key (if keysize==KEY_SIZE) or to different values, if keysize==2* KEY_SIZE.

Implements CASymChannelCipher.

Definition at line 93 of file CASymCipherOFB.cpp.

{
#ifdef _DEBUG
  CAMsg::printMsg(LOG_DEBUG, "CASymCipherOFB::setKeys() - keysize %u\n",keysize);
#endif
  if(keysize==KEY_SIZE)
    {
      return setKey(key);
    }
  else if(keysize==2*KEY_SIZE)
    {
#ifdef INTEL_IPP_CRYPTO
      ippsRijndael128Init(key, IppsRijndaelKey128,m_keyAES1);
      ippsRijndael128Init(key+KEY_SIZE, IppsRijndaelKey128,m_keyAES2);
#else
#ifdef AES_NI
      aesni_set_encrypt_key(key,128,m_keyAES1);
      aesni_set_encrypt_key(key+KEY_SIZE,128,m_keyAES2);
#else
      AES_set_encrypt_key(key,128,m_keyAES1);
      AES_set_encrypt_key(key+KEY_SIZE,128,m_keyAES2);
#endif
#endif
      memset(m_iv1,0,16);
      memset(m_iv2,0,16);
      m_bKeySet=true;
      return E_SUCCESS;
    }
  return E_UNKNOWN;
}

References E_SUCCESS, E_UNKNOWN, KEY_SIZE, m_bKeySet, m_iv1, m_iv2, m_keyAES1, m_keyAES2, CAMsg::printMsg(), and setKey().

Here is the call graph for this function:

testSpeed()

static SINT32 CASymCipherOFB::testSpeed ( )

static

Member Data Documentation

m_bKeySet

bool CASymCipherOFB::m_bKeySet

protected

Definition at line 149 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), isKeyValid(), setKey(), and setKeys().

m_iv1

UINT8* CASymCipherOFB::m_iv1

protected

Definition at line 147 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), crypt1(), crypt2(), setIVs(), setKey(), setKeys(), and ~CASymCipherOFB().

m_iv2

UINT8* CASymCipherOFB::m_iv2

protected

Definition at line 148 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), crypt2(), setIV2(), setIVs(), setKey(), setKeys(), and ~CASymCipherOFB().

m_keyAES1

AES_KEY* CASymCipherOFB::m_keyAES1

protected

Definition at line 143 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), crypt1(), setKey(), setKeys(), and ~CASymCipherOFB().

m_keyAES2

AES_KEY* CASymCipherOFB::m_keyAES2

protected

Definition at line 144 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), crypt2(), setKey(), setKeys(), and ~CASymCipherOFB().

m_pcsDec

CAMutex* CASymCipherOFB::m_pcsDec

private

Definition at line 133 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), and ~CASymCipherOFB().

m_pcsEnc

CAMutex* CASymCipherOFB::m_pcsEnc

private

Definition at line 132 of file CASymCipherOFB.hpp.

Referenced by CASymCipherOFB(), and ~CASymCipherOFB().

m_pDecMsgIV

UINT32* CASymCipherOFB::m_pDecMsgIV

private

Definition at line 135 of file CASymCipherOFB.hpp.

m_pEncMsgIV

UINT32* CASymCipherOFB::m_pEncMsgIV

private

Definition at line 134 of file CASymCipherOFB.hpp.

---

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

• CASymCipherOFB.hpp
• CASymCipherOFB.cpp