/*

* Copyright (c) 2004-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: 

*

*/

#include <e32uid.h>

#include "t_keystore_actions.h"

#include "t_keystore_defs.h"

#include "t_input.h"

#include <asn1enc.h>

#include <asn1dec.h>

#include <x509cert.h>

#include <x509keys.h>

#include <securityerr.h>

#ifdef SYMBIAN_AUTH_SERVER

#include <keystore_errs.h>

#include <authserver/auth_srv_errs.h>

#include <authserver/authclient.h>

#endif // SYMBIAN_AUTH_SERVER

static void TestKeyStorePanic(TKSPanicCode aPanicCode)

{

	_LIT(KTestKeyStorePanic, "TKeyStorePanic");

	User::Panic(KTestKeyStorePanic, aPanicCode);

}

//	CSharedKeyStores static singleton which maintains unfied key store instances

/*static*/ CSharedKeyStores* CSharedKeyStores::iTheKeyStores = NULL;

/*static*/ void CSharedKeyStores::InitialiseKeyStoresL()

{

	if (!iTheKeyStores)

	{

		iTheKeyStores = new (ELeave) CSharedKeyStores();

	}

}

/*static*/ void CSharedKeyStores::DestroyKeyStores()

{

	if (iTheKeyStores)

	{	

		delete iTheKeyStores;

		iTheKeyStores = NULL;

	}

}

/*static*/ RUnifiedKeyStoreArray& CSharedKeyStores::TheUnifiedKeyStores()

{

	return (iTheKeyStores->iUnifiedKeyStores);

}

CSharedKeyStores::~CSharedKeyStores()

{

	iUnifiedKeyStores.ResetAndDestroy();

	iUnifiedKeyStores.Close();

}

/////////////////////////////////////////////////////////////////////////////////

//CKeyStoreTestAction base class

/////////////////////////////////////////////////////////////////////////////////

CKeyStoreTestAction::~CKeyStoreTestAction()

	{

	delete iLabel;

	iExpectedDialogs.ResetAndDestroy();

	iKeys.Close();

#ifdef SYMBIAN_AUTH_SERVER	

	delete iAuthExpression;

#endif // SYMBIAN_AUTH_SERVER

	}

CKeyStoreTestAction::CKeyStoreTestAction(RFs& aFs, CConsoleBase& aConsole, Output& aOut) :

	CTestAction(aConsole, aOut), 

	iFs(aFs),

	iDisableCheckDialog(0),

	iKeyStoreImplIndex(0)

#ifdef SYMBIAN_AUTH_SERVER

	,iUseNewApi(EFalse),

	iFreshness(0)

#endif // SYMBIAN_AUTH_SERVER

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

	,iHardwareType(-1)

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

	{

	iFilter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

	}

void CKeyStoreTestAction::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	iExpectedResult = SetExpectedResultL(Input::ParseElement(aTestActionSpec.iActionResult, KReturnStart));

	TInt pos = 0;

	while (SetKeyUsageL(Input::ParseElement(aTestActionSpec.iActionBody, KKeyUsageStart, KKeyUsageEnd, pos)))

		/* do nothing */;

	SetKeyLabel(Input::ParseElement(aTestActionSpec.iActionBody, KKeyLabelStart));

	SetKeyAlgorithm(Input::ParseElement(aTestActionSpec.iActionBody, KKeyAlgorithmStart));

	SetKeyType(Input::ParseElement(aTestActionSpec.iActionBody, KOpenStart, KOpenEnd));

	pos = 0;

	while (SetKeyAccessType(Input::ParseElement(aTestActionSpec.iActionBody, KKeyAccessTypeStart, KKeyAccessTypeEnd, pos)))

		/* do nothing */;

	pos = 0;

	while (AddExpectedDialogL(Input::ParseElement(aTestActionSpec.iActionBody, KSecDlg, KSecDlgEnd, pos)))

		/* do nothing */;

	iKeystore = Input::ParseIntElement(aTestActionSpec.iActionBody, KKeystoreStart, KKeystoreEnd);

	iDisableCheckDialog = Input::ParseIntElement(aTestActionSpec.iActionBody, KDisableDialogStart, KDisableDialogEnd, pos);

	pos = 0;

