/*

* Copyright (c) 2005-2010 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: IKE transaction exchange implementation.

*

*/

/**-------------------------------------------------------------------

 *

 * Class CTransNegotiation

 * This class is used to handle ISAKMP Transaction exchange messages.

 * Transaction exchange has been defined in the IETF draft which specifies

 * The ISAKMP Configuration Method <draft-dukes-ike-mode-cfg-01.txt>.

 * This same two message configuration transaction is also used in IETF draft

 * Extended Authentication within IKE (XAUTH) <draft-beaulieu-ike-xauth-02.txt>.

 * CTransNegotiation class implements these IETF drafts, too.

 *

 *--------------------------------------------------------------------*/

#include "ikev1trans.h"

#include "ikedebug.h"

#include "ikev1pluginsession.h"

#include "ikev1negotiation.h"

#include "ikev1payload.h"

#include "ikev1timeout.h"

#include "ikev1crack.h"

#include "ikev1isakmpstream.h"

#include "ikev1crypto.h"

#include "credentialcache.h"

const TUint8  XAUTH_VID_DATA[8] = {0x09, 0x00, 0x26, 0x89, 0xdf, 0xd6, 0xb7, 0x12};

const TUint8  CISCO_UNITY_VID_DATA[16] = {0x12, 0xf5, 0xf2, 0x8c, 0x45, 0x71, 0x68, 0xa9,

                                          0x70, 0x2d, 0x9f, 0xe2, 0x74, 0xcc, 0x01, 0x00};

const TInt KCredentialTypeUnknown = 0;

const TInt KCredentialTypeNew     = 1;

const TInt KCredentialTypeCached  = 2;

CTransNegotiation::CTransNegotiation( TInt aGranularity,

                                      TBool aUseXauth,

                                      TBool aUseCfgMode, 

                                      CIkev1PluginSession* aPluginSession,

                                      CIkev1Negotiation* aNegotiation,

                                      MIkeDebug& aDebug ) 

    :CArrayFixFlat<TTransExchange*>(aGranularity),

     iPluginSession(aPluginSession),

     iNegotiation(aNegotiation),

     iUseXauth(aUseXauth),

     iUseCfgMode(aUseCfgMode),

     iDebug(aDebug)

{

}

/**-------------------------------------------------------------------

 *

 * Method New()

 * Creates an instance of CTransNegotiation class if either 

 * usage of XAUTH or CFG-MODE has been requested.

 *

 *--------------------------------------------------------------------*/

CTransNegotiation* CTransNegotiation::NewL(TBool aUseXauth, TBool aUseCfgMode,

                                           CIkev1PluginSession* aPluginSession, 

                                           CIkev1Negotiation* aNegotiation,

                                           MIkeDebug& aDebug )

{    

    CTransNegotiation* Neg = new (ELeave) CTransNegotiation( 1,

                                                             aUseXauth,

                                                             aUseCfgMode,

                                                             aPluginSession,

                                                             aNegotiation,

                                                             aDebug );

    CleanupStack::PushL(Neg);

    Neg->ConstructL();

    CleanupStack::Pop(Neg);

    return Neg;        

}

/**-------------------------------------------------------------------

 *

 * Deconstruct method

 *

 *--------------------------------------------------------------------*/

CTransNegotiation::~CTransNegotiation()

{

    DEBUG_LOG(_L("Transaction exchange object deleted"));  

    delete iInternalAddr;

    delete iDialog;

    delete iDialogInfo;

	delete iUserName;

	delete iCache;

    for ( TInt i = 0; i < Count(); i++ )

    {

        delete At(i);

    }

}

/**-------------------------------------------------------------------

 *

 * Method ConstructL()

 * -- Links CKmdEngine- and CNegotiation object pointers to CTransNegotiation

 * -- If only CONFIG-MODE requested, start corresponding transaction exchange.

 *

 *--------------------------------------------------------------------*/

void CTransNegotiation::ConstructL()

