/*

* 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:  

*

*/

//  CLASS HEADER

#include "UT_CSRTPCryptoHandlerSRTCP.h"

// CONSTANTS

const TInt KRtpVersion = 2;    // Current protocol version          

const TUint KMinRtpHeaderLen( 12 );

const TUint16 KTestSeqNr17 = 17171;

const TUint16 KTestSeqNr55 = 55;

const TUint16 KTestSeqNr17200 = 17200;

const TUint16 KTestSeqNr55536=55535;

const TUint16 KTestSeqNr65536=65535;

// 80 bit key, test 1

_LIT8(KTestPayload160Bits,  "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");

// 80 bit key, test 1

//_LIT8(KTestMKI128Bits,      "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");

_LIT8(KTestMKI128Bits,      "ABCDEF1234567890ABCDEF1234567890");

// 80 bit key, test 1

_LIT8(KTestAuthTag80Bits,   "CCCCCCCCCCCCCCCCCCCC");

_LIT8(KRFC3711_TestMasterKey128bits,    "E1F97A0D3E018BE0D64FA32C06DE4139");

_LIT8(KRFC3711_TestMasterSalt112bits,   "0EC675AD498AFEEBB6960B3AABE6");	

_LIT8(KRFC3711_SessionEncrKey128bits,   "4C1AA45A81F73D61C800BBB00FBB1EAA");  

_LIT8(KRFC3711_SessionSaltKey128bits,   "9581C7AD87B3E530BF3E4454A8B3");  

_LIT8(KRFC3711_SessionAuthKey128bits,   "8D54534FEB49AE8E7993A6BD0B844FC323A93DFD");  

_LIT8(KDecryptedPayload,                "2EDE3286C6E33E68C6BB93350620A1245EC0004F");  

_LIT8(KTestM_without_ROC,               "123456789ABCDE");  

_LIT8(KRefM_with_ROC,                   "123456789ABCDEFFFFFFFF");  

_LIT8(KTestAuthTag,                     "D07919ABC9F235CB4516");  

