/*

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

*

*/

/**

 @file

 @internalComponent

*/

#include <cryptospi/cryptospidef.h>

#include <bacline.h>

#include <cryptospi/cryptocharacteristics.h>

#include <cryptospi/cryptospistateapi.h>

#include "dumpprocessor.h"

#include <cryptospi/cryptoparams.h>

#include <cryptospi/extendedcharacteristics.h>

#include <e32cons.h>

#include <f32file.h>

using namespace CryptoSpi;

//

//The name of characteristics log file

//

_LIT(KLogStartMessage, "DumpCryptoSpiTool");

const TInt KMaxLineLength = 1024;

_LIT8(KNewLine8, "\r\n");

//

//Characteristic Heads

//

_LIT(KLogHashCharacteristicHead, "[HashCharacteristic]");

_LIT(KLogRandomCharacteristicHead, "[RandomCharacteristic]");

_LIT(KLogSymmetricCipherCharacteristicHead, "[SymmetricCipherCharacteristic]");

_LIT(KLogAsymmetricCipherCharacteristicHead, "[AsymmetricCipherCharacteristic]");

_LIT(KLogSignerCharacteristicHead, "[SignerCharacteristic]");

_LIT(KLogVerifierCharacteristicHead, "[VerifierCharacteristic]");

_LIT(KLogKeyAgreementCharacteristicHead, "[KeyAgreementCharacteristic]");

_LIT(KLogKeypairGeneratorCharacteristicHead, "[KeypairGeneratorCharacteristic]");

_LIT(KLogUnknownCharacteristicHead, "[UnknownCharacteristic]");

//

//bool and unknow

//

_LIT(KLogBoolTrue, "True");

_LIT(KLogBoolFalse, "False");

_LIT(KLogUnknown, "Unknown");

//Common Characteristics

_LIT(KLogInterfaceName, "	InterfaceName = %S");

_LIT(KLogAlgorithmUid, "	AlgorithmUid = 0x%x");

_LIT(KLogImplementationUid, "	ImplementationUid = 0x%x");

_LIT(KLogCreatorName, "	CreatorName = %S");

_LIT(KLogFIPSApproved, "	FIPSApproved = %S");

_LIT(KLogHardwareImplementation, "	HardwareImplementation = %S");

_LIT(KLogAlgorithmName, "	AlgorithmName = %S");

_LIT(KLogMaxConcurrency, "	MaxConcurrency = %d");

_LIT(KLogLatency, "	Latency = %d");

_LIT(KLogThroughput, "	Throughput = %d");

//Hash Characteristics

_LIT(KLogBlockSize, "	BlockSize = %d");

_LIT(KLogOutputSize, "	OutputSize = %d");

//Random Characteristics

_LIT(KLogBlockMode, "	BlockMode = %d");

//Symmetric Cipher Characteristics

_LIT(KLogMaximumKeyLength, "	MaximumKeyLength = %d");

_LIT(KLogKeySupportMode, "	KeySupportMode = %d");

//Plugin Dll Name

_LIT(KDllName, "	PluginDllName = %S");

//Extended characteristics

_LIT(KLogExtendedCharacteristicInt, "	Ext[0x%x] = 0x%x");

_LIT(KLogExtendedCharacteristicDes, "	Ext[0x%x] = %S");

_LIT8(KLogExtendedCharacteristicDes8, "	Ext[0x%x] = %S");

//padding modes definitions	

_LIT(KLogPaddingModes1, "	SupportedPaddingModes_%d = %S");

_LIT(KLogPaddingModeNone, "NoneMode");

_LIT(KLogPaddingModeSSLv3, "SSLv3Mode");

_LIT(KLogPaddingModePKCS7, "PKCS7Mode");

_LIT(KLogPaddingModePkcs1_v1_5_Encryption, "Pkcs1_v1_5_EncryptionMode");

_LIT(KLogPaddingModePkcs1_v1_5_Signature, "Pkcs1_v1_5_SignatureMode");

//Symmetric cipher operation modes definitions

_LIT(KLogOperationModeNone, "NoneMode");

_LIT(KLogOperationModeECB, "ECBMode");

_LIT(KLogOperationModeCBC, "CBCMode");

_LIT(KLogOperationModeOFB, "OFBMode");

_LIT(KLogOperationModeCFB, "CFBMode");

_LIT(KLogOperationModeCTR, "CTRMode");

//Hash modes definitions

_LIT(KLogOperationModes1, "	SupportedOperationModes_%d = %S");

_LIT(KLogOperationModeHash, "HashMode");

_LIT(KLogOperationModeHmac, "HmacMode");

//Help text

_LIT(KUsage, "Usage: dumpcryptoplugin [switches] \n");