#ifdef SYMBIAN_AUTH_SERVER

	TPtrC8 authExpr;

	TInt authExprPresent = KErrNone;

	authExpr.Set(Input::ParseElement(aTestActionSpec.iActionBody, KAuthExpressionStart, KAuthExpressionEnd, pos , authExprPresent));

	if(authExpr.Compare(_L8("null")) != 0)

		{

		TInt size = authExpr.Size();

		if (size != 0)

			{

			iAuthExpression = HBufC::NewMaxL(size);

			TPtr authExp(iAuthExpression->Des());

			authExp.FillZ();

			authExp.Copy(authExpr);

			}

		}

	TInt freshnessPresent = KErrNone;

	TInt negativeFreshness = Input::ParseIntElement(aTestActionSpec.iActionBody, KNegativeFreshnessStart, KNegativeFreshnessEnd);

	if(negativeFreshness == 1)

		{

		iFreshness = -1;

		}

	else

		{

		iFreshness = Input::ParseIntElement(aTestActionSpec.iActionBody, KFreshnessStart, KFreshnessEnd, pos, freshnessPresent);

		}

	if(authExprPresent == KErrNone && freshnessPresent == KErrNone)

		{

		iUseNewApi = ETrue;

		}

	iDeauthenticate = Input::ParseIntElement(aTestActionSpec.iActionBody, KAuthenticateStart, KAuthenticateEnd);

#endif // SYMBIAN_AUTH_SERVER

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

	iHardwareType = Input::ParseIntElement(aTestActionSpec.iActionBody, KHwTypeStart, KHwTypeEnd, pos);

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

	}

TBool CKeyStoreTestAction::AddExpectedDialogL(const TDesC8& aData)

	{

	if (aData.Length() == 0)

		return EFalse;

	HBufC* data = HBufC::NewMaxLC(aData.Length());

	TPtr ptr = data->Des();

	ptr.Copy(aData);

	User::LeaveIfError(iExpectedDialogs.Append(data));

	CleanupStack::Pop(data);

	return ETrue;

	}

void CKeyStoreTestAction::WriteExpectedDialogDataL()

	{

	CFileMan* fileMan = CFileMan::NewL(iFs);

	CleanupStack::PushL(fileMan);

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName sysDriveName (sysDrive.Name());

	TBuf<128> fileName (sysDriveName);

	fileName.Append(KTSecDlgOutputFile);

	TInt err = fileMan->Delete(fileName);

	if (err != KErrNotFound)

		User::LeaveIfError(err);

	fileName.Copy (sysDriveName);

	fileName.Append(KTSecDlgInputFile);

	err = fileMan->Delete(fileName);

	if (err != KErrNotFound)

		User::LeaveIfError(err);

	CleanupStack::PopAndDestroy(fileMan);

	RFileWriteStream stream;

	err = stream.Open(iFs, fileName, EFileWrite | EFileShareExclusive);

	if (err == KErrNotFound)

		{

		err = stream.Create(iFs, fileName, EFileWrite | EFileShareExclusive);

		}

	User::LeaveIfError(err);

	stream.PushL();

	for (TInt index = 0 ; index < iExpectedDialogs.Count() ; ++index)

		{		

		TLex lex(*iExpectedDialogs[index]);

		TPtrC token(lex.NextToken());

		if (token.Length() == 0)

			User::Leave(KErrCorrupt);

		if (token == KSecDlgImport)

			{

			TPtrC passphrase(lex.NextToken());

			if (passphrase.Length() == 0)

				User::Leave(KErrCorrupt);

			WriteDialogRecordL(stream, EEnterPIN, _L("Passphrase of the imported key file"), passphrase, KNullDesC);

			}

		else if (token == KSecDlgExport)

			{

			TPtrC passphrase(lex.NextToken());

			if (passphrase.Length() == 0)

				User::Leave(KErrCorrupt);

			WriteDialogRecordL(stream, EEnterPIN, _L("Passphrase of the exported key file"), passphrase, KNullDesC);			

			}

		else if (token == KSecDlgChange)

			{

			TPtrC oldPassphrase(lex.NextToken());

			if (oldPassphrase.Length() == 0)

				User::Leave(KErrCorrupt);

			TPtrC newPassphrase(lex.NextToken());

			if (newPassphrase.Length() == 0)

				User::Leave(KErrCorrupt);

			WriteDialogRecordL(stream, EChangePIN, KNullDesC, oldPassphrase, newPassphrase);

			}

		else if (token == KSecDlgCreate)

			{

			TPtrC passphrase(lex.NextToken());

			if (passphrase.Length() == 0)

				User::Leave(KErrCorrupt);

			WriteDialogRecordL(stream, EEnterPIN, _L("New key store passphrase"), passphrase, KNullDesC);

			}

		else

			{

			WriteDialogRecordL(stream, EEnterPIN, _L("Key store passphrase"), token, KNullDesC);

			}

		}

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

	}