{

    if ( !iPluginSession || !iNegotiation || (!iUseXauth && !iUseCfgMode)) 

    {

        User::Leave(KErrArgument);   

    }

    if ( !iUseXauth ) 

    {

       iXauthCompleted = ETrue;

       iNegotiation->iTimer->Cancel();  // Stop retransmission timer   

    }

    else 

    {

       if ( !iUseCfgMode ) 

           iCfgModeCompleted = ETrue;

       DEBUG_LOG(_L("Starting to Wait XAUTH request"));  

    }

    if( EFalse != iPluginSession->IkeData().iUseCache )

    {

        iCache = CCredentialCache::NewL( iDebug );

    }

    DEBUG_LOG(_L("Transaction exchange object constructed"));  

}

/**-------------------------------------------------------------------

 *

 * Method GetAuthMethod()

 * This static method converts the authentication method value from

 * "normal" IKE attribute value (specified in RFC2409) to the attribute

 * value indicate XAUTH usage after IKE phase 1. This conversion is done

 * into the opposite direction when call parameter (aAuthMethod) have

 * already value indicating Xauth usage.

 *

 *--------------------------------------------------------------------*/

TUint16 CTransNegotiation::GetAuthMethod(TUint16 aAuthMethod, TBool aXauthUsed, TInt aRole)

{

    if ( aXauthUsed ) {

       if ( aAuthMethod >= XAUTHInitPreShared && aAuthMethod <= XAUTHRespRSARevisedEncr) {

          aAuthMethod -= XAUTHMethodBase;

          aAuthMethod = (TUint16)((aAuthMethod >> XAUTHScaler) | XAUTHScaler);

       }

       else {

          if ( aAuthMethod >= PRE_SHARED && aAuthMethod <= RSA_REV_ENCR ) {

             aAuthMethod = (TUint16)((aAuthMethod << XAUTHScaler) + XAUTHMethodBase);

             if ( aRole == INITIATOR )

                aAuthMethod -= XAUTHScaler;

          }

       }       

    }

    return aAuthMethod;

}   

/**-------------------------------------------------------------------

 *

 * Method BuildXauthVendorId()

 * This method builds a XAUTH related Vendor ID payload and adds it into 

 * the IKE message. The vendor id is specified in the draft

 * <draft-beaulieu-ike-xauth-02.txt> and its content is the following:

 * ["0x09002689DFD6B712"])

 * Both ISAKMP mode-cfg and extended authentication (XAUTH) can be

 * implemented in some VPN SGWs according to the older mode-cfg and

 * xauth drafts:

 * <draft-ietf-ipsec-isakmp-mode-cfg-04.txt> and

 * <draft-ietf-ipsec-isakmp-xauth-04.txt>

 *

 *--------------------------------------------------------------------*/

void CTransNegotiation::BuildXauthVendorId(TIkev1IsakmpStream &aMsg)

{

    TInetAddr DummyAddr;

    aMsg.IsakmpVendorId(IETF_NATT_VENDOR_ID,

                        NULL, NULL, DummyAddr, // These parameters has no relevance with IETF_NATT_VID_DATA

                        (TUint8*)XAUTH_VID_DATA, sizeof(XAUTH_VID_DATA));

	aMsg.IsakmpVendorId(IETF_NATT_VENDOR_ID,

						NULL, NULL, DummyAddr, // These parameters has no relevance with IETF_NATT_VID_DATA

						(TUint8*)CISCO_UNITY_VID_DATA,

						sizeof(CISCO_UNITY_VID_DATA));

}

/**-------------------------------------------------------------------

 *

 * Method GetIV()

 * Get IV for transaction exchange specified with message id parameter:

 * Find corresponding exchange structure and copy IV to caller

 * If no exchange found, return EFALSE status to indicate error.    

 *

 *--------------------------------------------------------------------*/

TBool CTransNegotiation::GetIV(TUint32 aMsgId, TDes8& aIV)

{

    TBool status = ETrue;

    TTransExchange *exchange = FindExchange(aMsgId);

    if ( exchange )

         aIV.Copy(exchange->iIV);

    else status = EFalse;

    return status;

}   

/**-------------------------------------------------------------------

 *

 * Method SetIV()

 * Set IV for transaction exchange specified with message id parameter:

 * Find corresponding exchange structure and store specified IV to

 * exchange structure

 * If no exchange found, return EFALSE status to indicate error.    

 *

 *--------------------------------------------------------------------*/

