// Copyright (c) 2008-2009 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:
// Name          : CSIPSecChallengeMD5.cpp
// Part of       : SIPSec/DigestPlugin
// Version       : SIP/6.0
//



#include <hash.h>
#include <e32math.h>
#include "SipLogs.h"
#include "CSIPSecChallengeMD5.h"
#include "sipsecrequestdata.h"
#include "CSIPSecUserRecord.h"
#include "sipsecdigestcontext.h"
#include "sipstrings.h"
#include "sipstrconsts.h"


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::CSIPSecChallengeMD5
// -----------------------------------------------------------------------------
//
CSIPSecChallengeMD5::CSIPSecChallengeMD5( CSIPSecDigest::TChallengeType aType,
										  CSIPSecRequestData::TQop aQop ) :
	CSIPSecChallenge( aType, aQop )
    {
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::NewLC
// -----------------------------------------------------------------------------
//
CSIPSecChallengeMD5*
CSIPSecChallengeMD5::NewLC( CSIPSecDigest::TChallengeType aType,
                            CSIPAuthenticateHeaderBase& aAuthenticateHeader,
                            CSIPSecRequestData::TQop aQop )
    {
	CSIPSecChallengeMD5* self = new( ELeave )CSIPSecChallengeMD5( aType, aQop );
	CleanupStack::PushL( self );
	self->ConstructL( aAuthenticateHeader );	
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::~CSIPSecChallengeMD5
// -----------------------------------------------------------------------------
//
CSIPSecChallengeMD5::~CSIPSecChallengeMD5()
    {
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::VerifyTypeL
// -----------------------------------------------------------------------------
//
void CSIPSecChallengeMD5::VerifyTypeL( CSIPSecUserRecord::TType aType ) const
	{
	__ASSERT_ALWAYS( aType == CSIPSecUserRecord::EIETF,
        			 User::Leave( KErrPermissionDenied ) );
	}

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::CreateUserRecordL
// -----------------------------------------------------------------------------
//
CSIPSecUserRecord*
CSIPSecChallengeMD5::CreateUserRecordL( const TDesC8& aRealm,
										const MSIPSecUser& aUser,
										TRegistrationId aRegistrationId,
									    TTransactionId aTransactionId,
									    TUint /*aResponseCode*/ ) const
	{
	return CSIPSecUserRecord::NewL( aRealm,
									aUser,
									aRegistrationId,
									aTransactionId );
	}
			
// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::SupportedAlgorithm
// -----------------------------------------------------------------------------
//
RStringF CSIPSecChallengeMD5::SupportedAlgorithm()
    {    
    return SIPStrings::StringF( SipStrConsts::EMD5 );
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::AlgorithmName
// -----------------------------------------------------------------------------
//
RStringF CSIPSecChallengeMD5::AlgorithmName() const
    {
    return CSIPSecChallengeMD5::SupportedAlgorithm();
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::ProcessResponseL
// -----------------------------------------------------------------------------
//
TBool CSIPSecChallengeMD5::ProcessResponseL( TSIPSecDigestCtxSetup& aContext,
									   		 TBool& aAskCredentials ) const
    {
    aAskCredentials = EFalse;
    if ( aContext.UserData().IsValid() )
        {
        if ( aContext.UserData().SecretData().Length() == 0 )
            {
            CalculateSecretDataA1L( aContext );
            }
        return EFalse;
        }

    aAskCredentials = aContext.RequestUserCredentialsL();
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::ProcessRequestL
// -----------------------------------------------------------------------------
//
void
CSIPSecChallengeMD5::ProcessRequestL( TSIPSecDigestCtxProcess& aContext ) const
    {
    __SIP_LOG( "SIPSecChallMD5:ProcessRequestL" )

    HBufC8* response = RequestDigestL( aContext );
    CleanupStack::PushL( response );

	__SIP_LOG( "response computed" )

    aContext.SetResponseL( response->Des() );
    CleanupStack::PopAndDestroy( response );
    
    __SIP_LOG( "SIPSecChallMD5:ProcessRequestL ends" )
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::RequestDigestL
// -----------------------------------------------------------------------------
//
HBufC8*
CSIPSecChallengeMD5::RequestDigestL( TSIPSecDigestCtxProcess& aContext ) const
    {
    CMD5& messageDigest = aContext.Mechanism().MessageDigest();            
    HBufC8* a2buf = CalculateA2L( aContext );
    CleanupStack::PushL( a2buf );

    const TDesC8& secretData = aContext.UserData().SecretData();    
    const TDesC8& nonce 	 = aContext.Nonce();
    const TDesC8& nonceCount = aContext.NonceCount();    
    const TDesC8& cnonce 	 = aContext.CNonce();
    const TDesC8& a2 		 = a2buf->Des();        
	const TDesC8& qop 		 = QopDescriptor();

	const TInt KSeparatorCharacters = 2;
	TInt dataSize = secretData.Length() +
					nonce.Length() +
					a2.Length() +
					KSeparatorCharacters;
    if ( HasQop() )
        {
        const TInt KAdditionalSeparatorCharacters = 3;

        dataSize += nonceCount.Length();
        dataSize += cnonce.Length();
        dataSize += qop.Length();        
        dataSize += KAdditionalSeparatorCharacters;
        }

    // Create response for hashing
    HBufC8* data = HBufC8::NewLC( dataSize );

    if ( HasQop() )
        {
        _LIT8( KSIPSecResponsePattern, "%S:%S:%S:%S:%S:%S" );
        data->Des().AppendFormat( KSIPSecResponsePattern,
         					      &secretData,
         					      &nonce,
         					      &nonceCount,
         					      &cnonce,
         					      &qop,
         					      &a2 );
        }
    else
        {
        _LIT8( KSIPSecResponsePatternAssumed, "%S:%S:%S" );
        data->Des().AppendFormat( KSIPSecResponsePatternAssumed,
        						  &secretData,
        						  &nonce,
        						  &a2 );
        }

    // Create response hash
    HBufC8* response = HashL( messageDigest, data->Des() );

    CleanupStack::PopAndDestroy( data );
    CleanupStack::PopAndDestroy( a2buf );

    return response;        
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::GenerateCNonceL
// -----------------------------------------------------------------------------
//
void
CSIPSecChallengeMD5::GenerateCNonceL( TSIPSecDigestCtxSetup& aContext ) const
    {
#ifdef CPPUNIT_TEST
	// Use a known CNonce value in unit testing
	_LIT8( KDummyCNonce, "0a4f113b" );
    aContext.SetCNonceL( KDummyCNonce );
#else
    TTime time;
    time.HomeTime();

    TInt64 timeKey = time.Int64();
    CMD5& messageDigest = aContext.Mechanism().MessageDigest();

    // Append also some other data to keyBuf and increase size of KBufLength

    // Long enough to hold the decimal representation of TInt64
    const TInt KBufLength = 20;
    TBuf8< KBufLength > keyBuf;
	keyBuf.AppendNum( static_cast< TInt64 >( Math::Rand( timeKey ) ) );

    HBufC8* cnonce = HashL( messageDigest, keyBuf );
    CleanupStack::PushL( cnonce );

    aContext.SetCNonceL( cnonce->Des() );
    CleanupStack::PopAndDestroy( cnonce );
#endif
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::CalculateA2L
// -----------------------------------------------------------------------------
//
HBufC8*
CSIPSecChallengeMD5::CalculateA2L( TSIPSecDigestCtxProcess& aContext ) const
    {
    CMD5& messageDigest = aContext.Mechanism().MessageDigest();
    CSIPSecRequestData* requestData = aContext.RequestDataL( Qop() );
    CleanupStack::PushL( requestData );

    HBufC8* dataA2 = HBufC8::NewLC( requestData->Size() );
    
    while ( !requestData->EndOfData() )
        {
        RSIPSecRequestDataField field = requestData->NextL();
        CleanupClosePushL( field );

        if ( field.NeedsHashing() )
            {
            HBufC8* hashBuf = HashL( messageDigest, field.Value() );
            dataA2->Des().Append( hashBuf->Des() );
            delete hashBuf;
            }
        else
            {
            dataA2->Des().Append( field.Value() );
            }

        dataA2->Des().Append( requestData->Separator() );

        CleanupStack::PopAndDestroy(); // field
        }

    HBufC8* a2 = HashL( messageDigest, dataA2->Des() );

    CleanupStack::PopAndDestroy( dataA2 );
    CleanupStack::PopAndDestroy( requestData );
    return a2;
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::CalculateSecretDataA1L
// -----------------------------------------------------------------------------
//
void CSIPSecChallengeMD5::CalculateSecretDataA1L(
	TSIPSecDigestCtxSetup& aContext ) const
    {
    _LIT8( KSIPSecA1Pattern, "%S:%S:%S" );

    CMD5& messageDigest    = aContext.Mechanism().MessageDigest();
    const TDesC8& realm    = aContext.UserData().Realm();
    const TDesC8& username = aContext.UserData().UserName();
    const TDesC8& password = aContext.UserData().Password();

	TInt dataSize = realm.Length() +
					username.Length() +
         	        password.Length() +
         	        KSIPSecA1Pattern().Length();
    HBufC8* data = HBufC8::NewLC( dataSize );
    data->Des().AppendFormat( KSIPSecA1Pattern, &username, &realm, &password );

    HBufC8* secretData = HashL( messageDigest, data->Des() );

    CleanupStack::PopAndDestroy( data );
    aContext.UserData().SetSecretData( secretData );
    }

// -----------------------------------------------------------------------------
// CSIPSecChallengeMD5::HashL
// -----------------------------------------------------------------------------
//
HBufC8* CSIPSecChallengeMD5::HashL( CMD5& aDigest, TPtrC8 aData ) const
    {
    const TInt KHexSize = 2;
    TPtrC8 hash = aDigest.Hash( aData );
    TInt hashSize = aDigest.HashSize();
    TInt bufLength = hashSize * KHexSize;

    HBufC8* buf = HBufC8::NewL( bufLength );
    TPtr8 ptr( buf->Des() );
    TBuf8< KHexSize > hexChar;

    for ( TInt i = 0; i < hashSize; i++ )
		{
		hexChar.NumFixedWidth( hash[ i ], EHex, KHexSize );
		ptr.Append( hexChar );
		}

    aDigest.Reset();
	return buf;
    }