--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rtp/srtpstack/tsrc/ut_srtpstack/src/UT_CSRTPCryptoHandler.cpp Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,335 @@
+/*
+* 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_CSRTPCryptoHandler.h"
+
+// EXTERNAL INCLUDES
+#include <digia/eunit/eunitmacros.h>
+
+
+// INTERNAL INCLUDES
+#include "srtpcryptohandlersrtp.h"
+#include "srtpmastersalt.h"
+#include "srtpmasterkey.h"
+#include "srtpstreamin.h"
+#include "srtpstreamout.h"
+#include "srtpsession.h"
+#include "srtputils.h"
+
+/*
+ master key: E1F97A0D3E018BE0D64FA32C06DE4139
+ master salt: 0EC675AD498AFEEBB6960B3AABE6
+*/
+_LIT8(KTestMKI128Bits, "ABCDEF1234567890ABCDEF1234567890");
+_LIT8(KRFC3711_TestMasterKey128bits, "E1F97A0D3E018BE0D64FA32C06DE4139");
+_LIT8(KRFC3711_TestMasterSalt112bits, "0EC675AD498AFEEBB6960B3AABE6");
+// 80 bit key, test 1
+_LIT8(KTestAuthTag80bits, "ABABABABABABABABABAB");
+
+_LIT8(KRFCTestSalt112bits, "0EC675AD498AFEEBB6960B3AABE6");
+_LIT8(KSRTP_RFC112bitEncrXValue, "0EC675AD498AFEEBB6960B3AABE6");
+_LIT8(KSRTP_RFC112bitAuthXValue, "0EC675AD498AFEEAB6960B3AABE6");
+_LIT8(KSRTP_RFC112bitSaltXValue, "0EC675AD498AFEE9B6960B3AABE6");
+_LIT8(KSRTCP_RFC112bitEncrXValue, "0EC675AD498AFEEBB6950B3AABE6");
+_LIT8(KSRTCP_RFC112bitAuthXValue, "0EC675AD498AFEEBB6920B3AABE6");
+_LIT8(KSRTCP_RFC112bitSaltXValue, "0EC675AD498AFEEBB6930B3AABE6");
+
+
+// CONSTRUCTION
+UT_CSRTPCryptoHandler* UT_CSRTPCryptoHandler::NewL()
+ {
+ UT_CSRTPCryptoHandler* self = UT_CSRTPCryptoHandler::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+UT_CSRTPCryptoHandler* UT_CSRTPCryptoHandler::NewLC()
+ {
+ UT_CSRTPCryptoHandler* self = new( ELeave ) UT_CSRTPCryptoHandler();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+UT_CSRTPCryptoHandler::~UT_CSRTPCryptoHandler()
+ {
+ }
+
+// Default constructor
+UT_CSRTPCryptoHandler::UT_CSRTPCryptoHandler()
+ {
+ }
+
+void UT_CSRTPCryptoHandler::SRTPMasterKeyStaleEvent(const CSRTPStream& /*aStream*/ )
+ {
+ }
+void UT_CSRTPCryptoHandler::SRTPMasterKeyStaleEvent(const CSRTPSession& /*aSession*/ )
+ {
+ }
+
+// Second phase construct
+void UT_CSRTPCryptoHandler::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+ }
+
+// METHODS
+
+void UT_CSRTPCryptoHandler::Hex(HBufC8& aString)
+{
+ TPtr8 ptr=aString.Des();
+ 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_CSRTPCryptoHandler::SetupL( )
+ {
+ iTestAuthTag80Bits = HBufC8::NewL(KTestAuthTag80bits().Length());
+ *iTestAuthTag80Bits = KTestAuthTag80bits;
+ Hex(*iTestAuthTag80Bits);
+
+ // initialize salting key (from RFC)
+ iRFCTestSalt112bits.Copy(KRFCTestSalt112bits);
+ TSRTPUtils::DeHex(iRFCTestSalt112bits, iRFCTestSalt112bits_dehexed);
+
+ // initialize derived SRTP session encr key (from RFC)
+ iSRTP_RFC112bitEncrXValue.Copy(KSRTP_RFC112bitEncrXValue);
+ TSRTPUtils::DeHex(iSRTP_RFC112bitEncrXValue, iSRTP_RFC112bitEncrXValue_dehexed);
+ // initialize derived SRTP session auth key (from RFC)
+ iSRTP_RFC112bitAuthXValue.Copy(KSRTP_RFC112bitAuthXValue);
+ TSRTPUtils::DeHex(iSRTP_RFC112bitAuthXValue, iSRTP_RFC112bitAuthXValue_dehexed);
+ // initialize derived SRTP session salting key (from RFC)
+ iSRTP_RFC112bitSaltXValue.Copy(KSRTP_RFC112bitSaltXValue);
+ TSRTPUtils::DeHex(iSRTP_RFC112bitSaltXValue, iSRTP_RFC112bitSaltXValue_dehexed);
+
+ // initialize derived SRTCP session encr key (from RFC)
+ iSRTCP_RFC112bitEncrXValue.Copy(KSRTCP_RFC112bitEncrXValue);
+ TSRTPUtils::DeHex(iSRTCP_RFC112bitEncrXValue, iSRTCP_RFC112bitEncrXValue_dehexed);
+ // initialize derived SRTCP session auth key (from RFC)
+ iSRTCP_RFC112bitAuthXValue.Copy(KSRTCP_RFC112bitAuthXValue);
+ TSRTPUtils::DeHex(iSRTCP_RFC112bitAuthXValue, iSRTCP_RFC112bitAuthXValue_dehexed);
+ // initialize derived SRTCP session salting key (from RFC)
+ iSRTCP_RFC112bitSaltXValue.Copy(KSRTCP_RFC112bitSaltXValue);
+ TSRTPUtils::DeHex(iSRTCP_RFC112bitSaltXValue, iSRTCP_RFC112bitSaltXValue_dehexed);
+
+
+ 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, (TUint)1);
+ iStreamOut = CSRTPStreamOut::NewL(*iSRTPSession, (TUint)2);
+ //iCryptoHandlerSRTP = CSRTPCryptoHandlerSRTP::NewL(*iStreamIn);
+ //iStreamIn->iHandlerRTP = iCryptoHandlerSRTP;
+ iCryptoHandlerSRTP = iStreamIn->iHandlerRTP;
+ }
+
+void UT_CSRTPCryptoHandler::Teardown( )
+ {
+ delete iTestAuthTag80Bits;
+ delete iStreamIn;
+
+ delete iStreamOut;
+ delete iSRTPSession;
+
+ iResult.Zero();
+ iRFCTestSalt112bits.Zero();
+ iRFCTestSalt112bits_dehexed.Zero();
+ iRFC_TestSalt_80bits.Zero();
+
+ // SRTP test data KSRTP_RFC112bitEncrXValue
+ iSRTP_RFC112bitEncrXValue.Zero();
+ iSRTP_RFC112bitEncrXValue_dehexed.Zero();
+ iSRTP_RFC112bitAuthXValue.Zero();
+ iSRTP_RFC112bitAuthXValue_dehexed.Zero();
+ iSRTP_RFC112bitSaltXValue.Zero();
+ iSRTP_RFC112bitSaltXValue_dehexed.Zero();
+
+ // SRTCP test data
+ iSRTCP_RFC112bitEncrXValue.Zero();
+ iSRTCP_RFC112bitEncrXValue_dehexed.Zero();
+ iSRTCP_RFC112bitAuthXValue.Zero();
+ iSRTCP_RFC112bitAuthXValue_dehexed.Zero();
+ iSRTCP_RFC112bitSaltXValue.Zero();
+ iSRTCP_RFC112bitSaltXValue_dehexed.Zero();
+
+ }
+
+void UT_CSRTPCryptoHandler::UT_CSRTPCryptoHandler_MasterKeyUpdatedL( )
+ {
+ EUNIT_ASSERT(iCryptoHandlerSRTP->MasterKeysUpdated()==EFalse);
+ iCryptoHandlerSRTP->SRTPMasterKeyChanged();
+ EUNIT_ASSERT(iCryptoHandlerSRTP->MasterKeysUpdated()==ETrue);
+ }
+
+void UT_CSRTPCryptoHandler::UT_CSRTPCryptoHandler_AuthenticateLL( )
+ {
+ EUNIT_ASSERT( ETrue );
+ }
+
+
+void UT_CSRTPCryptoHandler::UT_GetAuthenticationTagL( )
+ {
+/*
+ TBuf8<KMinRtpHeaderSize + 200> packetTBuf;
+
+ for (TInt i=0; i<KMinRtpHeaderSize; i++)
+ {
+ //Fill the header with zeros
+ packetTBuf.Append(0x00);
+ }
+
+ for (TInt i=0; i<20; i++)
+ {
+ //Append 160 bit payload
+ packetTBuf.Append(0x11);
+ }
+
+
+ for (TInt i=0; i<10; i++)
+ {
+ //Append the authTag
+ packetTBuf.Append(0xAB);
+ }
+
+ iCryptoHandlerSRTP->iPacket.Set(packetTBuf);
+
+ TPtrC8 authTag = iCryptoHandlerSRTP->GetAuthenticationTag();
+
+ EUNIT_ASSERT (authTag.Compare(*iTestAuthTag80Bits) == 0)
+ */
+ }
+
+
+void UT_CSRTPCryptoHandler::UT_Count_XL( )
+ {
+
+ TUint64 r = TSRTPUtils::Cnt_r(5, iContext->CryptoParams().iSrtpKeyDervRate);
+
+ // first SRTP..
+ // SRTP encr label (0x00)
+ iCryptoHandlerSRTP->Count_X(r, KSRTPEncryptionLabel, KSRTPIndexLength, iResult);
+ EUNIT_ASSERT( iResult.Compare(iSRTP_RFC112bitEncrXValue_dehexed) == 0);
+ //reset result
+ iResult.FillZ();
+ // SRTP auth label (0x01)
+ iCryptoHandlerSRTP->Count_X(r, KSRTPAuthenticationLabel, KSRTPIndexLength, iResult);
+ EUNIT_ASSERT( iResult.Compare(iSRTP_RFC112bitAuthXValue_dehexed) == 0);
+ //reset result
+ iResult.FillZ();
+ // SRTP salting label (0x02)
+ iCryptoHandlerSRTP->Count_X(r, KSRTPSaltingLabel, KSRTPIndexLength, iResult);
+ EUNIT_ASSERT( iResult.Compare(iSRTP_RFC112bitSaltXValue_dehexed) == 0);
+ //reset result
+ iResult.FillZ();
+
+ // then SRTCP.. later
+ }
+
+
+
+// TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+ UT_CSRTPCryptoHandler,
+ "CSRTPCryptoHandler",
+ "UNIT" )
+
+EUNIT_TEST(
+ "UnprotectL - test ",
+ "CSRTPCryptoHandler",
+ "UnprotectL",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPCryptoHandler_MasterKeyUpdatedL, Teardown)
+
+EUNIT_TEST(
+ "ProtectL - test ",
+ "CSRTPCryptoHandler",
+ "ProtectL",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPCryptoHandler_AuthenticateLL, Teardown)
+
+EUNIT_TEST(
+ "GetAuthenticationTag - test ",
+ "CSRTPCryptoHandler",
+ "GetAuthenticationTag",
+ "FUNCTIONALITY",
+ SetupL, UT_GetAuthenticationTagL, Teardown)
+
+EUNIT_TEST(
+ "Count_X - test ",
+ "CSRTPCryptoHandler",
+ "Count_X",
+ "FUNCTIONALITY",
+ SetupL, UT_Count_XL, Teardown)
+EUNIT_TEST(
+ "MasterKeyUpdated ",
+ "CSRTPCryptoHandler",
+ "MasterKeyUpdated",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPCryptoHandler_MasterKeyUpdatedL, Teardown)
+EUNIT_END_TEST_TABLE
+
+// END OF FILE