/*

* Copyright (c) 2005 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:    Class for AES (in Counter Mode) encryption operations

*

*/

#include "srtpaesctrcrypto.h"

#include <e32uid.h>

#include <symmetric.h>

#include "srtpdef.h"

#include "srtputils.h"

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

// CSrtpAESCTRCrypto::NewL()

// 

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

//

EXPORT_C CSrtpAESCTRCrypto* CSrtpAESCTRCrypto::NewL()

	{

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

	return self;

	}

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

// CSrtpAESCTRCrypto::~CSrtpAESCTRCrypto()

// 

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

//

CSrtpAESCTRCrypto::~CSrtpAESCTRCrypto()

	{

	delete iEncryptor;

	delete iKey;

	}

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

// CSrtpAESCTRCrypto::CSrtpAESCTRCrypto

// 

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

//

CSrtpAESCTRCrypto::CSrtpAESCTRCrypto( ) 

	{

	}

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

// CSrtpAESCTRCrypto::KeystreamL

// 

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

//

EXPORT_C HBufC8* CSrtpAESCTRCrypto::KeystreamL(TUint aBitLength, 

                                                const TDesC8& aKey, 

                                                const TDesC8& aIV )

	{

    TBuf8<16> iv;           //temp for IV    

    TBuf8<16> data;         //for a 128-bit piece of a keystream    

    CAESEncryptor*  encryptor = NULL;

    TUint buffLength;       //length of the result (as 8 bit descriptor)

    TUint count;          // how many 128-bit AES calls needed 

    buffLength = aBitLength/8;  

    if (aBitLength%8)

        {

        buffLength++;            

        }

    count = aBitLength/128;    

    if (aBitLength%128)

        {

        count++;            

        }

	HBufC8* outputBuff = HBufC8::NewLC(16*count);

	TPtr8 ptrOutputBuff = outputBuff->Des();	

    SRTP_DEBUG_TUINT_VALUE( "KeyStreamL, Check the length of aKey==16 and the length is", (aKey.Length()) );

    if(aKey.Length() != 16)

    	{

	    CleanupStack::Pop(outputBuff);

        delete outputBuff;    

        outputBuff=NULL;    

    	User::Leave(KErrArgument);

    	}

    SRTP_DEBUG_TUINT_VALUE( "KeyStreamL, Check the length of aIV==16 and the length is", (TUint)aIV.Length() );

    //if IV's length is not valid

    if(aIV.Length() != 16)

    	{

	    CleanupStack::Pop(outputBuff);

        delete outputBuff;    

        outputBuff= NULL; 

    	User::Leave(KErrArgument);

    	}    

    iv.Copy(aIV);

    SRTP_DEBUG_TUINT_VALUE( "KeyStreamL, Check aBitLength/128>KSRTPMaxKeyStreamBlocks and the length is", 

                (TUint)aBitLength/128  );

    if(aBitLength/128 > KSRTPMaxKeyStreamBlocks)

    	{

	    CleanupStack::Pop(outputBuff);

        delete outputBuff;    

        outputBuff=NULL;   

    	User::Leave(KErrArgument);

    	}

    encryptor = CAESEncryptor::NewLC(aKey);

    for(int x = 0; x < count; x++)

    	{    	    	   	

    	data.Copy(iv);

    	encryptor->Transform(data);

    	IncreaseIV(iv);

		ptrOutputBuff.Append(data);		    	

    	}

    //set the size if it was changed

    TInt size= ptrOutputBuff.Size();

    ptrOutputBuff.SetLength(buffLength);

	CleanupStack::PopAndDestroy(encryptor);

    CleanupStack::Pop(outputBuff); 

    SRTP_DEBUG_TUINT_VALUE( "CSrtpAESCTRCrypto::KeystreamL ptrOutputBuff.Size()", 

    			(TUint)size );

    return outputBuff;	

	}

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

// CSrtpAESCTRCrypto::EncryptL

// 

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

//

