/*

* Copyright (c) 2000, 2004, 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   This file contains the implementation of CCrCrypto class. 

*

*/

//  INCLUDE FILES

#include "crcrypto.h"

#include <e32def.h>  // REINTERPRET_CAST

#include "crdata.h"

#include <bigint.h>  // Big integer.

#include <hash.h>

#include <symmetric.h>

// -----------------------------------------------------------------------------

// CCrCrypto

// Constructor.

// -----------------------------------------------------------------------------

CCrCrypto::CCrCrypto()

    : iAlgorithmInfos(0)

    {

    }

// -----------------------------------------------------------------------------

// ~CCrCrypto

// Destructor.

// -----------------------------------------------------------------------------

CCrCrypto::~CCrCrypto()

    {

    if( iAlgorithmInfos )

        {

        Reset();

        iAlgorithmInfos->Reset();

        delete iAlgorithmInfos;

        iAlgorithmInfos = NULL;

        }

    }

// -----------------------------------------------------------------------------

// CCrCrypto::ConstructL

// This function initializes this object's members.

// -----------------------------------------------------------------------------

void CCrCrypto::ConstructL()

    {

    iAlgorithmInfos = new (ELeave) CArrayPtrFlat<CCrAlgInfo>(1);

    }

// -----------------------------------------------------------------------------

// CCrCrypto::NewLC

// -----------------------------------------------------------------------------

CCrCrypto* CCrCrypto::NewLC()

    {

    CCrCrypto* self = new (ELeave) CCrCrypto();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self; 

    }

// -----------------------------------------------------------------------------

// CCrCrypto::NewL

// -----------------------------------------------------------------------------

CCrCrypto* CCrCrypto::NewL()

    {

    CCrCrypto* self = NewLC();

    CleanupStack::Pop();

    return self; 

    }

// -----------------------------------------------------------------------------

// CCrCrypto::Reset

// Reset all algorithms initialized into this object and free

// memory associated to them. Note that GetDigest etc. functions are

// meaningles after this until new ones are initialized and finalized.

// -----------------------------------------------------------------------------