_LIT8(KSRTCPPacket, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890DFC98F01DE16DA30F20D");

_LIT8(KRTCPPacket, "80C80006DEADBEEFC7B1ACD423FE000000E12F18000000010000020081CA0015DEADBEEF010A52747055492075736572020455736572030D7573657240686F6D652E6E6574040B2B313233343536373839300504486F6D65060B527470206578616D706C65070641637469766508010000000000");

_LIT8(KSRTCPPacket1, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890DFC98F01DE16DA30F20D");

_LIT8(KSRTCPPacket2, "80C90001DEADBEEF2BC095F51495D87D35B816BE569A6A1BA6989D5A20B541D680000002ABCDEF1234567890ABCDEF12345678905140BA93E8CDAC0C89D5");

_LIT8(KSRTCPPacketWrongMKI, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890DFC98F01DE16DA30F20D");

_LIT8(KSRTCPPacketNoAuthTag, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890");

_LIT8(KSRTCPPacketWrongAuthTag, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890DFC98F01DE16DA30F20A");

_LIT8(KRTCPPacketIndexUpperLimit, 

"80C80006DEADBEEFC7B1ACD423FE000000E12F18000000010000020081CA0015DEADBEEF010A52747055492075736572020455736572030D7573657240686F6D652E6E6574040B2B313233343536373839300504486F6D65060B527470206578616D706C650706416374697665087FFFFFFE");

#define RTP_EUNIT_ASSERT_SPECIFIC_LEAVE( func, val ) \

{\

TRAPD( rtpUnitTestRetVal, func );\

if ( val != KErrNoMemory && rtpUnitTestRetVal == KErrNoMemory ){\

	User::Leave( KErrNoMemory );\

	}\

else{\

	EUNIT_ASSERT_EQUALS( rtpUnitTestRetVal, val );\

	}\

}

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "srtpcryptohandlersrtcp.h"

#include "srtpmastersalt.h"

#include "srtpmasterkey.h"

#include "srtpstreamin.h"

#include "srtpstreamout.h"

#include "srtpsession.h"

#include "srtputils.h"

// CONSTRUCTION

UT_CSRTPCryptoHandlerSRTCP* UT_CSRTPCryptoHandlerSRTCP::NewL()

    {

    UT_CSRTPCryptoHandlerSRTCP* self = UT_CSRTPCryptoHandlerSRTCP::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CSRTPCryptoHandlerSRTCP* UT_CSRTPCryptoHandlerSRTCP::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CSRTPCryptoHandlerSRTCP::~UT_CSRTPCryptoHandlerSRTCP()

    {

    }

// Default constructor

UT_CSRTPCryptoHandlerSRTCP::UT_CSRTPCryptoHandlerSRTCP()

    {

    }

// Second phase construct

void UT_CSRTPCryptoHandlerSRTCP::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CSRTPCryptoHandlerSRTCP::SRTPMasterKeyStaleEvent(const CSRTPStream& /*aStream*/ )

    {

    iReKeyCalled= ETrue;

    }

void UT_CSRTPCryptoHandlerSRTCP::SRTPMasterKeyStaleEvent(const CSRTPSession& /*aSession*/ )

    {

    iReKeyCalled= ETrue;

    }

void UT_CSRTPCryptoHandlerSRTCP::Hex(HBufC8& aString)

 	{

 	TPtr8 ptr=aString.Des();

    TInt length = aString.Length();

    if (aString.Length()%2)

        {

        ptr.SetLength(0);

        return;

        }

    TInt i;

    for (i=0;i<aString.Length();i+=2)

        {

        TUint8 tmp;

        tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));

        tmp*=16;

        tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));

        ptr[i/2]=tmp;

        }

    ptr.SetLength(aString.Length()/2);

 	}

void UT_CSRTPCryptoHandlerSRTCP::SetupL(  )

    {

  	iDecryptedPayload = HBufC8::NewL(KDecryptedPayload().Length());

	*iDecryptedPayload = KDecryptedPayload;

	Hex(*iDecryptedPayload);

    iRFC3711_SessionEncrKey128bits = HBufC8::NewL(KRFC3711_SessionEncrKey128bits().Length());

	*iRFC3711_SessionEncrKey128bits = KRFC3711_SessionEncrKey128bits;

	Hex(*iRFC3711_SessionEncrKey128bits);

    iRFC3711_SessionSaltKey128bits = HBufC8::NewL(KRFC3711_SessionSaltKey128bits().Length());

	*iRFC3711_SessionSaltKey128bits = KRFC3711_SessionSaltKey128bits;

	Hex(*iRFC3711_SessionSaltKey128bits);

    iRFC3711_SessionAuthKey128bits = HBufC8::NewL(KRFC3711_SessionAuthKey128bits().Length());

	*iRFC3711_SessionAuthKey128bits = KRFC3711_SessionAuthKey128bits;

	Hex(*iRFC3711_SessionAuthKey128bits);

	iTestPayload160Bits = HBufC8::NewL(KTestPayload160Bits().Length());

	*iTestPayload160Bits = KTestPayload160Bits;	

	Hex(*iTestPayload160Bits);	

	iTestMKI128Bits = HBufC8::NewL(KTestMKI128Bits().Length());

	*iTestMKI128Bits = KTestMKI128Bits;	

	Hex(*iTestMKI128Bits);	

	iTestAuthTag80Bits = HBufC8::NewL(KTestAuthTag80Bits().Length());

	*iTestAuthTag80Bits = KTestAuthTag80Bits;	

	Hex(*iTestAuthTag80Bits);	

   HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());

    CleanupStack::PushL( masterKey );

    *masterKey = KRFC3711_TestMasterKey128bits;

    HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());

    CleanupStack::PushL( masterSalt);

	*masterSalt = KRFC3711_TestMasterSalt112bits;

	HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());

    CleanupStack::PushL( mki);

	*mki = KTestMKI128Bits;

	Hex(*mki);

	iMasterKey = CSRTPMasterKey::NewL( *masterKey, *mki );

    iMasterSalt = CSRTPMasterSalt::NewL( *masterSalt );

    TSrtpCryptoParams params;

    iContext = CSRTPCryptoContext::NewL(iMasterKey, iMasterSalt, params );

    CleanupStack::PopAndDestroy( mki );

    CleanupStack::PopAndDestroy( masterSalt );

    CleanupStack::PopAndDestroy( masterKey ); 

    iDestination.Input(_L("127.0.0.1"));

    iSRTPSession = CSRTPSession::NewL( iDestination, iContext, *this ); 

    iStreamIn = CSRTPStreamIn::NewL(*iSRTPSession, 0xDEADBEEF);

    iCryptoHandlerSRTCP=  iStreamIn->iHandlerRTCP;   

    iReKeyCalled = EFalse; 

    } 

