// Copyright (c) 2006-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:

//

/**

 @file tlsstepbase.cpp

 @internalTechnology

*/

#include "tlsstepbase.h"

#include <f32file.h>

#include <tlsprovinterface.h>

#include <asymmetric.h>

#include <asymmetrickeys.h>

#include <symmetric.h>

#include <asnpkcs.h>

#include "tlsgenericactive.h"

#include "psuedorandom.h"

#include "dhparamreader.h"

#include "testpadding.h"

CTlsStepBase::~CTlsStepBase()

	{

	delete iActive;

	delete iProvider;

	delete iSched;

	iSuites.Close();

//	iGenerator.Close();

//	iPrime.Close();

	delete iKeyPair;

	delete iClientMacSecret;

	delete iServerMacSecret;

	delete iClientWriteSecret;

	delete iServerWriteSecret;

	delete iClientInitVector;

	delete iServerInitVector;

	}

void CTlsStepBase::ConstructL()

	{

	iSched=new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(iSched);

	iProvider = CTLSProvider::ConnectL();

	iActive = new (ELeave) CGenericActive;

	}

// Test methods

TInt CTlsStepBase::GetCipherSuitesL()

	{

	iSuites.Reset();

	iProvider->CipherSuitesL(iSuites, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::GetCipherSuitesWithCancelL()

	{

	iSuites.Reset();

	iProvider->CipherSuitesL(iSuites, iActive->iStatus);

	iProvider->CancelRequest();

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::GetCipherSuitesL(CTLSProvider* & aTLSProviderInstance, RArray<TTLSCipherSuite> & aCipherSuites)

	{

	aTLSProviderInstance->CipherSuitesL(aCipherSuites, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::VerifyServerCertificateL(CX509Certificate*& aCertOut)

	{

	HBufC8* cert = ServerCertificateL();

	iProvider->VerifyServerCertificate(*cert, aCertOut, iActive->iStatus);

	iActive->Start();

	delete cert;

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::VerifyServerCertificateL(CTLSProvider* & aTLSProviderInstance, CX509Certificate*& aCertOut)

	{

	HBufC8* cert = ServerCertificateL();

	aTLSProviderInstance->VerifyServerCertificate(*cert, aCertOut, iActive->iStatus);

	iActive->Start();

	delete cert;

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::VerifyServerCertificateWithCancelL(CX509Certificate*& aCertOut)

	{

	HBufC8* cert = ServerCertificateL();

	iProvider->VerifyServerCertificate(*cert, aCertOut, iActive->iStatus);

	iProvider->CancelRequest();

	iActive->Start();

	delete cert;

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::RetrieveServerCert(CX509Certificate*& aCertOut)

	{

	iSession->ServerCertificate(aCertOut,iActive->iStatus);		

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::CreateSessionL()

	{

	iProvider->CreateL(iSession, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::CreateSessionWithCancelL()

	{

	iProvider->CreateL(iSession, iActive->iStatus);

	iProvider->CancelRequest();

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::CreateSessionL(CTLSProvider* & aTLSProviderInstance, CTLSSession* aCTLSSession)

	{

	aTLSProviderInstance->CreateL(aCTLSSession, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase ::VerifyGetSessionL(TTLSServerAddr& aServerName,TInt& aSessionIdLength)

	{

	TTLSSessionId sessionId;

	iProvider->GetSessionL(

		aServerName,

		sessionId,

		iActive->iStatus );

	iActive->Start();

	aSessionIdLength = sessionId.Length();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase ::VerifyGetSessionL(CTLSProvider* & aTLSProviderInstance , TTLSServerAddr& aServerName, TInt& aSessionIdLength)

	{

	TTLSSessionId sessionId;

	aTLSProviderInstance->GetSessionL(

		aServerName,

		sessionId,

		iActive->iStatus );

	iActive->Start();

	aSessionIdLength = sessionId.Length();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase ::CreateSessionAddedL(TInt aHiByte,TInt aLoByte)

	{

	CTlsCryptoAttributes* TlsCryptoAttributes =  iProvider->Attributes();

	TlsCryptoAttributes->iNegotiatedProtocol = KTLS1_0;

	TlsCryptoAttributes->iCurrentCipherSuite.iHiByte = aHiByte;

	TlsCryptoAttributes->iCurrentCipherSuite.iLoByte = aLoByte;

	iProvider->CreateL(iSession, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::ClearSessionCacheL(TTLSSessionNameAndID &aSessionNameAndId)

	{

	iProvider->ClearSessionCacheL( 

			aSessionNameAndId, 

			iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::ClearSessionCacheWithCancelL(TTLSSessionNameAndID &aSessionNameAndId)

	{

	iProvider->ClearSessionCacheL( 

			aSessionNameAndId, 

			iActive->iStatus);

	iProvider->CancelRequest();

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::ClearSessionCacheL(CTLSProvider* & aTLSProviderInstance ,TTLSSessionNameAndID &aSessionNameAndId)

	{

	aTLSProviderInstance->ClearSessionCacheL( 

			aSessionNameAndId, 

			iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

void CTlsStepBase::SessionCancelReq()

	{

	iSession->CancelRequest();

	}

void CTlsStepBase::ProviderCancelReq()

	{

	iProvider->CancelRequest();

	}

TInt CTlsStepBase::ClientKeyExchange(HBufC8*& aMessageOut)

	{

	iSession->ClientKeyExchange(aMessageOut, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::ClientKeyExchange(CTLSSession* &aCTLSSession, HBufC8*& aMessageOut)

	{

	aCTLSSession->ClientKeyExchange(aMessageOut, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::ClientKeyExchangeWithCancel(HBufC8*& aMessageOut)

	{

	iSession->ClientKeyExchange(aMessageOut, iActive->iStatus);

	iSession->CancelRequest();

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::GenerateClientFinishedL(CMessageDigest* aShaDigest, CMessageDigest* aMd5Digest, HBufC8*& aMessageOut)

	{

	iSession->ClientFinishedMsgL(aMd5Digest, aShaDigest, aMessageOut, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::VerifyServerFinishedL(CMessageDigest* aShaDigest, CMessageDigest* aMd5Digest, const TDesC8& aMessage)

	{

	iSession->VerifyServerFinishedMsgL(aMd5Digest, aShaDigest, aMessage, iActive->iStatus);

	iActive->Start();

	return iActive->iStatus.Int();

	}

TInt CTlsStepBase::CipherSuiteIndex(const TTLSCipherSuite& aSuite)

	{

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

		{

		if (CipherSuites()[i] == aSuite)

			{

			return i;

			};

		}

	return KErrNotFound;

	}

HBufC8* CTlsStepBase::DerivePreMasterSecretL(const TDesC8& aClientKeyExMessage)

	{

	return DerivePreMasterSecretL(iProvider, aClientKeyExMessage);

	}

HBufC8* CTlsStepBase::DerivePreMasterSecretL(CTLSProvider* & aTLSProviderInstance, const TDesC8& aClientKeyExMessage)

	{

	// Look up the cipher suite we used for this test

	CTlsCryptoAttributes* atts = aTLSProviderInstance->Attributes();

	TInt index = CipherSuiteIndex(atts->iCurrentCipherSuite);

	if (index < 0)

		{

		INFO_PRINTF3(_L("Failed! Could not find cipher 0x%02x.0x%02x, did the ECOM plugin load okay?"),

			  atts->iCurrentCipherSuite.iHiByte, atts->iCurrentCipherSuite.iLoByte);

		User::Leave(index);

		}

	HBufC8* ret = NULL;

	// currently, we only support three key exhange algorithms, so that is what we test here

	switch (CipherSuites()[index].CipherDetails()->iKeyExAlg)

		{

	case ERsa:

		// decrypt the key exhange message with the "server" private key, and

		// verify the version and that the premaster key is the right size...

		{

		CDecPKCS8Data* keyData = ServerPrivateKeyL();

		CleanupStack::PushL(keyData);

		// we don't own this pointer...

		CPKCS8KeyPairRSA* key = static_cast<CPKCS8KeyPairRSA*>(keyData->KeyPairData());

		CRSAPKCS1v15Decryptor* decryptor = CRSAPKCS1v15Decryptor::NewLC(key->PrivateKey());

		ret = HBufC8::NewLC(decryptor->MaxOutputLength());

		TPtr8 ptr = ret->Des();

		decryptor->DecryptL(aClientKeyExMessage, ptr);

		CleanupStack::Pop(ret);

		CleanupStack::PopAndDestroy(2, keyData); // decryptor

		}

		break;

	case EDHE:

		{

		RInteger clientX = RInteger::NewL(aClientKeyExMessage);

		CleanupClosePushL(clientX);

		RInteger prime = RInteger::NewL(iPrime);

		CleanupClosePushL(prime);

		RInteger gen = RInteger::NewL(iGenerator);

		CleanupClosePushL(gen);

		CDHPublicKey* clientKey = CDHPublicKey::NewL(prime, gen, clientX);

		CleanupStack::Pop(3, &clientX); // prime, gen, adopted by clientKey

		CleanupStack::PushL(clientKey);

		CDH* dh = CDH::NewLC(KeyPair()->PrivateKey());

		// this cast is evil, but hey! it's test code. And I'm not gonna revise the interface.

		ret = const_cast<HBufC8*>(dh->AgreeL(*clientKey));

		CleanupStack::PopAndDestroy(2, clientKey); // dh

		}

		break;

	case EPsk:

		{

		// For PSK cipher suites the premaster secret is formed as follows: 

		// if the PSK is N octets long, concatenate a uint16 with the value N, 

		// N zero octets, a second uint16 with the value N, and the PSK itself.

		// REF: RFC4279

		ret = HBufC8::NewLC(iPskKey->Length()*2 + 4 );

		ret->Des().FillZ(iPskKey->Length()*2 + 4);

 		TPtr8 ptr = ret->Des();

		// Populates first two field bytes values. 

		ptr[0] = (iPskKey->Length() & 0xFF00 ) >> 8;

		ptr[1] = iPskKey->Length() & 0xFF; 

		// Populates second two field bytes values. 

		ptr[iPskKey->Length() + 2] = ptr[0];

		ptr[iPskKey->Length() + 3] = ptr[1];

		// Populates the actual key value.

		ptr.Replace(iPskKey->Length() + 4, iPskKey->Length(), iPskKey->Des() );

		CleanupStack::Pop(ret);

		}

		break;

	default:

		User::Leave(KErrUnknown);

		break;

		}

	return ret;

	}

HBufC8* CTlsStepBase::ComputeMasterSecretL(const TDesC8& aPremasterSecret)

	{

	return CTlsStepBase::ComputeMasterSecretL(iProvider, aPremasterSecret);

	}

HBufC8* CTlsStepBase::ComputeMasterSecretL(CTLSProvider* & aTLSProviderInstance, const TDesC8& aPremasterSecret)

	{

	if (aTLSProviderInstance->Attributes()->iNegotiatedProtocol == KSSL3_0)

		{

		return ComputeSslMasterSecretL(aPremasterSecret);

		}

	else if (aTLSProviderInstance->Attributes()->iNegotiatedProtocol == KTLS1_0)

		{

		return ComputeTlsMasterSecretL(aPremasterSecret);

		}

	else

		{

		// currently unknown protocol!

		User::Leave(KErrUnknown);

		return NULL; // keep the compiler happy..

		}

	}

HBufC8* CTlsStepBase::ComputeMacL(const TDesC8& aData, TInt64 aSequenceNumber, TRecordProtocol& aType, TBool aIsServerMac)

	{

	if (Provider()->Attributes()->iNegotiatedProtocol == KSSL3_0)

		{

		return ComputeSslMacL(aData, aSequenceNumber, aType, aIsServerMac);

		}

	else if (Provider()->Attributes()->iNegotiatedProtocol == KTLS1_0)

		{

		return ComputeTlsMacL(aData, aSequenceNumber, aType, aIsServerMac);

		}

	else

		{

		// currently unknown protocol!

		User::Leave(KErrUnknown);

		return NULL; // keep the compiler happy..

		}

	}

HBufC8* CTlsStepBase::ComputeFinishedMessageL(CMessageDigest* aShaDigest, CMessageDigest* aMd5Digest,

	const TDesC8& aMasterSecret, TBool aClientFinished)

	{

	if (Provider()->Attributes()->iNegotiatedProtocol == KSSL3_0)

		{

		return ComputeSslFinishedL(aShaDigest, aMd5Digest, aMasterSecret, aClientFinished);

		}

	else if (Provider()->Attributes()->iNegotiatedProtocol == KTLS1_0)

		{

		return ComputeTlsFinishedL(aShaDigest, aMd5Digest, aMasterSecret, aClientFinished);

		}

	else

		{

		// currently unknown protocol!

		User::Leave(KErrUnknown);

		return NULL; // keep the compiler happy..

		}

	}

HBufC8* CTlsStepBase::EncryptRecordL(const TDesC8& aData, TInt64 aSequenceNumber, TRecordProtocol& aType, TBool aIsServerCrypt)

	{

	// Compute the mac for this record...

	HBufC8* mac = ComputeMacL(aData, aSequenceNumber, aType, aIsServerCrypt);

	CleanupStack::PushL(mac);

	// now, create an encryptor for this operation....

	CTlsCryptoAttributes* atts = Provider()->Attributes();

	TInt index = CipherSuiteIndex(atts->iCurrentCipherSuite);

	User::LeaveIfError(index);

	TTLSCipherSuite suite = CipherSuites()[index];

	CSymmetricCipher* encryptor = NULL;

	HBufC8* key = aIsServerCrypt ? ServerWriteSecret() : ClientWriteSecret();

	if (suite.CipherDetails()->iCipherType == EStream)

		{

		switch (suite.CipherDetails()->iBulkCiphAlg)

			{

		case ERc4:

			encryptor = CARC4::NewL(*key, 0);

			break;

		case ENullSymCiph:

			encryptor = CNullCipher::NewL();

			break;	

		default:

			User::Leave(KErrUnknown); // unknown cipher!

			break;

			}

		}

	else

		{

		CBlockTransformation* transform = NULL;

		switch (suite.CipherDetails()->iBulkCiphAlg)

			{

		case EDes:

		case EDes40:

			transform = CDESEncryptor::NewLC(*key, EFalse);

			break;

		case E3Des:

			transform = C3DESEncryptor::NewLC(*key);

			break;

		case EAes:

			transform = CAESEncryptor::NewLC(*key);

			break;

		default:

			User::Leave(KErrUnknown); // unknown cipher!

			break;

			}

		HBufC8* iv = aIsServerCrypt ? ServerInitVector() : ClientInitVector();

		CleanupStack::Pop(transform); // ownership transfered to cbc

		CModeCBCEncryptor* cbc = CModeCBCEncryptor::NewLC(transform, *iv);

		CPaddingSSLv3* padding = CPaddingSSLv3::NewLC(cbc->BlockSize());

		// Use next line instead later. Currently broken. Will be required for TLS 1.2

		// CTlsTestPadding* padding = CTlsTestPadding::NewLC(cbc->BlockSize(), 0);

		encryptor = CBufferedEncryptor::NewL(cbc, padding);

		CleanupStack::Pop(2, cbc); // padding - ownership transfered to encryptor

		}

	CleanupStack::PushL(encryptor);

	// encrypt the data, and the mac... padding will be added as appropriate.

	TInt outputMaxLen = encryptor->MaxFinalOutputLength(mac->Length() + aData.Length());

	HBufC8* ret = HBufC8::NewLC(outputMaxLen);

	TPtr8 des = ret->Des();

	encryptor->Process(aData, des);

	encryptor->ProcessFinalL(*mac, des);

	CleanupStack::Pop(ret);

	CleanupStack::PopAndDestroy(2, mac); // encryptor

	return ret;

	}

// INI Read methods

HBufC8* CTlsStepBase::ServerRandomL()

	{

	return ReadRandomL(KServerRandomFile);

	}

HBufC8* CTlsStepBase::ClientRandomL()

	{

	return ReadRandomL(KClientRandomFile);

	}

TTLSCipherSuite CTlsStepBase::CipherSuiteL()