// 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 verifysignaturestep.cpp
 @internalTechnology
*/
#include "verifysignaturestep.h"

#include <tlsprovinterface.h>
#include <asymmetric.h>
#include <asnpkcs.h>
#include <asn1enc.h>

CVerifySignatureStep::CVerifySignatureStep()
	{
	SetTestStepName(KVerifySignatureStep);
	}
	
TVerdict CVerifySignatureStep::doTestStepPreambleL()
	{
	ConstructL();
	
	CTlsCryptoAttributes* atts = Provider()->Attributes();
	
	// read the "server" random
	HBufC8* random = ServerRandomL();
	atts->iMasterSecretInput.iServerRandom.Copy(*random);
	delete random;
	
	// and the client random
	random = ClientRandomL();
	atts->iMasterSecretInput.iClientRandom.Copy(*random);
	delete random;
	
	// we only support null compression...
	atts->iCompressionMethod = ENullCompression;
	
	// read the cipher suite for the test
	atts->iCurrentCipherSuite = CipherSuiteL();
	
	// read the protocol version
	TTLSProtocolVersion version = ProtocolVersionL();
	atts->iNegotiatedProtocol = version;
	atts->iProposedProtocol = version;
	
	// set the session ID and "server" name (localhost)
	atts->iSessionNameAndID.iSessionId = SessionId();
	atts->iSessionNameAndID.iServerName.iAddress = KLocalHost; 
	atts->iSessionNameAndID.iServerName.iPort = 443;
	atts->idomainName.Copy(DomainNameL());
	
	// try and read DH params, this section may not exist
	RInteger gen;
	CleanupClosePushL(gen);
	
	RInteger prime;
	CleanupClosePushL(prime);
	
	TRAPD(err, ReadDHParamsL());
	if (err == KErrNone)
		{
		atts->iPublicKeyParams->iKeyType = EDHE;
		
		// The params are:
		// 1 - Prime
		// 2 - Generator
		// 3 - generator ^ random mod prime
		
		atts->iPublicKeyParams->iValue1 = Prime().BufferLC();
		CleanupStack::Pop(atts->iPublicKeyParams->iValue1);
		
		atts->iPublicKeyParams->iValue2 = Generator().BufferLC();
		CleanupStack::Pop(atts->iPublicKeyParams->iValue2);
		
		atts->iPublicKeyParams->iValue3 = KeyPair()->PublicKey().X().BufferLC();
		CleanupStack::Pop(atts->iPublicKeyParams->iValue3);
		}
		
	CleanupStack::PopAndDestroy(2, &gen); // prime
	
	// No client authentication or dialogs for this test, please
	atts->iClientAuthenticate = EFalse;
	atts->iDialogNonAttendedMode = ETrue;
	
	return EPass;
	}
	