void UT_CSRTPCryptoHandlerSRTCP::Teardown(  )

    {

  	delete iDecryptedPayload;

    delete iTestPayload160Bits;

    delete iTestMKI128Bits;

    delete iTestAuthTag80Bits;

    delete iStreamIn;

    delete iRFC3711_SessionEncrKey128bits;

    delete iRFC3711_SessionSaltKey128bits;

    }

void UT_CSRTPCryptoHandlerSRTCP::UT_CSRTPCryptoHandlerSRTCP_NewLL(  )

    {

    EUNIT_ASSERT( ETrue );

    }

void UT_CSRTPCryptoHandlerSRTCP::UT_CSRTPCryptoHandlerSRTCP_NewLCL(  )

    {

    EUNIT_ASSERT( ETrue );

    }

	{

	HBufC8* encSrtcpPacket =HBufC8::NewLC(KSRTCPPacket().Length());

	*encSrtcpPacket=KSRTCPPacket;

    Hex(*encSrtcpPacket);

    TInt len= KSRTCPPacket().Length();

	encSrtcpPacket->Des().SetLength(len/2);

    iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket);

    iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    iCryptoHandlerSRTCP->DeriveSessionKeysL();

    EUNIT_ASSERT( iCryptoHandlerSRTCP->iSessionEncrKey->Compare(

                                    *iRFC3711_SessionEncrKey128bits) == 0);

    EUNIT_ASSERT( iCryptoHandlerSRTCP->iSessionSaltKey->Compare(

                                    *iRFC3711_SessionSaltKey128bits) == 0);

    EUNIT_ASSERT( iCryptoHandlerSRTCP->iSessionAuthKey->Compare(

                                    *iRFC3711_SessionAuthKey128bits) == 0);

    CleanupStack::PopAndDestroy(encSrtcpPacket);  	

	}

 void UT_CSRTPCryptoHandlerSRTCP::UT_PerformAuthenticationLL()

 	{

 	HBufC8* encSrtcpPacket =HBufC8::NewLC(KSRTCPPacket().Length());

	*encSrtcpPacket=KSRTCPPacket;

    Hex(*encSrtcpPacket);

    TInt len= KSRTCPPacket().Length();

	encSrtcpPacket->Des().SetLength(len/2);

 	iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket);

 	iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    iCryptoHandlerSRTCP->CheckMasterKeyIdentifierL();

    iCryptoHandlerSRTCP->DeriveSessionKeysL();

	// do the authentication (integrity check)

    iCryptoHandlerSRTCP->AuthenticateL();

 	CleanupStack::PopAndDestroy(encSrtcpPacket);     

 	}

void UT_CSRTPCryptoHandlerSRTCP::UT_AuthenticateLL( ) 

 	{

 	//false cases when auth tage =0 but using HMAC auth

 	HBufC8* encSrtcpPacket =HBufC8::NewLC(KSRTCPPacketNoAuthTag().Length());

	*encSrtcpPacket=KSRTCPPacketNoAuthTag;

    Hex(*encSrtcpPacket);

    TInt len= KSRTCPPacketNoAuthTag().Length();

	encSrtcpPacket->Des().SetLength(len/2);

	//update crypto handler in the session

	//Set AuthLen=0

	TSrtpCryptoParams crypto;

	crypto.iSrtcpAuthTagLen=0;

	iCryptoHandlerSRTCP->Context().UpdateCryptoParams(crypto);

 	iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket);

 	iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    iCryptoHandlerSRTCP->CheckMasterKeyIdentifierL();

    iCryptoHandlerSRTCP->DeriveSessionKeysL();

	// do the authentication (integrity check)

    EUNIT_ASSERT_SPECIFIC_LEAVE(iCryptoHandlerSRTCP->AuthenticateL(), 

    													KErrNotFound);

 	CleanupStack::PopAndDestroy(encSrtcpPacket);     

 	}