void CKeyStoreTestAction::WriteDialogRecordL(RFileWriteStream& aStream, TSecurityDialogOperation aOp, const TDesC& aLabelSpec,

											 const TDesC& aResponse1, const TDesC& aResponse2)

	{

	MStreamBuf* streamBuf = aStream.Sink();

	streamBuf->SeekL(MStreamBuf::EWrite, EStreamEnd);

	aStream.WriteInt32L(aOp);

	aStream.WriteInt32L(aLabelSpec.Length());

	aStream.WriteL(aLabelSpec);

	aStream.WriteInt32L(aResponse1.Length());

	aStream.WriteL(aResponse1);

	aStream.WriteInt32L(aResponse2.Length());

	aStream.WriteL(aResponse2);

	}

TInt CKeyStoreTestAction::ReadDialogCountL()

	{

	RFileReadStream stream;

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TBuf<128> secDlgOutputFile (sysDrive.Name());

	secDlgOutputFile.Append(KTSecDlgOutputFile);

	TInt err = stream.Open(iFs, secDlgOutputFile, EFileRead);

	// If the file doesn't exist yet just return zero

	if (err == KErrNotFound)

		{

		return 0;

		}

	User::LeaveIfError(err);

	stream.PushL();

	TInt index = stream.ReadInt32L();

	CleanupStack::PopAndDestroy(); // stream

	return index;

	}

TInt CKeyStoreTestAction::SetExpectedResultL(const TDesC8& aResult)

{

	if (aResult==KErrNoneString)

		return (KErrNone);

	else if (aResult==KErrAccessDeniedString)

		return (KErrAccessDenied);

	else if (aResult==KErrAlreadyExistsString)

		return (KErrAlreadyExists);

	else if (aResult==KErrInUseString)

		return (KErrInUse);

	else if (aResult==KErrNotFoundString)

		return (KErrNotFound);

	else if (aResult==KErrBadNameString)

		return (KErrBadName);

	else if (aResult==KErrArgumentString)

		return (KErrArgument);

	else if (aResult==KErrNotReadyString)

		return (KErrNotReady);

	else if (aResult==KErrCancelString)

		return (KErrCancel);

	else if (aResult==KErrCorruptString)

		return (KErrCorrupt);

	else if (aResult==KErrNotSupportedString)

		return (KErrNotSupported);

	else if (aResult==KErrOverflowString)

		return (KErrOverflow);

	else if (aResult==KErrBadPassphraseString)

		return (KErrBadPassphrase);

	else if (aResult==KErrGeneralString)

		return (KErrGeneral);

	else if (aResult==KErrKeyAlgorithmString)

		return KErrKeyAlgorithm;

	else if (aResult==KErrKeyUsageString)

		return KErrKeyUsage;

	else if (aResult==KErrKeyValidityString)

		return KErrKeyValidity;

	else if (aResult==KErrKeySizeString)

		return KErrKeySize;

	else if (aResult==KErrKeyAccessString)

		return KErrKeyAccess;

	else if (aResult==KErrPrivateKeyNotFoundString) 

		return KErrPrivateKeyNotFound;

	else if (aResult==KErrPermissionDeniedString)

		return KErrPermissionDenied;

	else if (aResult==KErrNoMemoryString)

			return KErrNoMemory;

#ifdef SYMBIAN_AUTH_SERVER

	else if (aResult==KErrAuthFailureString)

		return KErrAuthenticationFailure;

	else if (aResult==KErrUnknownAuthStrengthAliasString)

		return KErrUnknownAuthStrengthAlias;

#endif // SYMBIAN_AUTH_SERVER

	else

		{

		iOut.writeString(_L("Unknown expected result: "));

		iOut.writeString(aResult);

		iOut.writeNewLine();

		User::Leave(KErrNotFound);

		return KErrNotFound; // Keep compiler happy 

		}

}