TBool CTransNegotiation::SetIV(TUint32 aMsgId, TDes8& aIV)

{

    TBool status = ETrue;

    TTransExchange *exchange = FindExchange(aMsgId);

    if ( exchange )

         exchange->iIV.Copy(aIV);

    else status = EFalse;

    return status;

}   

/**-------------------------------------------------------------------

 *

 * Method ProcessUserResponseL()

 * ProcessUserResponseL() builds a XAUTH reply message from authentication

 * credentials linked into the current CAuthDialogInfo object.

 *

 *--------------------------------------------------------------------*/

TInt CTransNegotiation::ProcessUserResponseL(CAuthDialogInfo *aDialogInfo )

{

    //

    // Find a transaction exchange structure for current message 

    //

    TInt lth = 0;

    iCurrExchange = FindExchange(aDialogInfo->GetMsgId());

    if ( iCurrExchange && iRequestFlags ) {

       //

       // Allocate a buffer for Attribute payload.

       // Calculate first required buffer length

       //

       if ( aDialogInfo->iUsername )    

          lth += (aDialogInfo->iUsername->Length() + 4);

       if ( aDialogInfo->iSecret )  

          lth += (aDialogInfo->iSecret->Length() + 4);

       HBufC8 *attributes = HBufC8::NewL(lth + 4);

       CleanupStack::PushL(attributes);

       TPtr8 attr_ptr(attributes->Des());

	   TUint16 AttrType;

       if ( iRequestFlags & (1 << (ATTR_PASSWORD - ATTR_XAUTH_TYPE)) ) {

          //

          // Add Xauth type attribute. Value is taken from current exchange structure

          //

		  if ( iUseOlderPIXXauth )

			   AttrType = ATTR_PIX_XAUTH_TYPE;

          else AttrType = ATTR_XAUTH_TYPE;						 

          AddAttributeData(attr_ptr, AttrType, 2, (TUint8*)&iCurrExchange->iXauthType);

       }

       if ( aDialogInfo->iUsername ) {

          //

          // Add user name attribute. 

          //

	      if ( iUseOlderPIXXauth )

			   AttrType = ATTR_PIX_USER_NAME;

		  else AttrType = ATTR_USER_NAME;						 

          AddAttributeData(attr_ptr, AttrType, aDialogInfo->iUsername->Length(),

                           (TUint8*)aDialogInfo->iUsername->Ptr());

          //

	      // Take a copy of user name buffer in dialog info. This user name

	      // is cached into user name file if current CRACK negotiation is

	      // succeeded

	      //

		  delete iUserName; // Delete old user name buffer for sure

  	      iUserName = HBufC8::New(aDialogInfo->iUsername->Length() + 16); // 16 bytes space for padding

		  if ( iUserName ) {

		     iUserName->Des().Copy(aDialogInfo->iUsername->Des()); 

		  }

		  if( iCache && KCredentialTypeNew == iCredentialType )

		  {

		      iCache->SetUserName( *aDialogInfo->iUsername );

		  }

       }

       if ( aDialogInfo->iSecret ) {

          //

          // Add either password, passcode or next pin attribute.

          // Check from iRequestFlags which one was requested by the gateway

          //

	      if ( iUseOlderPIXXauth )

			   AttrType = ATTR_PIX_PASSWORD; // default;

		  else AttrType = ATTR_PASSWORD; // default

          switch ( iRequestFlags ) {

              case (1 << (ATTR_PASSCODE - ATTR_XAUTH_TYPE)):

				  if ( iUseOlderPIXXauth )

					   AttrType = ATTR_PIX_PASSCODE;

				  else AttrType = ATTR_PASSCODE;

                  break;

              case (1 << (ATTR_NEXT_PIN - ATTR_XAUTH_TYPE)):

                  AttrType = ATTR_NEXT_PIN;

                  break;

              default:

                  if( iCache && KCredentialTypeNew == iCredentialType )

                  {

                      iCache->SetSecret( *aDialogInfo->iSecret );

                  }

                  break;

          }

          AddAttributeData(attr_ptr, AttrType, aDialogInfo->iSecret->Length(),

                          (TUint8*)aDialogInfo->iSecret->Ptr());           

       }

       BuildAndSendMessageL(attr_ptr, ISAKMP_CFG_REPLY);

       CleanupStack::PopAndDestroy(); //attributes 

       iRequestFlags = 0;

    }

    delete iDialog;  // delete dialog object

    delete aDialogInfo;  // release dialog info object  

    iDialog = NULL;

    iDialogInfo = NULL;  

    return TRANSACTION_CONTINUE;

}   