void CCrCrypto::Reset()

    {

    TInt        i = 0;

    TInt        size = 0;

    CCrAlgInfo* algInfo = 0;

    size = iAlgorithmInfos->Count();

    for (i = 0; i < size; i++)

        {    

        algInfo = (*iAlgorithmInfos)[i];

		if (algInfo)

			{

			switch (algInfo->iType)

				{

				case ECrDES2:

				case ECrDES3:

					{

                    if (algInfo->iAlgorithmObject)

                        {

						delete algInfo->iAlgorithmObject;

                        algInfo->iAlgorithmObject = NULL;

                        }

                    if (algInfo->iPadding)

                        {

                        delete algInfo->iPadding;

                        algInfo->iPadding = NULL;

                        }

                    break;

                    }

				default:

					{

                    if (algInfo->iAlgorithmObject)

                        {

                        delete algInfo->iAlgorithmObject;

                        algInfo->iAlgorithmObject = NULL;

                        }

                    if (algInfo->iPadding)

                        {

                        delete algInfo->iPadding;

                        algInfo->iPadding = NULL;

                        }

                    break;

					}

                }

            }

        }

    iAlgorithmInfos->ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CCrCrypto::InitCrypt3DESL

// Initialize encryption or decryption with 3DES algorithm.

// -----------------------------------------------------------------------------

TCrStatus CCrCrypto::InitCrypt3DESL(

    const TDesC8& aKey1,

    const TDesC8& aKey2,

    const TDesC8& aKey3,

    const TDesC8& aIV,              

    TBool         aEncrypt,   // ETrue  

    TCrSymmMode   aMode,      // ECrCBC

    TPaddingRule  /*aPadRule*/)   // ECrPKCS1

    {

    // Number of items pushed to CleanupStack

    TUint pushedToCStack = 0;

    // Combined keys.

    HBufC8* keys = HBufC8::NewLC(

        aKey1.Length() + aKey2.Length() + aKey3.Length());

    ++pushedToCStack;

    TPtr8 ptrKeys = keys->Des();

    // Combine given keys to be able to give them to algorithm info object.

    ptrKeys = aKey1;

    ptrKeys.Append(aKey2);

    ptrKeys.Append(aKey3);

    // Create new algorithm info object.

    CCrAlgInfo* algInfo = CCrAlgInfo::NewLC(

        ECrDES3,

        *keys,

        aIV,

        aEncrypt,

        ETrue,

        aMode);

    ++pushedToCStack;

    switch (aMode)

        {

        case ECrCBC:

            {

			    if (aEncrypt)

				    {

				    C3DESEncryptor* tripleDes = C3DESEncryptor::NewL(*algInfo->iKey);

				    CleanupStack::PushL(tripleDes);

				    CModeCBCEncryptor* cbcEncryptor = CModeCBCEncryptor::NewL(tripleDes, aIV);

				    CleanupStack::Pop(tripleDes); // CModeCBCEncryptor takes care of tripleDes now

				    CleanupStack::PushL(cbcEncryptor);

				    CPaddingPKCS7* padding = CPaddingPKCS7::NewL(tripleDes->BlockSize());							

				    CleanupStack::PushL(padding);

				    CBufferedEncryptor* encryptor = CBufferedEncryptor::NewL(cbcEncryptor, padding);

				    CleanupStack::Pop(2); // CBufferedEncryptor takes care of freeing	

				    algInfo->iAlgorithmObject = encryptor;

				    }

			    else

				    {			

				    C3DESDecryptor* tripleDes = C3DESDecryptor::NewL(*algInfo->iKey);

				    CleanupStack::PushL(tripleDes);

				    CModeCBCDecryptor* cbcDecryptor = CModeCBCDecryptor::NewL(tripleDes, aIV);

				    CleanupStack::Pop(tripleDes); // CModeCBCEncryptor takes care of tripleDes now

				    CleanupStack::PushL(cbcDecryptor);

				    CPaddingPKCS7* padding = CPaddingPKCS7::NewL(tripleDes->BlockSize());

				    CleanupStack::PushL(padding);

				    CBufferedDecryptor* decryptor = CBufferedDecryptor::NewL(cbcDecryptor, padding);

				    CleanupStack::Pop(2); // CBufferedDecryptor takes care of freeing	

				    algInfo->iAlgorithmObject = decryptor;							

				    }	                    

            break;

            }

        case ECrCFB:

            {

		    return KCrCrypto | KCrUnknownMode;

            }

        case ECrECB:

            {

            return KCrCrypto | KCrUnknownMode;

            }

        case ECrOFB:

            {

		    return KCrCrypto | KCrUnknownMode;

            }

        default:

            {

            return KCrCrypto | KCrUnknownMode;

            }

        }

    CleanupStack::PushL(algInfo->iAlgorithmObject);

    ++pushedToCStack;

    // Append new algorithm info object into member set.

    iAlgorithmInfos->AppendL(algInfo);

    CleanupStack::Pop(pushedToCStack);

    delete keys;

    keys = NULL;

    return KCrOK;

    }

// -----------------------------------------------------------------------------

// CCrCrypto::InitCryptRC2L

// Initialize encryption or decryption with RC2 algorithm.

// -----------------------------------------------------------------------------

TCrStatus CCrCrypto::InitCryptRC2L(

    const TDesC8& aKey,             

    const TDesC8& aIV,

    TBool         aEncrypt,          // ETrue

    TInt          aEffectiveKeyLen,  // If 0 given, key len is used.

    TCrSymmMode   aMode,             // ECrCBC

    TPaddingRule  /*aPadRule */)          // ECrPKCS1

    {

    // Number of items pushed to CleanupStack

    TUint pushedToCStack = 0;

    // Create new algorithm info object.

    CCrAlgInfo* algInfo = CCrAlgInfo::NewLC(

        ECrRC2,

        aKey,

        aIV,

        aEncrypt,

        ETrue,

        aMode);

    ++pushedToCStack;

    // If given effective key length is zero, use key length.

    if (aEffectiveKeyLen == 0)

        {

        aEffectiveKeyLen = algInfo->iKey->Length() * 8;

        }

    // Create cipher object.

    switch (aMode)

        {

        case ECrCBC:

            {

			if (aEncrypt)

				{

				CRC2Encryptor* rc2 = CRC2Encryptor::NewL(*algInfo->iKey, aEffectiveKeyLen);

				CleanupStack::PushL(rc2);

				CModeCBCEncryptor* cbcEncryptor = CModeCBCEncryptor::NewL(rc2, aIV);

				CleanupStack::Pop(rc2); // CModeCBCEncryptor takes care of rc2 now

				CleanupStack::PushL(cbcEncryptor);

				CPaddingPKCS7* padding = CPaddingPKCS7::NewL(rc2->BlockSize());

				CleanupStack::PushL(padding);

				CBufferedEncryptor* encryptor = CBufferedEncryptor::NewL(cbcEncryptor, padding);

				CleanupStack::Pop(2); // CBufferedEncryptor takes care of freeing

				algInfo->iAlgorithmObject = encryptor;							

				}

			else

				{			

				CRC2Decryptor* rc2 = CRC2Decryptor::NewL(*algInfo->iKey, aEffectiveKeyLen);

				CleanupStack::PushL(rc2);

				CModeCBCDecryptor* cbcDecryptor = CModeCBCDecryptor::NewL(rc2, aIV);

				CleanupStack::Pop(rc2); // CModeCBCEncryptor takes care of rc2 now

				CleanupStack::PushL(cbcDecryptor);

				CPaddingPKCS7* padding = CPaddingPKCS7::NewL(rc2->BlockSize());

				CleanupStack::PushL(padding);

				CBufferedDecryptor* decryptor = CBufferedDecryptor::NewL(cbcDecryptor, padding);

				CleanupStack::Pop(2); // CBufferedDecryptor takes care of freeing

				algInfo->iAlgorithmObject = decryptor;							

				}	                    

            algInfo->iMode = ECrCBC;

            break;

            }

        case ECrCFB:

            {

            return KCrCrypto | KCrUnknownMode;

            }

        case ECrECB:

            {          

            return KCrCrypto | KCrUnknownMode;

            }

        case ECrOFB:

            {

			return KCrCrypto | KCrUnknownMode;

            }

        default:

            {

            return KCrCrypto | KCrUnknownMode;

            }

        }

    CleanupStack::PushL(algInfo->iAlgorithmObject);

    ++pushedToCStack;

    // Append new algorithm info object into member set.

    iAlgorithmInfos->AppendL(algInfo);

    CleanupStack::Pop(pushedToCStack);

    return KCrOK;

    }

// -----------------------------------------------------------------------------

// CCrCrypto::InitDigestL

// Initialize message digest with MD2 algorithm.

// -----------------------------------------------------------------------------

TCrStatus CCrCrypto::InitDigestL(TCrAlgorithm aAlgorithm)    

    {

    // Number of items pushed to CleanupStack

    TUint pushedToCStack = 0;

    // Create new algorithm info object.

    CCrAlgInfo *algInfo = CCrAlgInfo::NewLC(aAlgorithm);

    pushedToCStack++;

    switch(aAlgorithm)

        {

        case ECrSHA1:

            {

            // Create digest object.

            algInfo->iAlgorithmObject  = CSHA1::NewL();

            break;

            }

        case ECrMD5:

            {

            // Create digest object.

            algInfo->iAlgorithmObject  = CMD5::NewL();

            break;

            }

        case ECrMD2:

            {

            // Create digest object.

            algInfo->iAlgorithmObject = CMD2::NewL();

            break;

            }

        case ECrSHA:

            {  

            // Create digest object.

            algInfo->iAlgorithmObject  = CSHA::NewL();

            break;

            }

        default:

            {

            return KCrCrypto | KCrNotSupportedAlg;

            }

        }

    CleanupStack::PushL(algInfo->iAlgorithmObject);

    pushedToCStack++;

    // Append new algorithm info object into member set.

    iAlgorithmInfos->AppendL(algInfo);

    CleanupStack::Pop(pushedToCStack);

    return KCrOK;

    }

// -----------------------------------------------------------------------------

// CCrCrypto::InitDigestHMACL

// Initialize message digest with HMAC algorithm.

// -----------------------------------------------------------------------------

TCrStatus CCrCrypto::InitDigestHMACL(

    const TDesC8& aKey, 

    TCrAlgorithm aDigestAlg)     

    {

    // Number of items pushed to CleanupStack

    TUint pushedToCStack = 0;

    TCrAlgorithm hmacDigest;

    switch (aDigestAlg)

        {

        case ECrSHA1:

            {

            hmacDigest = ECrHMAC_SHA1;

            break;

            }

        case ECrMD5:

            {

            hmacDigest = ECrHMAC_MD5;

            break;

            }

        default:

            {

            return KCrCrypto | KCrNotSupportedAlg;

            }

        }

    // Create new algorithm info object.

    CCrAlgInfo *algInfo = CCrAlgInfo::NewLC(hmacDigest);

    pushedToCStack++;

    CMessageDigest* digest = 0;

    switch(aDigestAlg)

        {

        case ECrSHA1:

            {

            // Create digest object.

            digest = CSHA1::NewL();

            break;

            }

        case ECrMD5:

            {

            // Create digest object.

            digest = CMD5::NewL();

            break;

            }

        case ECrMD2:

            {

            // Create digest object.

            digest = CMD2::NewL();

            break;

            }

        case ECrSHA:

            {   

            // Create digest object.

            digest = CSHA::NewL();

            break;  

            }   

        default:

            {

            return KCrCrypto | KCrNotSupportedAlg;

            }

        }

    CleanupStack::PushL(digest);

    ++pushedToCStack;

    // Create digest object.

    algInfo->iAlgorithmObject  = CHMAC::NewL(aKey, digest);

    CleanupStack::PushL(algInfo->iAlgorithmObject);

    ++pushedToCStack;

    // Append new algorithm info object into member set.

    iAlgorithmInfos->AppendL(algInfo);

    CleanupStack::Pop(pushedToCStack);

    return KCrOK;

    }

// -----------------------------------------------------------------------------

// CCrCrypto::ProcessL

// Process given source data with initialized crypto operations.

// If symmetric crypto is initialized sets to aTrg encrypted

// or decrypted data without last portion. If aProcessFinalBlock

// is ETrue, appends also last portion. If only digest algorithm

// is initialized, aTrg is not used.

// -----------------------------------------------------------------------------

TCrStatus CCrCrypto::ProcessL(const TDesC8& aSrc, TDes8& aTrg) 

    {

    TInt              i, size;

    TUint             pushedToCStack = 0;

    CCrAlgInfo* algInfo = 0;

    size = iAlgorithmInfos->Count();

    for (i = 0; i < size; i++)

        {

        algInfo = (*iAlgorithmInfos)[i];

        // Message digest algorithm

        if (algInfo->iType < ECrLAST_DIGEST)

            {

            // Casting to right type

            CMessageDigest* digest = STATIC_CAST(

                CMessageDigest*, algInfo->iAlgorithmObject);