/*

* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Implements PKCS#10 certificate request class.

*

*/

#include <pkcs10.h>

#include <asn1enc.h>

#include <e32std.h>

#include <e32def.h>

#include <x500dn.h>

#include <x509keys.h>

#include <hash.h>

#include <pkcs10attr.h>

#include "keyhelper.h"

#include <mctkeystoreuids.h>

void Panic(TInt aError)

	{

	_LIT(KCategory, "PKCS10");

	User::Panic(KCategory, aError);

	}

// CPKCS10Request Class Implementation

CPKCS10Request::CPKCS10Request(const CX500DistinguishedName* aDN,

							   const CCTKeyInfo* aKeyInfo,

							   CPKCS10Attributes* aAttr) :

	CActive(EPriorityNormal),

	iDN(aDN),

	iKeyInfo(aKeyInfo),

	iAttributes(aAttr),

	iDigestId(ESHA1)

	{

	CActiveScheduler::Add(this);

	}

EXPORT_C CPKCS10Request* CPKCS10Request::NewLC(const CX500DistinguishedName& aDN,

											   const CCTKeyInfo& aKeyInfo,

											   CPKCS10Attributes* aAttr/* = NULL*/)

	{

	// Sanity Check the input parameters

	if (&aDN == NULL)

		{

		User::Leave(KErrArgument);

		}

	if (&aKeyInfo == NULL)

		{

		User::Leave(KErrArgument);

		}

	CPKCS10Request* self = new (ELeave) CPKCS10Request(&aDN, &aKeyInfo, aAttr);

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CPKCS10Request* CPKCS10Request::NewL(const CX500DistinguishedName& aDN,

											  const CCTKeyInfo& aKeyInfo,

											  CPKCS10Attributes* aAttr/* = NULL*/)

	{

	CPKCS10Request* self = NewLC(aDN, aKeyInfo, aAttr);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CPKCS10Request::~CPKCS10Request()

	{

	Cancel();

	delete iAttributes;

	Reset();

	}

void CPKCS10Request::Reset()

	{

	delete iExportedKey;

	iExportedKey = NULL;

	delete iTBSData;

	iTBSData = NULL;

	delete iKeyHelper;

	iKeyHelper = NULL;

	if (iKeyStore)

		{

		iKeyStore->Release();

		iKeyStore = NULL;

		}

	iState = EIdle;

	}

EXPORT_C void CPKCS10Request::SetDistinguishedNameL(const CX500DistinguishedName& aDN)

	{

	// Sanity check

	if (&aDN == NULL)

		{

		User::Leave(KErrArgument);

		}

	iDN = &aDN;

	}

EXPORT_C void CPKCS10Request::SetKeyInfoL(const CCTKeyInfo& aKeyInfo)

	{

	// Sanity check

	if (&aKeyInfo == NULL)

		{

		User::Leave(KErrArgument);

		}

	iKeyInfo = &aKeyInfo;

	}

EXPORT_C void CPKCS10Request::SetAttributes(CPKCS10Attributes* aAttr)

	{

	delete iAttributes;

	iAttributes = aAttr;

	}

EXPORT_C void CPKCS10Request::SetDigestAlgL(TAlgorithmId aDigestId)

	{

	if (aDigestId != EMD2 && aDigestId != EMD5 && aDigestId != ESHA1)

		{

		User::Leave(KErrArgument);

		}

	if (iKeyInfo->Algorithm() == CCTKeyInfo::EDSA && aDigestId != ESHA1)

		{

		User::Leave(KErrArgument);

		}

	iDigestId = aDigestId;

	}

EXPORT_C void CPKCS10Request::CreateEncoding(HBufC8*& aResult, TRequestStatus& aStatus)

	{

	ASSERT(iState == EIdle);	

	iClientStatus = &aStatus;

	iResult = &aResult;

	aResult = NULL;	

	aStatus = KRequestPending;

	iState = EInitialize;

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

TInt CPKCS10Request::RunError(TInt aErr)

	{

    User::RequestComplete(iClientStatus, aErr);

	iState = EIdle;

    return KErrNone;

	}

void CPKCS10Request::DoCancel()

	{

	switch (iState)

		{

		case EGetKeyStore:

			iKeyInfo->Token().CancelGetInterface();

			break;

		case EGetPublicKey:

			iKeyStore->CancelExportPublic();

			break;

		case EOpenSigner:

			iKeyHelper->CancelOpenSigner();

			break;

		case ESign:

			iKeyHelper->CancelSignDigest();

			break;

		default:

			// do nothing, keep compiler happy

			break;			

		}

	if (iClientStatus)

		User::RequestComplete(iClientStatus, KErrCancel);

	iState = EIdle;

	}	

void CPKCS10Request::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	switch (iState)

		{

		case EInitialize:

			// Get keystore interface

			if (iKeyStore)

				{

				iKeyStore->Release();

				iKeyStore = NULL;

				}

			iKeyInfo->Token().GetInterface(TUid::Uid(KInterfaceKeyStore),

										  *reinterpret_cast<MCTTokenInterface**>(&iKeyStore),

										  iStatus);

			iState = EGetKeyStore;

			SetActive();

			break;

		case EGetKeyStore:

			// Fetch the public key

			delete iExportedKey;

			iKeyStore->ExportPublic(*iKeyInfo, iExportedKey, iStatus);

			iState = EGetPublicKey;

			SetActive();

			break;

		case EGetPublicKey:

			// Create key helper object

			delete iKeyHelper;

			iKeyHelper = CPKCS10KeyHelper::CreateKeyHelperL(*iKeyStore, *iKeyInfo, *iExportedKey, iDigestId);

			EncodeTBSDataL();

			// Open signing object

			iKeyHelper->OpenSigner(iStatus);

			iState = EOpenSigner;

			SetActive();

			break;

		case EOpenSigner:

			// Create digest

			{

			CMessageDigest* digest = NULL;

			switch (iDigestId)

				{

				case EMD2:

					digest = CMD2::NewL();

					break;

				case EMD5:

					digest = CMD5::NewL();

					break;

				case ESHA1:

					digest = CSHA1::NewL();

					break;

				default:

					User::Invariant();

				}

			CleanupStack::PushL(digest);

			// Hash data and sign

			digest->Update(*iTBSData);

			iKeyHelper->SignDigestL(digest->Final(), iStatus);

			CleanupStack::PopAndDestroy(digest); // keystore copies data to be signed

			iState = ESign;

			SetActive();

			}

			break;

		case ESign:

			CreateFinalEncodingL();

			Reset();

			break;

		default:

			User::Invariant();

		}

	}

CASN1EncBase* CPKCS10Request::MakeAttrEncLC() 

	{

	if (iAttributes)

		{

		CASN1EncBase* result = iAttributes->TakeEncodingLC();

		delete iAttributes;

		iAttributes = NULL;

		return result;

		}

	else

		{

		CASN1EncSequence* contextSpecific = CASN1EncSequence::NewLC();

		contextSpecific->SetTag(0);

		return contextSpecific;

		}

	}

CASN1EncSequence* CPKCS10Request::MakeCertRequestInfoEncLC()

	{

	// Top-level sequence contains distinguished name and other 

	// stuff. This is what gets signed with the entity's private key.

	CASN1EncSequence* certRequestInfo = CASN1EncSequence::NewLC();

	// Encode version number, which is 0.

	CASN1EncInt* version = CASN1EncInt::NewLC(0);

	certRequestInfo->AddAndPopChildL(version);

	// Encode distinguished name.

	CASN1EncBase* distinguishedName = iDN->EncodeASN1LC();

	certRequestInfo->AddAndPopChildL(distinguishedName);

	// Encode SubjectPublicKeyInfo.

	CASN1EncBase* subjectPubKeyInfo = iKeyHelper->EncodeKeyLC();

	certRequestInfo->AddAndPopChildL(subjectPubKeyInfo);

	// Encode attributes, if any.

	CASN1EncBase* attr = MakeAttrEncLC();

	certRequestInfo->AddAndPopChildL(attr);

	return certRequestInfo;

	}

void CPKCS10Request::EncodeTBSDataL() 

	{

	// The data we provide for signing is the certRequestInfo object.

	CASN1EncBase* certRequestInfo = MakeCertRequestInfoEncLC();

	// Write DER of it to the buffer.

	delete iTBSData;

	iTBSData = HBufC8::NewMaxL(certRequestInfo->LengthDER());

	TPtr8 dataPtr = iTBSData->Des();

	TUint pos = 0;

	certRequestInfo->WriteDERL(dataPtr, pos);

	CleanupStack::PopAndDestroy(certRequestInfo);

	}

void CPKCS10Request::CreateFinalEncodingL()

	{

	// the root sequence contains all other components of a X509 signed object

	CASN1EncSequence* root = CASN1EncSequence::NewLC();

	// wrap data to be signed in a sequence and add it to the root

	CASN1EncEncoding* encenc = CASN1EncEncoding::NewLC(*iTBSData);

	root->AddAndPopChildL(encenc);

	// encode signature algorithm and  parameters and add them to the root

	CASN1EncSequence* sigalg = iKeyHelper->EncodeSignatureAlgorithmLC();

	root->AddAndPopChildL(sigalg);

	// Create ASN.1 bit string from the signature 

	CASN1EncBitString* encSig = iKeyHelper->EncodeSignatureLC();

	root->AddAndPopChildL(encSig);

	// encode the object in a DER encoding

	HBufC8* der = HBufC8::NewMaxLC(root->LengthDER());

	TPtr8 pder(der->Des());

	TUint pos = 0;

	root->WriteDERL(pder, pos);

	CleanupStack::Pop(der);

	CleanupStack::PopAndDestroy(root);

	*iResult = der;

	User::RequestComplete(iClientStatus, KErrNone);

	}