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

// CTlsProviderImpl.CPP

// 

//

#include <ecom/ecom.h>

#include <securitydefsconst.h>

#include <x520ava.h>

#include "tlsprovider.h"

#include "cryptostrength.h"

//

//  CTlsProviderImpl

//

/**

This method creates a new CTlsProviderImpl object

@return Pointer to a new CTlsProviderImpl object is returned

*/

CTlsProviderImpl* CTlsProviderImpl::ConnectL()

	{

	CTlsProviderImpl* tPtr = new (ELeave)CTlsProviderImpl;

	CleanupStack::PushL(tPtr);

	tPtr->ConstructL();

	tPtr->iTlsCryptoAttributes = CTlsCryptoAttributes::NewL();

	CleanupStack::Pop();

	return tPtr;	

	}

CTlsProviderImpl::CTlsProviderImpl()

	:CActive(0), iValidationStatus(EValidatedOK, 0), iTlsProviderPolicy(NULL)

	{

	  if(CActiveScheduler::Current()) //Allready installed?

		{

		CActiveScheduler::Add( this );

		}

	}

TInt CipherSuiteOrder(

		const TTLSCipherSuite& aLeft,

		const TTLSCipherSuite& aRight)

	{	

	if((aLeft.iHiByte == aRight.iHiByte) && (aLeft.iLoByte == aRight.iLoByte))

		return 1;

	else

		return 0;

	}

static TInt CompareCipherIdentities(

	const TTLSCipherSuite& aLeft, const TTLSCipherSuite& aRight)

/**

	This ordering relation is used by CTlsProviderImpl::ReturnCipherListL

	to ensure that cipher appears in a list at most once.  (It will

	also order the ciphers by identity, but that is incidental.)

	It is used with a TLinearOrder template and an RArray.

	It orders the ciphers by identity, which means iHiByte is the most

	significant byte, and iLoByte is the least significant byte.

	@param	aLeft			Left cipher suite to compare.

	@param	aRight			Right cipher suite to compare.

	@return					<0 if the left cipher's identity is less

							than the right cipher's; 0 if they are

							the same; >0 otherwise.

	@see CTlsProviderImpl::ReturnCipherListL

 */

	{

	TInt leftHi = aLeft.iHiByte;

	TInt leftLo = aLeft.iLoByte;

	TInt leftIdentity = (leftHi << 8) | leftLo;

	TInt rightHi = aRight.iHiByte;

	TInt rightLo = aRight.iLoByte;

	TInt rightIdentity = (rightHi << 8) | rightLo;

	return leftIdentity - rightIdentity;

	}

static TInt CompareCipherPriorities(	

	const TTLSCipherSuite& aLeft, const TTLSCipherSuite& aRight)

/**

	This ordering relation is used by CTlsProviderImpl::ReturnCipherListL

	to put the ciphers in priority order, highest priority first.

	A higher priority means the numerically lower value of iPriority.

	E.g. priority 1 is before priority 2.

	It is wrapped in a TLinearOrder object and used to sort an RArray.

	@param	aLeft			Left cipher suite to compare.

	@param	aRight			Right cipher suite to compare.

	@return					<0 if the left cipher's priority is gt

							the right cipher; 0 if they are the same;

							>0 otherwise.

	@see CTlsProviderImpl::ReturnCipherListL

 */

	{

	const TTLSCipherSuiteMapping* cipherDetail = aLeft.CipherDetails();

	TInt leftPri = (cipherDetail == NULL)? pri_unsupp:  cipherDetail->iPriority;

	cipherDetail = aRight.CipherDetails();

	TInt rightPri = (cipherDetail == NULL)? pri_unsupp:  cipherDetail->iPriority;

	return leftPri - rightPri;

	}

/**

The first call to CTlsProviderImpl takes place before ClientHello is sent,then as the handshake progresses, 

the information relevant for Provider and token will be gradually filled in a structure. This 

structure CTlsCryptoAttributes will be returned in this API, If the structure already exists,

then the pointer to the same structure is returned.

@param None

@return Pointer to a CTlsCryptoAttributes structure 

@see CTlsCryptoAttributes

*/

CTlsCryptoAttributes* CTlsCryptoAttributes::NewL()

	{

	CTlsCryptoAttributes* tPtr = new (ELeave)CTlsCryptoAttributes;

	CleanupStack::PushL(tPtr);

	tPtr->iPublicKeyParams = new (ELeave)CTLSPublicKeyParams;

	CleanupStack::Pop();

	return tPtr;

	}