_LIT(KHelpInterface, "-interface/-i <interface name>	Dump characteristics for the interface, which can be\n");

_LIT(KHelpInterface1, "				hash,random,symcipher,asymcipher,signer,verifier,\n");

_LIT(KHelpInterface2, "				keypairgen,keyagree,asynchash,asyncrandom,asyncsymcipher\n");

_LIT(KHelpInterface3, "				asyncsigner,asyncverifier,asynckeypairgen,asynckeyagree.\n");

_LIT(KHelpAlgorithm, "-algorithm/-al <algorithm name>	Dump characteristics for the algorithm, which can be\n");

_LIT(KHelpAlgorithm1, "				md2,md4,md5,sha1,des,3des,rc2,aes,rc4,rsacipher,rsasigner\n");

_LIT(KHelpAlgorithm2, "				rsaverifier,rsakeypair,dsasigner,dsaverifier,dsakeypair\n");

_LIT(KHelpAlgorithm3, "				dhkeypair,dhkeyagree.\n");

_LIT(KHelpAll, "-all/-a				Dump all the characteristics of all the inplementations.\n");

_LIT(KHelpExtended, "-extended/-e			Dump the extended characteristics as well.\n");

_LIT(KHelpDll, "-dll/-d	<filename>		Only dump the characteristics for the given plugin Dll.\n");

_LIT(KHelpOutput, "-out/-o	<drive:><path><filename>Output file name.\n");

_LIT(KHelpHelp, "-help/-h			Help\n");

_LIT(KProgessStatus, "Progressing\n");

_LIT(KFileStatus, "Dump to %S");

_LIT(KInvalidArgument, "Invalid Argument:");

_LIT(KArgument, " %S");

//

//Implementation of CDumpToolParameters

//

CDumpToolParameters* CDumpToolParameters::NewLC()

	{

	CDumpToolParameters* self=new(ELeave) CDumpToolParameters();

	CleanupStack::PushL(self);

	return self;		

	}

CDumpToolParameters::~CDumpToolParameters()

	{

	iOptions.Close();

	iInvalidOptions.ResetAndDestroy();

	}

CDumpToolParameters::CDumpToolParameters()

	{

	}

TBool CDumpToolParameters::FindOption(TOption aOption) const

	{

	TBool found=EFalse;

	TInt count=iOptions.Count();

	for (TInt i=0;i<count;i++)

		{

		if (aOption==iOptions[i])

			{

			found=ETrue;

			break;	

			}

		}

	return found;

	}

//

//Implementation of CDumpToolProcessor

//

