--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rtp/srtpstack/tsrc/ut_srtpstack/src/UT_CSRTPStream.cpp Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,460 @@
+/*
+* 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_CSRTPStream.h"
+
+// EXTERNAL INCLUDES
+#include <digia/eunit/eunitmacros.h>
+
+
+// INTERNAL INCLUDES
+#include "srtpstream.h"
+#include "srtpcryptohandlersrtp.h"
+#include "srtpcryptohandlersrtcp.h"
+#include "srtpmastersalt.h"
+#include "srtpmasterkey.h"
+#include "srtpstreamin.h"
+#include "srtpstreamout.h"
+#include "srtpsession.h"
+#include "srtputils.h"
+#include "srtpcryptoparams.h"
+
+// CONSTANTS
+const TInt KRtpVersion = 2; // Current protocol version
+const TUint KMinRtpHeaderLen( 12 );
+const TUint16 KTestSeqNr17 = 17171;
+const TInt KLength = 50;
+
+// 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, "C61E7A93744F39EE10734AFE3FF7A087");
+_LIT8(KRFC3711_SessionSaltKey128bits, "30CBBC08863D8C85D49DB34A9AE1");
+_LIT8(KRFC3711_SessionAuthKey128bits, "CEBE321F6FF7716B6FD4AB49AF256A156D38BAA4");
+_LIT8(KDecryptedPayload, "2EDE3286C6E33E68C6BB93350620A1245EC0004F");
+
+_LIT8(KTestM_without_ROC, "123456789ABCDE");
+_LIT8(KRefM_with_ROC, "123456789ABCDEFFFFFFFF");
+
+_LIT8(KTestAuthTag, "D07919ABC9F235CB4516");
+_LIT8(KDummyRTCPPacket, "dummyrtcp");
+
+
+// CONSTRUCTION
+UT_CSRTPStream* UT_CSRTPStream::NewL()
+ {
+ UT_CSRTPStream* self = UT_CSRTPStream::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+UT_CSRTPStream* UT_CSRTPStream::NewLC()
+ {
+ UT_CSRTPStream* self = new( ELeave ) UT_CSRTPStream();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+UT_CSRTPStream::~UT_CSRTPStream()
+ {
+ }
+
+// Default constructor
+UT_CSRTPStream::UT_CSRTPStream()
+ {
+ }
+
+UT_CSRTPStream::TPayloadDetails::TPayloadDetails() :
+ seqNr(),
+// ssrc(),
+ padding(0),
+ numCSRC(0),
+ fHeaderExtension(EFalse),
+ payloadLen(0),
+ payloadData(NULL),
+ MKILen(0),
+ MKIData(NULL),
+ authTagLen(0),
+ authTagData(NULL)
+ {
+ }
+
+
+// Second phase construct
+void UT_CSRTPStream::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+ }
+
+// METHODS
+
+void UT_CSRTPStream::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_CSRTPStream::SRTPMasterKeyStaleEvent(const CSRTPStream& /*aStream*/)
+ {
+ iReKeyCalled= ETrue;
+ }
+void UT_CSRTPStream::SRTPMasterKeyStaleEvent(const CSRTPSession& /*aSession*/ )
+ {
+ iReKeyCalled= ETrue;
+ }
+
+
+void UT_CSRTPStream::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);
+
+
+
+ // our test MKI is 16 bit long:
+ // ABCDEF1234567890ABCDEF1234567890
+
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ iMasterKey = CSRTPMasterKey::NewL( *masterKey, *mki );
+ iMasterSalt = CSRTPMasterSalt::NewL( *masterSalt );
+
+ TSrtpCryptoParams params;
+
+
+ iContext = CSRTPCryptoContext::NewL(iMasterKey, iMasterSalt, params );
+
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterKey );
+ iDestination.Input(_L("127.0.0.1"));
+ iSRTPSession = CSRTPSession::NewL( iDestination, iContext, *this );
+ iStreamIn = CSRTPStreamIn::NewL(*iSRTPSession, (TUint)1);
+
+ iCryptoHandlerSRTP = iStreamIn->iHandlerRTP;
+ }
+
+void UT_CSRTPStream::Teardown( )
+ {
+ delete iDecryptedPayload;
+ delete iTestPayload160Bits;
+ delete iTestMKI128Bits;
+ delete iTestAuthTag80Bits;
+
+ delete iStreamIn;
+ delete iSRTPSession;
+
+ delete iRFC3711_SessionEncrKey128bits;
+ delete iRFC3711_SessionSaltKey128bits;
+ delete iRFC3711_SessionAuthKey128bits;
+
+ }
+
+void UT_CSRTPStream::UT_CSRTPStream_TestNewL( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ CSRTPMasterKey* mKey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mSalt = CSRTPMasterSalt::NewLC( *masterSalt );
+
+ TSrtpCryptoParams params;
+
+
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mKey, mSalt, params );
+ CleanupStack::Pop( mSalt );
+ CleanupStack::Pop( mKey );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+
+ CSRTPStreamIn* streamIn = CSRTPStreamIn::NewL(*iSRTPSession, context, *this);
+ CleanupStack::Pop( context );
+ delete streamIn;
+ }
+
+void UT_CSRTPStream::UT_CSRTPStream_IsContextSetL( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ CSRTPMasterKey* mKey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mSalt = CSRTPMasterSalt::NewLC( *masterSalt );
+
+ TSrtpCryptoParams params;
+
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mKey, mSalt, params );
+ CleanupStack::Pop( mSalt );
+ CleanupStack::Pop( mKey );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+
+ CSRTPSession* srtpSession = CSRTPSession::NewLC( iDestination );
+ CSRTPStreamIn* streamIn = CSRTPStreamIn::NewL(*iSRTPSession, context, *this);
+ CleanupStack::Pop( srtpSession );
+ CleanupStack::Pop( context );
+ CleanupStack::PushL( srtpSession );
+ CleanupStack::PushL( streamIn );
+ CSRTPStreamIn* streamIn2 = CSRTPStreamIn::NewL(*srtpSession, *this);
+ CleanupStack::PushL( streamIn2 );
+ streamIn->IsContextSet();
+ streamIn2->IsContextSet();
+ CleanupStack::PopAndDestroy( streamIn2 );
+ CleanupStack::PopAndDestroy( streamIn );
+ CleanupStack::PopAndDestroy( srtpSession );
+ }
+
+void UT_CSRTPStream::UT_CSRTPStream_SetROCL( )
+ {
+ //CSRTPStream* tempStream =&(CSRTPStream( *iSRTPSession,0));
+ iStreamIn ->SetROC(22);
+ EUNIT_ASSERT(iStreamIn ->ROC()== 22);
+
+ }
+
+void UT_CSRTPStream::UT_CSRTPStream_ROCL( )
+ {
+ EUNIT_ASSERT( ETrue);
+ }
+
+void UT_CSRTPStream::UT_CSRTPStream_GetCryptoContextL( )
+ {
+ EUNIT_ASSERT((iStreamIn->GetCryptoContext().CryptoParams() .iSrtpAuthTagLen)==
+ 80);
+ }
+void UT_CSRTPStream::UT_CSRTPStream_SetSSRCL( )
+ {
+ CSRTPStreamIn* streamIn = CSRTPStreamIn::NewL(*iSRTPSession, (TUint)0);
+ streamIn->SetSSRC(1);
+ EUNIT_ASSERT(streamIn->SSRC()== 1);
+
+ delete streamIn;
+ }
+
+ void UT_CSRTPStream::UT_CSRTPStream_ReKeyNeeded_1L( )
+ {
+ iReKeyCalled= EFalse;
+ CSRTPStreamIn* streamIn = CSRTPStreamIn::NewL(*iSRTPSession, (TUint)0);
+ streamIn->ReKeyNeeded();
+ EUNIT_ASSERT(iReKeyCalled==ETrue);
+ delete streamIn;
+ }
+
+void UT_CSRTPStream::UT_CSRTPStream_ReKeyNeeded_2L( )
+ {
+ iReKeyCalled= EFalse;
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ CSRTPMasterKey* mKey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mSalt = CSRTPMasterSalt::NewLC( *masterSalt );
+
+ TSrtpCryptoParams params;
+
+
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mKey, mSalt, params );
+ CleanupStack::Pop( mSalt );
+ CleanupStack::Pop( mKey );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ CSRTPStreamOut* streamOut= CSRTPStreamOut::NewL(*iSRTPSession, (TUint)1, context, *this);
+ CleanupStack::Pop( context );
+ streamOut->ReKeyNeeded();
+ EUNIT_ASSERT(iReKeyCalled== ETrue);
+ delete streamOut;
+ }
+// TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+ UT_CSRTPStream,
+ "CSRTPStream test",
+ "UNIT" )
+
+EUNIT_TEST(
+ "SetROC - test ",
+ "CSRTPStream",
+ "SetROC",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_SetROCL, Teardown)
+
+EUNIT_TEST(
+ "ROC - test ",
+ "CSRTPStream",
+ "ROC",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_ROCL, Teardown)
+
+EUNIT_TEST(
+ "GetCryptoContext - test ",
+ "CSRTPStream",
+ "GetCryptoContext",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_GetCryptoContextL, Teardown)
+EUNIT_TEST(
+ "SetSSRCL ",
+ "CSRTPStream",
+ "SetSSRCL",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_SetSSRCL, Teardown)
+EUNIT_TEST(
+ "ReKey1",
+ "CSRTPStream",
+ "ReKey",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_ReKeyNeeded_1L, Teardown)
+EUNIT_TEST(
+ "ReKey2 ",
+ "CSRTPStream",
+ "ReKey",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_ReKeyNeeded_2L, Teardown)
+
+EUNIT_TEST(
+ "TestNewL",
+ "Test Default Constructor",
+ "Test Default Constructor",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_TestNewL, Teardown)
+
+EUNIT_TEST(
+ "isContextSetL",
+ "IsContextSet",
+ "IsContextSet",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStream_IsContextSetL, Teardown)
+
+
+EUNIT_END_TEST_TABLE
+
+// END OF FILE