CTlsCryptoAttributes::CTlsCryptoAttributes()

	{

	}

CTlsCryptoAttributes::~CTlsCryptoAttributes()

	{

	delete iPskIdentityHint;

	iReqCertTypes.Close();

	if(iPublicKeyParams)

		delete iPublicKeyParams;

    for ( TInt n = 0; n < iDistinguishedCANames.Count(); n++ )

      	{

      	HBufC8* buf = (HBufC8*)(iDistinguishedCANames[n]);

      	delete buf;

      	}

	iDistinguishedCANames.Close();

	delete iServerNames;

	if(iServerDNFromCertSubject)

		delete iServerDNFromCertSubject;

	if(iServerDNFromCertIssuer)

		delete iServerDNFromCertIssuer;

	}

CTlsCryptoAttributes* CTlsProviderImpl::Attributes() 

	{

	return iTlsCryptoAttributes;

	}

CTlsSessionImpl* CTlsProviderImpl::TlsSessionPtr() 

	{

	return iTlsSessionImpl;

	}

void CTlsProviderImpl::CreateL(

		CTLSSession*& aTlsSession,		

		TRequestStatus& aStatus) 

		{

		TInt Err = 0;

		aStatus = KRequestPending;

		iOriginalRequestStatus = &aStatus;

		aTlsSession = 0;

		iTlsSessionHldr = 0;

		if(IsActive())

			{

			Err = KErrInUse;			

			}

		if(iTlsCryptoAttributes)

 			{

			if((iTlsCryptoAttributes->iSessionNameAndID.iSessionId.Length()) && 

				(iTlsCryptoAttributes->iSessionNameAndID.iSessionId == iSessionData.iSessionId)

			  )

				{

				iSelectedTypeIndex = 0;

				iAbbreviatedHandshake = ETrue;

				}

			else

				{

				iAbbreviatedHandshake = EFalse;

 				TIdentityRelation<TTLSCipherSuite> CipherOrder(CipherSuiteOrder);

				if((iTlsCryptoAttributes->iNegotiatedProtocol != KTLS1_0) || (iTlsCryptoAttributes->iNegotiatedProtocol != KSSL3_0) )

 					Err = KErrSSLAlertIllegalParameter;

 				if(iSupportedCipherSuiteList.Count() &&

 					(iSupportedCipherSuiteList.Find((iTlsCryptoAttributes->iCurrentCipherSuite),CipherOrder) ==KErrNotFound))

 						Err = KErrSSLAlertIllegalParameter;

 				if(iTlsCryptoAttributes->iMasterSecretInput.iServerRandom.Size() != 32)

 					Err = KErrSSLAlertIllegalParameter;	

				if(!(

					(iTlsCryptoAttributes->iMasterSecretInput.iServerRandom).Compare(iTlsCryptoAttributes->iMasterSecretInput.iClientRandom)

					)

				  )

					Err = KErrSSLAlertIllegalParameter;	

				if(!iTotalTokenTypeCount)

					Err = KErrSSLAlertIllegalParameter;	

				}

			}

		if(Err != KErrNone || !iTlsCryptoAttributes)

			{	

   			User::RequestComplete(iOriginalRequestStatus, Err);

  			return; 

   			}

		iOriginalState =  ECreate;			

		iTlsSessionHldr = &aTlsSession;

		iSelectedTypeIndex = -1;	

		TBool TokenFound = EFalse;

		if(!iAbbreviatedHandshake) //Full handshake

			{

			TokenFound = SelectToken();

			if(!TokenFound) //No tokens supporting the selected cipher

				{

				User::RequestComplete(iOriginalRequestStatus, KErrCipherNotSupported);

				}

			else

				{

				if(iTlsCryptoAttributes->iClientAuthenticate)

					{

					//Before we initilize client authenticate, let's check if server

					//provides us it's DN name

					if(!iTlsCryptoAttributes->iDistinguishedCANames.Count())

						{

							//seems we need to use the server DN obtained from server cert as a backup

							iTlsCryptoAttributes->iDistinguishedCANames.AppendL(iTlsCryptoAttributes->iServerDNFromCertSubject);

							iTlsCryptoAttributes->iDistinguishedCANames.AppendL(iTlsCryptoAttributes->iServerDNFromCertIssuer);

							iTlsCryptoAttributes->iServerDNFromCertSubject = NULL; //ownership handover 

							iTlsCryptoAttributes->iServerDNFromCertIssuer = NULL; //ownership handover 

						}

					iClntAuthenticate = CTlsClntAuthenticate::NewL(*iTlsCryptoAttributes,

																	 iEncodedServerCerts);

					iCurrentState = EClientAuthenticate;

					iStoredIntermediatesCACertificates.Reset();

					iClntAuthenticate->DoClientAuthenticate(iSelectedCertInfo,

															iSelectedKeyInfo,

															&iStoredIntermediatesCACertificates,

															iStatus);

					SetActive();

					}

				else

					{

					// Get the session interface and create CtlsSession object

					TLSPROV_LOG2(_L("Using (newly selected) token %d's provider interface"), iSelectedTypeIndex)

					iPtrTokenSearch->GetSessionInterface(iListAllTokensAndTypes[iSelectedTypeIndex].iProviderInterface,

								iSessionInterface,iStatus);

					iCurrentState = EGetSessionInterface;

					iStatus = KRequestPending;

					SetActive();

					}

				}

			}

		else //Abbrevated handshake

			{

			iCurrentState = EGetSessionInterface;

			iNextState =  EConstructResumed;

			iStatus = KRequestPending;

			iPtrTokenSearch->GetSessionInterface(iSessionData.iProviderInterface,

			iSessionInterface,iStatus);

			SetActive();

			}

		return;

		}