CDumpToolProcessor* CDumpToolProcessor::NewLC(const CDumpToolParameters& aParams, CConsoleBase* aConsole)

	{

	CDumpToolProcessor* self=new(ELeave) CDumpToolProcessor(aParams, aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;		

	}

CDumpToolProcessor::~CDumpToolProcessor()

	{

	iLogFile.Close();

	iFs.Close();

	iCharacters.ResetAndDestroy();	

	}

CDumpToolProcessor::CDumpToolProcessor(const CDumpToolParameters& aParams, CConsoleBase* aConsole)

: iInputParams(aParams), iConsole(aConsole)

	{

	}

void CDumpToolProcessor::ConstructL()

	{

	User::LeaveIfError(iFs.Connect());

	if (iInputParams.iDumpFileName.CompareF(KNullDesC)==0)

		{

		TUint driveCh(RFs::GetSystemDriveChar());

		_LIT(KDumpFileNameFmt, "%c:\\dumpcrypoplugin.txt");

		iDumpFileName.Format(KDumpFileNameFmt, driveCh);

		}

	else

		{

		TInt pos=iInputParams.iDumpFileName.LocateReverseF('\\');

		TFileName path=iInputParams.iDumpFileName.Left(pos+1);

		TInt ret=iFs.MkDirAll(path);

		if (ret!=KErrNone && ret!=KErrAlreadyExists)

			{

			User::LeaveIfError(ret);	

			}

		iDumpFileName=iInputParams.iDumpFileName;

		}

	User::LeaveIfError(iLogFile.Replace(iFs, iDumpFileName, EFileWrite | EFileShareExclusive));

	TBool extended=EFalse;

	if (iInputParams.FindOption(CDumpToolParameters::EOptionExtendedCharacteristic))

		{

		extended=ETrue;

		}

	CCryptoSpiStateApi::EnumerateCharacteristicsL(iCharacters, iInputParams.iInterface, extended);

	}

void CDumpToolProcessor::ProcessL()

	{

	if (iInputParams.FindOption(CDumpToolParameters::EOptionHelp))

		{

		DisplayHelp();

		return;	

		}

	if (iInputParams.iInvalidOptions.Count()!=0 )

		{

		DisplayInvalidOptions();

		return;

		}

	LogL(KLogStartMessage);

	TInt count=iCharacters.Count();

	iConsole->Printf(KProgessStatus);

	for (TInt i=0;i<count;i++)

		{

		if (iInputParams.iAlgorithm!=0 

			&& iInputParams.iAlgorithm!=iCharacters[i]->iCharacteristic->iAlgorithmUid)

			{

			continue;

			}

		if (iInputParams.iDllName.Compare(KNullDesC)!=0

			&&iInputParams.iDllName.Compare(iCharacters[i]->iDllName)!=0)

			{

			continue;

			}

		OutputCharcteristicsAndDllL(*iCharacters[i]);

		}

	iConsole->Printf(KFileStatus, &iDumpFileName);

	}

void CDumpToolProcessor::OutputCharacteristicHeadL(TInt32 aInterfaceUid)

	{

	LogL(KNewLine8);

	switch (aInterfaceUid)

		{

	case KHashInterface:

	case KAsyncHashInterface:

		LogL(KLogHashCharacteristicHead);

		break;

	case KRandomInterface:

	case KAsyncRandomInterface:

		LogL(KLogRandomCharacteristicHead);

		break;

	case KSymmetricCipherInterface:

	case KAsyncSymmetricCipherInterface:

		LogL(KLogSymmetricCipherCharacteristicHead);

		break;

	case KAsymmetricCipherInterface:

	case KAsyncAsymmetricCipherInterface:

		LogL(KLogAsymmetricCipherCharacteristicHead);

		break;

	case KSignerInterface:

	case KAsyncSignerInterface:

		LogL(KLogSignerCharacteristicHead);

		break;

	case KVerifierInterface:

	case KAsyncVerifierInterface:

		LogL(KLogVerifierCharacteristicHead);

		break;

	case KKeyAgreementInterface:

	case KAsyncKeyAgreementInterface:

		LogL(KLogKeyAgreementCharacteristicHead);

		break;

	case KKeypairGeneratorInterface:

	case KAsyncKeypairGeneratorInterface:

		LogL(KLogKeypairGeneratorCharacteristicHead);

		break;

	default:

		LogL(KLogUnknownCharacteristicHead);

		}

	}

void CDumpToolProcessor::OutputInterfaceNameL(TInt32 aInterfaceUid)

	{

	switch (aInterfaceUid)

		{

	case KHashInterface:

		LogL(KLogInterfaceName, &KHash);

		break;

	case KAsyncHashInterface:

		LogL(KLogInterfaceName, &KAsyncHash);

		break;

	case KRandomInterface:

		LogL(KLogInterfaceName, &KRandom);

		break;

	case KAsyncRandomInterface:

		LogL(KLogInterfaceName, &KAsyncRandom);

		break;

	case KSymmetricCipherInterface:

		LogL(KLogInterfaceName, &KSymmetricCipher);

		break;

	case KAsyncSymmetricCipherInterface:

		LogL(KLogInterfaceName, &KAsyncSymmetricCipher);

		break;

	case KAsymmetricCipherInterface:

		LogL(KLogInterfaceName, &KAsymmetricCipher);

		break;

	case KAsyncAsymmetricCipherInterface:

		LogL(KLogInterfaceName, &KAsyncAsymmetricCipher);

		break;

	case KSignerInterface:

		LogL(KLogInterfaceName, &KSigner);

		break;

	case KAsyncSignerInterface:

		LogL(KLogInterfaceName, &KAsyncSigner);

		break;

	case KVerifierInterface:

		LogL(KLogInterfaceName, &KVerifier);

		break;

	case KAsyncVerifierInterface:

		LogL(KLogInterfaceName, &KAsyncVerifier);

		break;

	case KKeyAgreementInterface:

		LogL(KLogInterfaceName, &KKeyAgreement);

		break;

	case KAsyncKeyAgreementInterface:

		LogL(KLogInterfaceName, &KAsyncKeyAgreement);

		break;

	case KKeypairGeneratorInterface:

		LogL(KLogInterfaceName, &KKeyPairGenerator);

		break;

	case KAsyncKeypairGeneratorInterface:

		LogL(KLogInterfaceName, &KAsyncKeyPairGenerator);

		break;

	default:

		LogL(KLogInterfaceName, &KLogUnknown);

		}		

	}

void CDumpToolProcessor::OutputAlgorithmNameL(TInt32 aAlgorithmUid)

	{

	switch (aAlgorithmUid)

		{

	case KAlgorithmHashMd2:

		LogL(KLogAlgorithmName, &KMd2);

		break;

	case KAlgorithmHashMd4:

		LogL(KLogAlgorithmName, &KMd4);

		break;		

	case KAlgorithmHashMd5:

		LogL(KLogAlgorithmName, &KMd5);

		break;

	case KAlgorithmHashSha1:

		LogL(KLogAlgorithmName, &KSha1);

		break;

	case KAlgorithmCipherDes:

		LogL(KLogAlgorithmName, &KDes);	

		break;

	case KAlgorithmCipher3Des:

		LogL(KLogAlgorithmName, &K3Des);	

		break;

	case KAlgorithmCipherRc2:

		LogL(KLogAlgorithmName, &KRC2);	

		break;

	case KAlgorithmCipherAes:

		LogL(KLogAlgorithmName, &KAes);	

		break;

	case KAlgorithmCipherArc4:

		LogL(KLogAlgorithmName, &KRC4);	

		break;

	case KAlgorithmCipherRsa:

		LogL(KLogAlgorithmName, &KRsaCipher);	

		break;

	case KAlgorithmSignerRsa:

		LogL(KLogAlgorithmName, &KRsaSigner);	

		break;

	case KAlgorithmVerifierRsa:

		LogL(KLogAlgorithmName, &KRsaVerifier);	

		break;

	case KAlgorithmRSAKeyPairGenerator:

		LogL(KLogAlgorithmName, &KRsaKeyPair);	

		break;

	case KAlgorithmSignerDsa:

		LogL(KLogAlgorithmName, &KDsaSigner);	

		break;

	case KAlgorithmVerifierDsa:

		LogL(KLogAlgorithmName, &KDsaVerifier);	

		break;

	case KAlgorithmDSAKeyPairGenerator:

		LogL(KLogAlgorithmName, &KDsaKeyPair);	

		break;

	case KAlgorithmDHKeyPairGenerator:

		LogL(KLogAlgorithmName, &KDhKeyPair);	

		break;

	case KAlgorithmKeyAgreementDH:

		LogL(KLogAlgorithmName, &KDhKeyAgreement);	

		break;

	default:;

		}

	}

void CDumpToolProcessor::OutputHashOperationModeL(TInt aIndex, TInt32 aOperationMode)

	{

	switch(aOperationMode)

		{

	case KHashMode:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeHash);

		break;

	case KHmacMode:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeHmac);

		break;

	default:;

		}

	}