void UT_CSRTPCryptoHandlerSRTCP::UT_AuthenticateL2L( ) 

 	{

 	//false cases when auth tage is not equal 

 	HBufC8* encSrtcpPacket =HBufC8::NewLC(KSRTCPPacketWrongAuthTag().Length());

	*encSrtcpPacket=KSRTCPPacketWrongAuthTag;

    Hex(*encSrtcpPacket);

    TInt len= KSRTCPPacketWrongAuthTag().Length();

	encSrtcpPacket->Des().SetLength(len/2);

 	iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket);

 	iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    iCryptoHandlerSRTCP->CheckMasterKeyIdentifierL();

    iCryptoHandlerSRTCP->DeriveSessionKeysL();

	// do the authentication (integrity check)

    RTP_EUNIT_ASSERT_SPECIFIC_LEAVE(iCryptoHandlerSRTCP->AuthenticateL(), 

    													KErrNotFound);

 	CleanupStack::PopAndDestroy(encSrtcpPacket);     

 	}

  void UT_CSRTPCryptoHandlerSRTCP::UT_AddAuthTagLL(  )

 	{

 	//Set auth tag len=0 and MKI = NULL

   	HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());

    CleanupStack::PushL( masterKey );

    *masterKey = KRFC3711_TestMasterKey128bits;

    HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());

    CleanupStack::PushL( masterSalt);

	*masterSalt = KRFC3711_TestMasterSalt112bits;

	CSRTPMasterKey* master = CSRTPMasterKey::NewLC( *masterKey, KNullDesC8 );

    CSRTPMasterSalt* salt = CSRTPMasterSalt::NewLC( *masterSalt );

    TSrtpCryptoParams params;

    params.iSrtcpAuthAlg=EAuthNull;

    params.iSrtcpAuthTagLen=0;

    CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(master, salt, params);

    CleanupStack::Pop( salt );

    CleanupStack::Pop( master ); 

    CleanupStack::PopAndDestroy( masterSalt );

    CleanupStack::PopAndDestroy( masterKey ); 

    iDestination.Input(_L("127.0.0.1"));

    CleanupStack::PushL( context );

    CSRTPSession* srtpSession = CSRTPSession::NewL( iDestination); 

    CleanupStack::PushL( srtpSession );

    CSRTPStreamIn* streamIn = CSRTPStreamIn::NewL(*srtpSession, 0xDEADBEEF, context, *this);

    CleanupStack::Pop( srtpSession );

    CleanupStack::Pop( context );

    CleanupStack::PushL( srtpSession );

    CleanupStack::PushL( streamIn );

    CSRTPCryptoHandlerSRTCP* cryptoSrtcp=  streamIn->iHandlerRTCP;

    HBufC8* rtcpPacket =HBufC8::NewLC(KRTCPPacket().Length());

	*rtcpPacket=KRTCPPacket;

    Hex(*rtcpPacket);

    TInt len= KRTCPPacket().Length();

	rtcpPacket->Des().SetLength(len/2);

    cryptoSrtcp->InitializePlainPacketL(*rtcpPacket);

    //for testing only , not for real cases packet created sequences

    TUint8* srtpPacketPtr = const_cast<TUint8*>(rtcpPacket->Des().Ptr());

    cryptoSrtcp->AddAuthTagToPacketL(srtpPacketPtr);

    EUNIT_ASSERT(rtcpPacket->Size()==(len/2));

    CleanupStack::PopAndDestroy(rtcpPacket);  

    CleanupStack::PopAndDestroy( streamIn );

    CleanupStack::PopAndDestroy( srtpSession );

 	}

 void UT_CSRTPCryptoHandlerSRTCP::UT_CountSenderPacketIndexL1L(  )

 	{

 	// just a dummy packet index

    //iCryptoHandlerSRTCP->iReplayPktIndex = 5;

    HBufC8* rtcpPacket =HBufC8::NewLC(KRTCPPacket().Length());

	*rtcpPacket=KRTCPPacket;

    Hex(*rtcpPacket);

    TInt len= KRTCPPacket().Length();

	rtcpPacket->Des().SetLength(len/2);

    iCryptoHandlerSRTCP->InitializePlainPacketL(*rtcpPacket);

    iCryptoHandlerSRTCP->CountSenderPacketIndexL();

    //normal situation

    EUNIT_ASSERT(iCryptoHandlerSRTCP->iSRTCPIndex==0x80000001);

    EUNIT_ASSERT( !iReKeyCalled );

    EUNIT_ASSERT ( !iCryptoHandlerSRTCP->iReKey );

    //test Rekey

    iReKeyCalled = EFalse;

    iCryptoHandlerSRTCP->iNumPackets = 100;

    iCryptoHandlerSRTCP->iSRTCPMasterKeyLifeTime = 200;

    iCryptoHandlerSRTCP->IndexReKeyCheckL();

    EUNIT_ASSERT( iReKeyCalled );

    iCryptoHandlerSRTCP->iNumPackets = 200;

    iCryptoHandlerSRTCP->IndexReKeyCheckL();

    EUNIT_ASSERT ( iCryptoHandlerSRTCP->iReKey );

	CleanupStack::PopAndDestroy(rtcpPacket);

 	}

 void UT_CSRTPCryptoHandlerSRTCP::UT_CountSenderPacketIndexL2L(  )

 	{

 	//Index Rekey Check when does not need Re-Key

 	// just a dummy packet index

    //iCryptoHandlerSRTCP->iReplayPktIndex = 5;

    iCryptoHandlerSRTCP->iSRTCPIndexEStripped= 0x7FFFFFFE;

    HBufC8* rtcpPacket =HBufC8::NewLC(KRTCPPacketIndexUpperLimit().Length());

	*rtcpPacket=KRTCPPacketIndexUpperLimit;

    Hex(*rtcpPacket);

    TInt len= KRTCPPacketIndexUpperLimit().Length();

	rtcpPacket->Des().SetLength(len/2);

    iCryptoHandlerSRTCP->InitializePlainPacketL(*rtcpPacket);

    iCryptoHandlerSRTCP->CountSenderPacketIndexL();

    //normal situation

    //7FFFFFFE -is the index we sent

    EUNIT_ASSERT(iCryptoHandlerSRTCP->iSRTCPIndex==0xFFFFFFFF);

    EUNIT_ASSERT(iReKeyCalled== ETrue);

	CleanupStack::PopAndDestroy(rtcpPacket);

 	} 	

 void UT_CSRTPCryptoHandlerSRTCP::UT_ReplayProtectionL1L( )   

 	{

 	HBufC8* encSrtcpPacket1 =HBufC8::NewLC(KSRTCPPacket1().Length());

	*encSrtcpPacket1=KSRTCPPacket1;

    Hex(*encSrtcpPacket1);

    TInt len= KSRTCPPacket1().Length();

	encSrtcpPacket1->Des().SetLength(len/2);

    // do the authentication (integrity check)

    iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket1);

 	iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    // derive session keys..

    iCryptoHandlerSRTCP->DeriveSessionKeysL();

    // do the replay protection 

    iCryptoHandlerSRTCP->ReplayProtectionL();

    iCryptoHandlerSRTCP->AuthenticateL();

    iCryptoHandlerSRTCP->AddReplayIndex();

    //EUNIT_ASSERT(iCryptoHandlerSRTP->iPktIndex == KTestSeqNr17); 

   	CleanupStack::PopAndDestroy(encSrtcpPacket1);  

    //Create the packet again so can check the Replay protection

	HBufC8* encSrtcpPacket2 =HBufC8::NewLC(KSRTCPPacket2().Length());

	*encSrtcpPacket2=KSRTCPPacket2;

    Hex(*encSrtcpPacket2);

    TInt len2= KSRTCPPacket2().Length();

	encSrtcpPacket2->Des().SetLength(len2/2);

    iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket2);

    iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    iCryptoHandlerSRTCP->ReplayProtectionL();

    iCryptoHandlerSRTCP->AddReplayIndex(); 

    TUint64  temp= iCryptoHandlerSRTCP->iReplayPktIndex; 

    //EUNIT_ASSERT(iCryptoHandlerSRTCP->iReplayPktIndex == 2);

   	CleanupStack::PopAndDestroy(encSrtcpPacket2);  	

 	}

 void UT_CSRTPCryptoHandlerSRTCP::UT_ReplayProtectionL2L( )

 	{

 	//Set stored PktIndx number to bigger than the on in the sequence number

    //but inside the Replay window and has not been seen

    iCryptoHandlerSRTCP->iReplayPktIndex= KTestSeqNr55;

    HBufC8* encSrtcpPacket1 =HBufC8::NewLC(KSRTCPPacket1().Length());

	*encSrtcpPacket1=KSRTCPPacket1;

    Hex(*encSrtcpPacket1);

    TInt len= KSRTCPPacket1().Length();

	encSrtcpPacket1->Des().SetLength(len/2);

    iCryptoHandlerSRTCP->InitializeEncryptedPacketL(*encSrtcpPacket1);

 	iCryptoHandlerSRTCP->ReceiverPacketIndexL();

    // derive session keys..

    iCryptoHandlerSRTCP->DeriveSessionKeysL();

    // do the replay protection 

    iCryptoHandlerSRTCP->ReplayProtectionL();

    iCryptoHandlerSRTCP->AddReplayIndex();

    EUNIT_ASSERT(iCryptoHandlerSRTCP->iReplayPktIndex == KTestSeqNr55); 

    //check also bitmap later

   	CleanupStack::PopAndDestroy(encSrtcpPacket1);