TBool CKeyStoreTestAction::SetKeyUsageL(const TDesC8& aKeyUsage)

	{

	if (aKeyUsage.Length() == 0)

		return EFalse;

	TBool ret = ETrue;

	if (aKeyUsage.Compare(KAllKeyUsages)==0)

		iUsage = EPKCS15UsageAll;

	else if (aKeyUsage.Compare(KKeyUsageNone)==0)

		iUsage = EPKCS15UsageNone;

	else if (aKeyUsage.Compare(KAllKeyUsagesExceptNR)==0)

		iUsage |= EPKCS15UsageSign | EPKCS15UsageSignRecover | EPKCS15UsageDecrypt;

	else if (aKeyUsage.Compare(KDSAUsage)==0)

		iUsage |= EPKCS15UsageSign | EPKCS15UsageSignRecover;

	else if (aKeyUsage.Compare(KEncryptUsage)==0)

		iUsage |= EPKCS15UsageEncrypt;

	else if (aKeyUsage.Compare(KDecryptUsage)==0)

		iUsage |= EPKCS15UsageDecrypt;

	else if (aKeyUsage.Compare(KSignUsage)==0)

		iUsage |= EPKCS15UsageSign;

	else if (aKeyUsage.Compare(KSignRecoverUsage)==0)

		iUsage |= EPKCS15UsageSignRecover;

	else if (aKeyUsage.Compare(KWrapUsage)==0)

		iUsage |= EPKCS15UsageWrap;

	else if (aKeyUsage.Compare(KUnwrapUsage)==0)

		iUsage |= EPKCS15UsageUnwrap;

	else if (aKeyUsage.Compare(KVerifyUsage)==0)

		iUsage |= EPKCS15UsageVerify;

	else if (aKeyUsage.Compare(KVerifyRecoverUsage)==0)

		iUsage |= EPKCS15UsageVerifyRecover;

	else if (aKeyUsage.Compare(KDeriveUsage)==0)

		iUsage |= EPKCS15UsageDerive;

	else if (aKeyUsage.Compare(KNR)==0)

		iUsage |= EPKCS15UsageNonRepudiation;

	else

		{

		iOut.writeString(_L("Unknown key usage: "));

		iOut.writeString(aKeyUsage);

		iOut.writeNewLine();		

		User::Leave(KErrNotFound);

		}

	return ret;

	}

void CKeyStoreTestAction::SetKeyLabel(const TDesC8& aKeyLabel)

{

	iLabel = HBufC::NewMax(aKeyLabel.Size());

	if (iLabel)

	{

		TPtr theLabel(iLabel->Des());

		theLabel.FillZ();

		theLabel.Copy(aKeyLabel);

	}

}

void CKeyStoreTestAction::SetKeyAlgorithm(const TDesC8& aKeyAlgorithm)

{

	if (aKeyAlgorithm.Compare(KAlgRSA)==0)

	{

		iAlgorithm = CCTKeyInfo::ERSA;

	}

	else if (aKeyAlgorithm.Compare(KAlgDSA)==0)

	{

		iAlgorithm = CCTKeyInfo::EDSA;

	}

	else if (aKeyAlgorithm.Compare(KAlgDH)==0)

	{

		iAlgorithm = CCTKeyInfo::EDH;

	}

	else if (aKeyAlgorithm.Compare(KAlgBAD)==0)

	{

		iAlgorithm = static_cast<CCTKeyInfo::EKeyAlgorithm>(-1);

	}

	else

	{

		iAlgorithm = CCTKeyInfo::EInvalidAlgorithm;

	}

}

TBool CKeyStoreTestAction::SetKeyAccessType(const TDesC8& aKeyAccessType)

	{

	TBool ret = ETrue;

	if (aKeyAccessType.Compare(KExtractable)==0)

		{

		iAccessType |= CCTKeyInfo::EExtractable;

		}

	else if (aKeyAccessType.Compare(KSensitive)==0)

		{

		iAccessType |= CCTKeyInfo::ESensitive;

		}

	else if (aKeyAccessType.Compare(KAlwaysSensitive)==0)

		{

		iAccessType |= CCTKeyInfo::EAlwaysSensitive;

		}

	else if (aKeyAccessType.Compare(KNeverExtractable)==0)

		{

		iAccessType |= CCTKeyInfo::ENeverExtractable;

		}

	else if (aKeyAccessType.Compare(KLocal)==0)

		{

		iAccessType |= CCTKeyInfo::ELocal;

		}

	else

		ret = EFalse;

	return ret;

	}

void CKeyStoreTestAction::SetKeyStoreIndex(CUnifiedKeyStore* aUnifiedKeyStore)

	{

	TInt keyStoreCount = aUnifiedKeyStore->KeyStoreManagerCount();

	for(int index = 0 ; index<keyStoreCount; ++index)

		{

		MCTKeyStoreManager& mctKeyStoreMngr = aUnifiedKeyStore->KeyStoreManager(index);

		const TDesC16& label = mctKeyStoreMngr.Token().Label();

		TBuf<50> keyStoreLabel;

		keyStoreLabel.Copy(iKeyStoreImplLabel);

		if(label.Compare(keyStoreLabel) == 0 )

			{

			iKeyStoreImplIndex = index;

			break;

			}

		}

	}