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