void CTlsProviderImpl::GetSessionL(	

		TTLSServerAddr& aServerName,

		TTLSSessionId& aSessionId,

		TRequestStatus& aStatus) 

	{ 

	aStatus = KRequestPending;

	iOriginalRequestStatus = &aStatus;

	if(IsActive())

		{

		User::RequestComplete(iOriginalRequestStatus, KErrInUse);

		return;

		}

	iPServerName =  &aServerName;

	iOutputSessionData.iSessionId.Zero();

	iPSessionId= &aSessionId;

	if(iPtrTokenSearch)

		iTotalTokenTypeCount = iPtrTokenSearch->TotalTypeCount();

	iCurrentTokentype = 0;

	iCurrentToken = 0;

	iOriginalState = EGetSession;

	if(!iTotalTokenTypeCount)

		{	

		iCurrentState =  EBrowseTokens;

		iPtrTokenSearch = CTlsBrowseToken::NewL();		

		iStatus = KRequestPending;

		iPtrTokenSearch->StartBrowsingL(iListAllTokensAndTypes,iStatus);

		SetActive();

		return;

		}

	else

		RetrieveSession();

	return;	

	}

void CTlsProviderImpl::RetrieveSession()

	{

	while((iCurrentTokentype + 1) <= iListAllTokensAndTypes.Count())

		{

		iCurrentState = EGetSession;		

		iReqProtList.Reset();			

		if(iTlsCryptoAttributes)

			{		

			if((iTlsCryptoAttributes->iProposedProtocol.iMajor !=0)

				&& (iTlsCryptoAttributes->iProposedProtocol.iMajor != 0))

				{				

				iReqProtList.Append(iTlsCryptoAttributes->iProposedProtocol);

				}		

			}

		iStatus = KRequestPending;

		iListAllTokensAndTypes[iCurrentTokentype].iProviderInterface->GetSession(

				( (iOriginalState !=  EClearSessionCache)?(*iPServerName):(iServerNameAndId.iServerName)),

				iReqProtList,

				iOutputSessionData,iStatus);

		SetActive();	

		return;	

		}

	ReturnResult();

	}

void CTlsProviderImpl::CipherSuitesL(RArray<TTLSCipherSuite>& aUserCipherSuiteList,TRequestStatus& aStatus)

	{

	aStatus = KRequestPending;

	iOriginalState =  EGetCiphers;

	iOriginalRequestStatus = &aStatus;

	if(IsActive())

		{

		User::RequestComplete(iOriginalRequestStatus, KErrInUse);

		return;

		}

	TLSPROV_LOG2(_L("Obtaining the list of ciphersuites %d"), iTotalTokenTypeCount)

	iUserCipherSuiteList = &aUserCipherSuiteList;

	aUserCipherSuiteList.Reset();

	if(iPtrTokenSearch)

		iTotalTokenTypeCount = iListAllTokensAndTypes.Count();

	if(!iTotalTokenTypeCount)

		{	

		iCurrentState =  EBrowseTokens;

		iStatus = KRequestPending;

		iPtrTokenSearch = CTlsBrowseToken::NewL();		

		iPtrTokenSearch->StartBrowsingL(iListAllTokensAndTypes,iStatus);

		SetActive();

		return;		

		}

	else 

		{

		//we have the Token details already...so lets return the cipher list

		TRAPD(err,ReturnCipherListL());

		User::RequestComplete(iOriginalRequestStatus, err);

		}

	return;

	}