EXPORT_C HBufC8* CSrtpAESCTRCrypto::EncryptL(const TDesC8& aKey, 

                                            const TDesC8& aIV, 

                                            const TDesC8& aSrc)

	{

		HBufC8* outputBuff = HBufC8::NewLC(aSrc.Length());

		TPtr8 ptrOutputBuff = outputBuff->Des();

	    TBuf8<16> iv; //temp for IV

	    TBuf8<16> data; //for a 128-bit piece of a keystream

	    TBuf8<16> msg; //for a 128-bit piece of a message

	    TInt count=0; // how many full 128-bit pieces can be made of a source

	    SRTP_DEBUG_TINT_VALUE( "EncryptL, Check aBitLengh ==16 and the length is", 

	                aKey.Length()  );

	    //if key's length is not valid

	    if(aKey.Length() != 16)

	    	{

		    CleanupStack::Pop(outputBuff);

	        delete outputBuff;    

	        outputBuff= NULL;

	    	User::Leave(KErrArgument);

	    	}

	    SRTP_DEBUG_TINT_VALUE( "EncryptL, Check the length of aIV==16 and the length is", 

	                aIV.Length() );

	    //if IV's length is not valid

	    if(aIV.Length() != 16)

	    	{

		    CleanupStack::Pop(outputBuff);

	        delete outputBuff;    

	        outputBuff= NULL;  

	    	User::Leave(KErrArgument);

	    	}    

		SRTP_DEBUG_TINT_VALUE("EncryptL, Check aSrc.Length()>KSRTPMaxTextLength and the length is", 

	                aSrc.Length()  );

	    //check that text length is less than 2^23

	    if(aSrc.Length() > KSRTPMaxTextLength)

	    	{

		    CleanupStack::Pop(outputBuff);

	        delete outputBuff;    

	        outputBuff= NULL;    

	    	User::Leave(KErrArgument);

	    	}

	    iv.Copy(aIV);

	    count = aSrc.Length()/16;

		SRTP_DEBUG_TINT_VALUE("EncryptL, count>KSRTPMaxKeyStreamBlocks and the length is", 

	                count  );

	    if(count > KSRTPMaxKeyStreamBlocks)

	    	{

		    CleanupStack::Pop(outputBuff);

	        delete outputBuff;    

	        outputBuff= NULL;  

	    	User::Leave(KErrArgument);

	    	}

	    if ( !iEncryptor || !iKey || (*iKey != aKey) )

	        {

	        CreateEncryptorL(aKey);

            }

	    for(int x = 0; x < count; x++)

	    	{

	    	msg.Copy(aSrc.Mid(x*16, 16));

	    	data.Copy(iv);

	    	iEncryptor->Transform(data);

	    	IncreaseIV(iv);

		    // XOR 128-bits of message with encrypted IV

		    for(int i = 0; i < 16; i++)

				{

				msg[i] ^= data[i];

				}

			ptrOutputBuff.Append(msg);

	    	}

	    //if source's length isn't an exact multiple of 128-bits

	    if(aSrc.Length()%16)

	    	{

	    	TInt bytesleft;

	    	bytesleft = aSrc.Length() - count*16;

	    	msg.Copy(aSrc.Mid(count*16, bytesleft));

	    	data.Copy(iv);

	    	iEncryptor->Transform(data);

		    // XOR last piece of message with encrypted IV

		    for(int i = 0; i < bytesleft; i++)

			{

					msg[i] ^= data[i];

			}

			ptrOutputBuff.Append(msg);

	    	}

	    CleanupStack::Pop(outputBuff);    	    

	    return outputBuff;

	}

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

// CSrtpAESCTRCrypto::IncreaseIV

// 

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

//

void CSrtpAESCTRCrypto::IncreaseIV(TDes8& iv)

	{

	if(iv[15] != 0xFF)

		{

		iv[15] += 1;	

		}

	else if(iv[14] != 0xFF)

		{

		iv[15] = 0;

		iv[14] += 1;

		}

	else if(iv[13] != 0xFF)

		{

		iv[15] = 0;

		iv[14] = 0;

		iv[13] += 1;

		}	

	else if (iv[12] != 0xFF)

		{

		iv[15] = 0;

		iv[14] = 0;

		iv[13] = 0;

		iv[12] += 1;

		}		

	else

		{

		iv[15] = 0;

		iv[14] = 0;

		iv[13] = 0;

		iv[12] = 0;

		}

	} 

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

// CSrtpAESCTRCrypto::CreateEncryptorL

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

//

void CSrtpAESCTRCrypto::CreateEncryptorL(const TDesC8& aKey)

    {

    delete iEncryptor;

    iEncryptor = 0;

    delete iKey;

    iKey = 0;

    iKey = aKey.AllocL();

    iEncryptor = CAESEncryptor::NewL(*iKey);

    }