void CDumpToolProcessor::OutputSymmetricOperationModeL(TInt aIndex, TInt32 aOperationMode)

	{

	switch(aOperationMode)

		{

	case KOperationModeNone:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeNone);

		break;

	case KOperationModeECB:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeECB);

		break;

	case KOperationModeCBC:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeCBC);

		break;

	case KOperationModeOFB:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeOFB);

		break;

	case KOperationModeCFB:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeCFB);

		break;

	case KOperationModeCTR:

		LogL(KLogOperationModes1, aIndex, &KLogOperationModeCTR);

		break;		

	default:;

		}	

	}

void CDumpToolProcessor::OutputPaddingModeL(TInt aIndex, TInt32 aPaddingMode)

	{

	switch(aPaddingMode)

		{

	case KPaddingModeNone:

		LogL(KLogPaddingModes1, aIndex, &KLogPaddingModeNone);

		break;

	case KPaddingModeSSLv3:

		LogL(KLogPaddingModes1, aIndex, &KLogPaddingModeSSLv3);

		break;

	case KPaddingModePKCS7:

		LogL(KLogPaddingModes1, aIndex, &KLogPaddingModePKCS7);

		break;

	case KPaddingModePkcs1_v1_5_Encryption:

		LogL(KLogPaddingModes1, aIndex, &KLogPaddingModePkcs1_v1_5_Encryption);

		break;

	case KPaddingModePkcs1_v1_5_Signature:

		LogL(KLogPaddingModes1, aIndex, &KLogPaddingModePkcs1_v1_5_Signature);

		break;

	default:;

		}		

	}

void CDumpToolProcessor::OutputSpecificCharacteristicL(const CCharacteristics& aCharacter)

	{

	switch (aCharacter.iInterfaceUid)

		{

	case KHashInterface:

	case KAsyncHashInterface:

		{

		const CHashCharacteristics& sCharacter=static_cast<const CHashCharacteristics&>(aCharacter);

		LogL(KLogBlockSize, sCharacter.iBlockSize);

		LogL(KLogOutputSize, sCharacter.iOutputSize);

		TInt count=sCharacter.iSupportedOperationModes.Count();

		for (TInt i=0;i<count;i++)

			{

			OutputHashOperationModeL(i, sCharacter.iSupportedOperationModes[i]);

			}			

		}

		break;