/**-------------------------------------------------------------------

 *

 * Method TransactionFailedL()

 * TransactionFailedL() is called when a notificatio/delete payload 

 * has been received in the middle of a transaction exchange.

 *

 *--------------------------------------------------------------------*/

TInt CTransNegotiation::TransactionFailedL(const TNotificationISAKMP *aNotifPayload)

{

    (void)aNotifPayload;

    iNegotiation->iTimer->Cancel();   //Cancel timer because authentication failed

    DEBUG_LOG(_L("Transaction exchange stopped by the gateway!"));

    // 

    // Dialog object shall be delete in Dialog->RunL when dialog completed

    //

    CIkev1Dialog* Dialog  = CIkev1Dialog::NewL(iPluginSession, iPluginSession->DialogAnchor(), iDebug);

    Dialog->ShowErrorDialogL(TVpnNoteDialog::EKmdAuthenticationFailed, NULL, NULL);

    return TRANSACTION_FAILED;

}

/**-------------------------------------------------------------------

 *

 * Method ExecuteL()

 * Processes a received ISAKMP transaction exchange message.

 * The received message MUST be an encrypted transaction exchange message

 * otherwise it is silently discarded.

 * Current TTransExchange structure is found, IV value calculated and

 * ISAKMP message decrypted.

 * TransactionExchangeL() method returns to the caller the following status codes:

 * (Corresponding CRACK status codes  defined in ike_crack.h)

 * -- TRANSACTION_SUCCESS (0) =

 *    Transaction exchange(s) has been succesfully completed.

 *    Normal operation can continue and CTransNegotiation object can be deleted.

 * -- TRANSACTION_CONTINUE (1) =

 *    Received message succesfully processed.

 *    Transaction exchange(s) shall still continue. 

 * -- TRANSACTION_IGNORE   (2) =

 *    Received message ignored. Transaction exchange(s) shall still continue. 

 * -- TRANSACTION_FAILED   (4) =

 *    Transaction exchange(s) has been failed (either CONFIG-MODE or XAUTH).

 *    Current CNegotiation object as well as CTransNegotiation object can

 *    be deleted. (= corresponding ISAKMP phase 1 negotiation shall be deleted).

 *

 *--------------------------------------------------------------------*/

#ifdef _DEBUG

TInt CTransNegotiation::ExecuteL( const ThdrISAKMP& aHdr,

                                  const TInetAddr& aSrcAddr,

                                  TInt aLocalPort )

#else

TInt CTransNegotiation::ExecuteL( const ThdrISAKMP& aHdr,

                                  const TInetAddr& /*aSrcAddr*/,

                                  TInt /*aLocalPort*/ )

#endif