TVerdict CVerifySignatureStep::doTestStepL()
	{
	INFO_PRINTF1(_L("Calling TLS Provider to fetch cipher suites."));
	// first we have to retrieve the available cipher suites
	TInt err = GetCipherSuitesL();
	
	if (err != KErrNone)
		{
		SetTestStepResult(EFail);
		return TestStepResult();
		}
	
	INFO_PRINTF1(_L("Calling TLS Provider to verify server certificate."));
	CX509Certificate* cert = NULL;
	err = VerifyServerCertificateL(cert);
	CleanupStack::PushL(cert);

	if (err != KErrNone)
		{
		SetTestStepResult(EFail);
		return TestStepResult();
		}
		
	// sign some random data, and call it a signature....
	// doesn't have to be an actual digest, since we don't pass the data buffer.
	
	TBuf8<36> digest;
	CTlsCryptoAttributes* atts = Provider()->Attributes();

	TInt index = KErrNotFound;
	for(TInt j=0;j<CipherSuites().Count();j++)
		{
		if(CipherSuites()[j] == atts->iCurrentCipherSuite)
			{
			index = j;
			break;
			}
		}
	User::LeaveIfError(index);

	TTLSCipherSuite suite = CipherSuites()[index];
	// ajust the pseudo-digest size for sig algorithm
	switch(suite.CipherDetails()->iSigAlg)
		{
	case EDsa:
		atts->isignatureAlgorithm = EDsa;
		digest.SetLength(20); // only one SHA-1 in size
		break;
	
	case ERsaSigAlg:
		atts->isignatureAlgorithm = ERsaSigAlg;
		digest.SetLength(36); // MD5 + SHA-1 in size
		break;
	
	default:
		User::Leave(KErrUnknown);
		break;
		}
	
	TRandom::RandomL(digest);
	
	// get the server private key data
	CDecPKCS8Data* keyData = ServerPrivateKeyL();
	CleanupStack::PushL(keyData);
	
	// sign the "digest" with the appropriate signature algorithm
	HBufC8* signature = NULL;
	switch(suite.CipherDetails()->iSigAlg)
		{
	case EDsa:
		{
		// we don't own this pointer
		CPKCS8KeyPairDSA* key = static_cast<CPKCS8KeyPairDSA*>(keyData->KeyPairData());
		
		CDSASigner* signer = CDSASigner::NewLC(key->PrivateKey());
		const CDSASignature* sig = signer->SignL(digest);
		CleanupStack::PushL(const_cast<CDSASignature*>(sig));
		
		// DSA sig is an ASN.1 sequence of R followed by S
		CASN1EncSequence* sigSeq = CASN1EncSequence::NewLC();
		
		CASN1EncBigInt* rAsn = CASN1EncBigInt::NewLC(sig->R());
		sigSeq->AddAndPopChildL(rAsn);
		
		CASN1EncBigInt* sAsn = CASN1EncBigInt::NewLC(sig->S());
		sigSeq->AddAndPopChildL(sAsn);
		
		signature = HBufC8::NewLC(sigSeq->LengthDER());
		TPtr8 sigPtr = signature->Des();
		sigPtr.SetLength(sigSeq->LengthDER());
		TUint pos = 0;
		sigSeq->WriteDERL(sigPtr, pos);
		CleanupStack::Pop(signature);
		
		CleanupStack::PopAndDestroy(3, signer); //sig, sigSeq
		}
		break;

	case ERsaSigAlg:
		{
		// we don't own this pointer
		CPKCS8KeyPairRSA* key = static_cast<CPKCS8KeyPairRSA*>(keyData->KeyPairData());
		
		CRSAPKCS1v15Signer* signer = CRSAPKCS1v15Signer::NewLC(key->PrivateKey());
		const CRSASignature* sig = signer->SignL(digest);
		CleanupStack::PushL(const_cast<CRSASignature*>(sig));
		
		signature = sig->S().BufferLC();
		CleanupStack::Pop(signature);
	
		CleanupStack::PopAndDestroy(2, signer); // sig
		}
		break;
		
	default:
		User::Leave(KErrUnknown);
		break;
		}
	
	CleanupStack::PushL(signature);
	
	//Code to check VerifySignatureL()
	TBool expectedResult = ETrue;
	
	// security test - we may wish to munge the digest we pass to the method
	TBool tamperDigest(EFalse);
	GetBoolFromConfig(ConfigSection(), KTamperedDigest, tamperDigest); // ignore error
	
	if (tamperDigest)
		{
		expectedResult = EFalse;
		TRandom::RandomL(digest);
		}
	// now, invoke the verify signature method.
	TBool result = Provider()->VerifySignatureL(cert->PublicKey(), digest, *signature);
	
	if (result == expectedResult)
		{
		SetTestStepResult(EPass);
		}
	else
		{
		SetTestStepResult(EFail);
		}
		
	//now invoke the verify signature method with invalid params and ensure that it fails accordingly
		TRandom::RandomL(digest);
	result = Provider()->VerifySignatureL(cert->PublicKey(), digest, *signature);
			expectedResult = EFalse;
	if (result == expectedResult)
		{
		SetTestStepResult(EPass);
		}
	else
		{
		SetTestStepResult(EFail);
		}
	
	CleanupStack::PopAndDestroy(3, cert); // keyData, signature
	return TestStepResult();
	}