/*

* Copyright (c) 2004 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:    .

*

*/

// INCLUDES

#include <e32std.h>

#include "srtpcryptohandler.h"

#include "srtpcryptocontext.h"

#include "srtputils.h"

#include "srtpstream.h"

#include "srtpaesctrcrypto.h"

#include "srtpkeyderivation_aescm128.h"

#include "srtpcipher_aescm128.h"

#include "srtpcipher_null.h"

#include "srtpauthentication_hmac_sha1.h"

#include "srtpauthentication_null.h"

#include "srtpauthentication_rcc.h"

#include "srtppacket.h"

#include "srtpmasterkey.h"

#include "srtpmastersalt.h"

// CONSTANTS

const TInt CSRTPCryptoHandler::iHandlerOffset = _FOFF( CSRTPCryptoHandler, iHandlerLink );

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

// CSRTPCryptoHandler::CSrtpCryptoHandler

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

//

CSRTPCryptoHandler::CSRTPCryptoHandler( CSRTPStream& aStream ) :

        iStream(aStream),

        iCurrentPacket(NULL),

        iKeyDeriver(NULL),

        iAuthenticator(NULL),

        iCipher(NULL),

        iMasterDataUpdated(EFalse),

        iSessionEncrKey(NULL),

        iSessionAuthKey(NULL),

        iSessionSaltKey(NULL),

        iReKey(EFalse),

        iBitmap(NULL),

        iNumPackets(NULL)

    {

    }

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

// CSRTPCryptoHandler::~CSrtpCryptoHandler

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

//

CSRTPCryptoHandler::~CSRTPCryptoHandler( )

    { 

    if (&Context())

    	{

    	Context().RemoveCryptoChangeObserver(this);	

    	}

    delete iCurrentPacket; iCurrentPacket=NULL;

    delete iKeyDeriver; iKeyDeriver=NULL;

    delete iCipher; iCipher=NULL;

    delete iAuthenticator; iAuthenticator=NULL;        

    DeleteSessionKeys();

    }

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

// void CSRTPCryptoHandler::SRTPMasterKeyChanged()

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

//

void CSRTPCryptoHandler::SRTPMasterKeyChanged()

    {

     iMasterDataUpdated = ETrue;

    //RFC 3711 8.1

     iReKey= EFalse;

    }

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

// void CSRTPCryptoHandler::SRTPMasterSaltChanged()

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

//

void CSRTPCryptoHandler::SRTPMasterSaltChanged()

    {

     iMasterDataUpdated = ETrue;   

    }

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

// CSRTPCryptoHandler::ConstructL

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

//

void CSRTPCryptoHandler::ConstructL( )

    {  

    if (!Context().Valid())

    	{

    	User::Leave(KErrArgument);

    	}

    Context().AddCryptoChangeObserver(this);	

    iKeyDeriver = CSRTPKeyDerivation_AESCM128::NewL();

    }

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

// CSRTPCryptoHandler::SetEncAndAlg ();

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

//

void CSRTPCryptoHandler::SetEncAndAuthL (TSRTPEncAlg aEngAlg, 

										TSRTPAuthAlg aAuthAlg)

	{

	delete iCipher; iCipher=NULL;

    delete iAuthenticator; iAuthenticator=NULL;  

	switch (aEngAlg)

	    {

	    case EEncAES_CM:

	        {

	        iCipher = CSRTPCipherAESCM128::NewL();        

	        break;                

	        }      

	    case ENullAlg:

	        {

	        iCipher = CSRTPCipherNULL::NewL();        

	        break;                

	        }      

	    default:          

	        {

	        User::Leave(KErrNotSupported);

	        }

	    }  

	switch (aAuthAlg)

	    {

	    case EAuthHMAC_SHA1:

	        {

	        iAuthenticator = CSRTPAuthentication_HMAC_SHA1::NewL();        

	        break;                

	        }     

	    case EAuthNull:  

	    case EAuthRCCm3:

	    	{

	        iAuthenticator = CSRTPAuthentication_NULL::NewL();        

	        break;                

	        } 

	    case EAuthRCCm1: 

	    case EAuthRCCm2: 	                 

	       	{

	        iAuthenticator = CSrtpAuthentication_RCC::NewL();        

	        break;                

	        } 

	    default:          

	        {

	        User::Leave(KErrNotSupported);

	        }

	    }  

	}

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

// CSRTPCryptoHandler::Context()

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

//

CSRTPCryptoContext& CSRTPCryptoHandler::Context()

    {

    return iStream.GetCryptoContext();

    }

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

// CSRTPCryptoHandler::CryptoParams()

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

//

const TSrtpCryptoParams& CSRTPCryptoHandler::CryptoParams()

    {

    return Context().CryptoParams();

    }

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

// CSRTPCryptoHandler::DeleteSessionKeys()

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

//

void CSRTPCryptoHandler::DeleteSessionKeys()

    {

     delete iSessionEncrKey;

     delete iSessionAuthKey;

     delete iSessionSaltKey;  

     iSessionEncrKey = NULL;

     iSessionAuthKey = NULL;

     iSessionSaltKey = NULL;

    }

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

// CSRTPCryptoHandler::Count_X()

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

//

void CSRTPCryptoHandler::Count_X(TUint64 a_R,

                                TInt8 aLabel, 

                                const TUint64 aIndexLength, 

                                TDes8 &aRes)

    {

    TUint64 key_id = TSRTPUtils::Cnt_key_id(aLabel, a_R, aIndexLength);

    TSRTPUtils::Cnt_x(key_id, aRes, Context().MasterSalt().MasterSalt());

    } 

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

// CSRTPCryptoHandler::SetROC()

// 

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

//

void CSRTPCryptoHandler::SetROC(  TUint32 aROC )

    {

    iStream.SetROC(aROC);

    }

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

// CSRTPCryptoHandler::ROC

// 

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

//

TUint32 CSRTPCryptoHandler::ROC() const

    {

    return iStream.ROC();

    }

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

// CSRTPCryptoHandler::SSRC

// 

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

//

TUint CSRTPCryptoHandler::SSRC() const

    {

    return iStream.SSRC();

    }

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

// TInt CSRTPCryptoHandler::ReplayCheck()

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

//

TInt CSRTPCryptoHandler::ReplayCheck(TInt aDelta) 

	{

	TInt replayWSH= KReplayWindowSize;

	if (CryptoParams().iReplayWindowSizeHint!=replayWSH)

		{

		replayWSH= CryptoParams().iReplayWindowSizeHint;

		}

	//Remember to initial bitmask at the first time

  	//if aDelta ==0 it might be just re-sent	

	if (aDelta > 0) 

		{                

		/* new larger sequence number */

        if (aDelta < replayWSH) 

        	{  /* In window */

            iBitmap <<= aDelta;

            iBitmap |= 1;  /* set bit for this packet */

        	} else iBitmap = 1; /* This packet has a "way larger" */

        return KErrNone;   /* larger is good */

    	}

    TInt diff= -(aDelta);

    if (diff >= replayWSH) return KErrArgument; /* too old or wrapped */

    if (iBitmap & ((TUint64)1 << diff)) return KErrArgument; /* already seen */

    //if none of above then will mark as seen in the AddReplayIndex() function             

    return KErrNone;  /* out of order but good */

	}