{

    DEBUG_LOG(_L("Received message (encr)."));

    TLastIKEMsg msg_info(aHdr); //For retransmitted IKE msg detection

    if ( iLastTransMsgInfo.IsReTransmit(msg_info) ) {

       DEBUG_LOG(_L("Retransmitted Transaction message received, silently discarded !"));

       return TRANSACTION_IGNORE;              

    }

    TUint32 status = TRANSACTION_IGNORE; // default

    TUint32 msg_id;

    TBuf8<IV_LTH> tmp_IV;   //Temporal IV. Used to update the real one if the msg OK    

    const ThdrISAKMP *hdr = NULL;

    TUint8 *msg = NULL;

    msg_id = aHdr.GetMessageId();   //Saves the ID to compute IV and hash

    if (aHdr.GetFlags() & ISAKMP_HDR_EFLAG) //if encrypted

    {

        msg = new (ELeave) TUint8[aHdr.GetLength()];    //to place the new msg

		CleanupStack::PushL(msg);

        Mem::Copy(msg, (TUint8 *)&aHdr, sizeof(aHdr));  //The header is not encrypted

#ifdef _DEBUG        

        DEBUG_LOG(_L("Message ID recv:"));        

        TUint32 swap_id = ByteOrder::Swap32(msg_id);

        DEBUG_LOG_ARRAY((TUint8 *)&swap_id, sizeof(msg_id));

        DEBUG_LOG(_L("Transaction IV:"));

#endif // _DEBUG        

        //

        // Find a transaction exchange structure for current message 

        //

        iCurrExchange = FindExchange(msg_id);

        if ( !iCurrExchange )

           iCurrExchange = AddExchangeL(msg_id, RESPONDER); // Add a new transaction exchange

        //

        // Adjust IV value for transaction exchange.

        // There is now two situations:

        // 1) There already exists an IV in exchange structure

        //    (received message is a reply for an earlier sent request)

        // 2) There is no IV in exchange structure

        //    (received message is a new request/set message from peer)

        //    A new IV is built from CNegotiation.iLastIV and current message ID

        //

        if ( iCurrExchange->iIV.Length() == 0 ) {

           iCurrExchange->iIV.Copy(iNegotiation->iLastIV);          

           iNegotiation->ComputeIVL(iCurrExchange->iIV, msg_id);        

        }

        tmp_IV.Copy(iCurrExchange->iIV); // Make a copy of current IV                       

        DEBUG_LOG(_L("Decrypting..."));

        DecryptL((TUint8 *)aHdr.Next(),&msg[sizeof(aHdr)], (aHdr.GetLength()-sizeof(aHdr)),

                 iCurrExchange->iIV, iNegotiation->iSKEYID_e,

                 iNegotiation->iChosenProposal_I.iAttrList->iEncrAlg);

        hdr = (ThdrISAKMP *)msg;  //decrypted msg

#ifdef _DEBUG   

        const TPtrC8 ikeMsgPtr( (TUint8*)hdr,(TUint16)hdr->GetLength() );

        TInetAddr dstAddr;

        iPluginSession->GetLocalAddress( dstAddr );

        dstAddr.SetPort( aLocalPort );

        TRACE_MSG_IKEV1( ikeMsgPtr, aSrcAddr, dstAddr );                        

#endif // _DEBUG                        

        status = TransactionExchangeL(*hdr);

        if ( status == TRANSACTION_IGNORE ) {

           //

           // Current message ignored, restore saved IV to exchange structure

           //   

           iCurrExchange->iIV.Copy(tmp_IV);

        }

    }

    else

        hdr = &aHdr;

    if (msg)    //If used erase it (when encryption)

        CleanupStack::PopAndDestroy();

    if ( status == TRANSACTION_CONTINUE )

       msg_info.Store(iLastTransMsgInfo); // store new last received IKE message info

    return status;

}

/**-------------------------------------------------------------------

 *

 * Method TransactionExchangeL()

 * The ISAKMP transaction exchange message MUST be the following format:

 * HDR*, HASH, ATTR

 * Where the HASH payload contains the prf output, using SKEYID_a as

 * the key, and the M-ID (ISAKMP header Message ID) unique to this

 * exchange concatenated with all of the payloads after the HASH

 * payload. In other words, the hash for the above exchange is:

 * HASH = prf( SKEYID_a, M-ID | ATTR )

 * Multiple ATTR payloads MAY NOT be present in the Transaction Exchange.

 *

 *--------------------------------------------------------------------*/

TInt CTransNegotiation::TransactionExchangeL(const ThdrISAKMP &aHdr)

{

    TUint32 status;

	iNegotiation->iLengthLeft = aHdr.GetLength(); //Used to check the size in the payload are OK

	CIkev1Payloads* payload = CIkev1Payloads::NewL(aHdr, *iNegotiation, iDebug);

	if (!payload)

	{	

		return TRANSACTION_FAILED;    

	}

	CleanupStack::PushL(payload);

	if ( payload->iHash && payload->iAttr )

	{

	   // 

	   // Check if the hash value is OK. 

	   // 

	   if (!iNegotiation->VerifyInformationalHashL(payload->iHash, payload->iAttr,