void CTlsProviderImpl::OnEBrowseTokens()

	{

   if ( iStatus == KErrNone )

      {

	   if(iPtrTokenSearch)

		   iTotalTokenTypeCount = iListAllTokensAndTypes.Count();

	   switch(iOriginalState)

	      {

	      case EGetCiphers:

		      ReturnResult();

		      break;

	      case EGetSession:

	      case EClearSessionCache:

		      {

		      RetrieveSession();		

		      }

		      break;

	      default:

		      break;

	      }

      }

   else

      {

		User::RequestComplete(iOriginalRequestStatus, iStatus.Int());

      }

	return;

	}	

void CTlsProviderImpl::VerifyServerCertificate(

		const TDesC8& aEncodedServerCerts, 

		CX509Certificate*& aServerCert,		  			

		TRequestStatus& aStatus)

	{

	aStatus = KRequestPending;

	iOriginalRequestStatus = &aStatus;

	if(IsActive())

		{

		User::RequestComplete(iOriginalRequestStatus, KErrInUse);

		return;

		}

	TTime ValidationTime;	

	ValidationTime.UniversalTime();

	iStatus = KRequestPending;

	iX509ServerCert= &aServerCert;

	iOriginalState =  EValidateCertificate;

	TRAPD(leaveValue, 		

		iEncodedServerCerts=aEncodedServerCerts.AllocL();		

		(iCertVerificationResult= CPKIXValidationResult::NewL()); 

		iServerCertsChain = CPKIXCertChain::NewL(iFs,  aEncodedServerCerts,

												  TUid::Uid(KUidUnicodeSSLProtocolModule));

		if ( iTlsProviderPolicy->PKICriticalExtensions() != 0 )

		    {

            TLSPROV_LOG2(_L("Adding %d additionally Supported Critical Extensions"), iTlsProviderPolicy->PKICriticalExtensions())

            iServerCertsChain->AddSupportedCriticalExtensionsL(iTlsProviderPolicy->GetPKICriticalExtensions());

		    }

		iServerCertsChain->ValidateL(*iCertVerificationResult,ValidationTime,iStatus) );

	if (leaveValue!=KErrNone)

		{

		delete iServerCertsChain;

		iServerCertsChain = 0;

		delete iEncodedServerCerts;

		iEncodedServerCerts = 0;

		iStatus = KErrNone;

		User::RequestComplete(iOriginalRequestStatus, leaveValue);

		}

	else

		{

		iCurrentState = EValidateCertificate;

		SetActive();

		}

	return;

	}

TBool CTlsProviderImpl::VerifySignatureL(

		const CSubjectPublicKeyInfo& aServerPublicKey, 

		const TDesC8& aDigest,const TDesC8& aSignature)

	{

	TBool tempResult;

	tempResult = EFalse;

	switch(iTlsCryptoAttributes->isignatureAlgorithm)

	{

	case ERsaSigAlg:

		{

		//create an RSA public key object from the server certificate

		CRSAPublicKey* rsaPublicKey = CX509RSAPublicKey::NewLC(aServerPublicKey.KeyData());

		//create an RSA signature object from the signature buffer

		RInteger sigInt = RInteger::NewL(aSignature);

		CleanupStack::PushL(sigInt);

		CRSASignature* rsaSignature = CRSASignature::NewL(sigInt);

		CleanupStack::Pop(&sigInt);	//	Owned by rsaSignature

		CleanupStack::PushL(rsaSignature);

		//create a verifier with the server public key

		CRSAPKCS1v15Verifier*  Verifier = CRSAPKCS1v15Verifier::NewLC(*rsaPublicKey);

		//verify the signature

		tempResult = Verifier->VerifyL(aDigest, *rsaSignature);	

		CleanupStack::PopAndDestroy(3, rsaPublicKey);		

		}

		break;

	case EDsa:

		{

		//digest and signature are 8-bit descriptors

		//create a DSA public key object from the server certificate

		CDSAPublicKey* dsaPublicKey = CX509DSAPublicKey::NewL(aServerPublicKey.EncodedParams(),

															  aServerPublicKey.KeyData());

		CleanupStack::PushL(dsaPublicKey);

		//create verifier, verify sig

		CDSAVerifier* verifier = CDSAVerifier::NewL(*dsaPublicKey);

		CleanupStack::PushL(verifier);

		//create DSA signature object from signature buffer

		CDSASignature* dsaSignature = CX509DSASignature::NewLC(aSignature);