/*

* Copyright (c) 2003-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 <e32base.h>

#include <e32cons.h>

#include "keytool_utils.h"

#include "securityerr.h"

#include "compiledsecuritypolicy.h"

_LIT(space, " ");

_LIT(newline, "\n");

_LIT(KExtractable, "Extractable");

_LIT(KSensitive, "Sensitive");

_LIT(KAlwaysSensitive, "AlwaysSensitive");

_LIT(KNeverExtractable, "NeverExtractable");

_LIT(KLocal, "Local");

_LIT(KEllipsis, "...");

_LIT(x509, "X509");

_LIT(allusage, "AllUsage");

_LIT(nousage, "NoUsage");

_LIT(encrypt, "Encrypt");

_LIT(decrypt, "Decrypt");

_LIT(sign, "Sign");

_LIT(signrecover, "SignRecover");

_LIT(wrap, "Wrap");

_LIT(unwrap, "Unwrap");

_LIT(verify, "Verify");

_LIT(verifyrecover, "VerifyRecover");

_LIT(derive, "Derive");

_LIT(nonrepudiation, "NonRepudiation");

const TInt KCursorOffset		= 2;

static const TInt KMaxLabel = 32;

CConsoleBase* KeyToolUtils::iConsole = NULL;       

RFile* KeyToolUtils::iFile = NULL;

/*static*/ void KeyToolUtils::WriteErrorL(TInt aError)

	{

	if ((aError <= -12000) && (aError >= -12100))

		{

		PrintInfoL(_L("You have tsecdlg.dll in z:\\system\\notifiers."));		

		PrintInfoL(_L("This notifier is for *testing only* please remove it and try again!"));

		return;		

		}

	switch (aError)

		{

	case KErrNone:	// 0

		PrintInfoL(_L("KErrNone"));

		break;

	case KErrNotFound:	// -1

		PrintInfoL(_L("KErrNotFound"));

		break;

	case KErrNotSupported:	// -5

		PrintInfoL(_L("KErrNotSupported"));

		break;

	case KErrInUse:	// -14

		PrintInfoL(_L("KErrInUse"));

		break;

	case KErrNotReady:	// -18

		PrintInfoL(_L("KErrNotReady"));

		break;

	case KErrKeyAlgorithm:  //-11006

		PrintInfoL(_L("KErrKeyAlgorithm"));

		break;		

	case KErrKeyUsage:  //-11007

		PrintInfoL(_L("KErrKeyUsage"));

		break;

	case KErrKeyValidity:  //-11008

		PrintInfoL(_L("KErrKeyValidity"));

		break;		

	case KErrKeySize:  //-11009

		PrintInfoL(_L("KErrKeySize"));

		break;

	case KErrKeyAccess:  //-11010

		PrintInfoL(_L("KErrKeyAccess"));

		break;

	case KRequestPending:

		PrintInfoL(_L("KRequestPending"));

		break;

	case KErrAlreadyExists:

		PrintInfoL(_L("KErrAlreadyExists"));

		break;

	case KErrArgument:

		PrintInfoL(_L("KErrArgument"));

		break;

	case KErrBadName: // -28

		PrintInfoL(_L("KErrBadName"));

		break;

	case KErrCorrupt: // -20

		PrintInfoL(_L("KErrCorrupt"));

		break;		

	case KErrPrivateKeyNotFound: //-11011				

		PrintInfoL(_L("KErrPrivateKeyNotFound"));

		break;	

	default:

		{

		TBuf<64> msg;

		msg.Format(_L("Unknown (Code %d)"), aError);

		PrintInfoL(msg);		

		}

		break;

		}

	}

/*static*/ void KeyToolUtils::WriteOctetStringL(const TDesC8& aString)

	{

	TInt index;

   	TInt counter;

 	counter = aString.Length();

	HBufC* buf = HBufC::NewLC(counter*6);

	TPtr pBuf = buf->Des();

   	 for (index = 0; index < counter; index++)

		{

		pBuf.AppendFormat(_L("%01x"),aString[index]>>4);

		pBuf.AppendFormat(_L("%01x"),aString[index]&0xf);

		pBuf.Append(_L(" "));

		}

	PrintInfoL(pBuf);

	CleanupStack::PopAndDestroy();//buf

	}

/*static*/ void KeyToolUtils::PrintUsageL(TUint aUsage)

	{

	PrintInfoL(_L("\t\tUsage : "));

	if (aUsage & 0x0000ffff)  // In this range we are talking PKCS15

		{

		PrintInfoL(_L("PKCS15 "));

		}

	if (aUsage & 0xffff0000)  // In this range we are talking X509

		{

		PrintInfoL(x509);

		}

	if (aUsage == (TUint)EPKCS15UsageAll)

		{

		PrintInfoL(allusage);		

		return;

		}	

	if (aUsage == EPKCS15UsageNone)

		{

		PrintInfoL(nousage);		

		return;

		}	

	if (aUsage & EPKCS15UsageEncrypt)

		{

		PrintInfoL(encrypt);		

		}

	if (aUsage & EPKCS15UsageDecrypt)

		{

		PrintInfoL(decrypt);		

		}

	if (aUsage & EPKCS15UsageSign)

		{

		PrintInfoL(sign);		

		}

	if (aUsage & EPKCS15UsageSignRecover)

		{

		PrintInfoL(signrecover);		

		}

	if (aUsage & EPKCS15UsageWrap)

		{

		PrintInfoL(wrap);		

		}

	if (aUsage & EPKCS15UsageUnwrap)

		{

		PrintInfoL(unwrap);		

		}

	if (aUsage & EPKCS15UsageVerify)

		{

		PrintInfoL(verify);		

		}

	if (aUsage & EPKCS15UsageVerifyRecover)

		{

		PrintInfoL(verifyrecover);		

		}

	if (aUsage & EPKCS15UsageDerive)

		{

		PrintInfoL(derive);		

		}

	if (aUsage & EPKCS15UsageNonRepudiation)

		{

		PrintInfoL(nonrepudiation);		

		}

	if (aUsage & (TUint)EX509UsageDigitalSignature)

		{

		PrintInfoL(_L("DigitalSignature "));		

		}

	if (aUsage & EX509UsageNonRepudiation)

		{

		PrintInfoL(_L("NonRepudiation "));		

		}

	if (aUsage & EX509UsageKeyEncipherment)

		{

		PrintInfoL(_L("KeyEncipherment "));		

		}

	if (aUsage & EX509UsageDataEncipherment )

		{

		PrintInfoL(_L("DataEncipherment "));		

		}

	if (aUsage & EX509UsageKeyAgreement )

		{

		PrintInfoL(_L("KeyAgreement "));		

		}

	if (aUsage & EX509UsageKeyCertSign )

		{

		PrintInfoL(_L("KeyCertSign "));		

		}

	if (aUsage & EX509UsageCRLSign )

		{

		PrintInfoL(_L("CRLSign "));		

		}

	if (aUsage & EX509UsageEncipherOnly )

		{

		PrintInfoL(_L("EncipherOnly  "));		

		}

	if (aUsage & EX509UsageDecipherOnly)

		{

		PrintInfoL(_L("DecipherOnly  "));		

		}

	TBuf<32> buf;	

	_LIT(KKeyUsage, "\tCode: 0x%x ");

	buf.Format(KKeyUsage, aUsage);

	PrintInfoL(buf);

	PrintInfoL(newline);	

	}

/*static*/ HBufC* KeyToolUtils::KeyAccessDesLC(TInt aAccess)

	{

	TBuf<128> access;

	if (aAccess & CCTKeyInfo::ESensitive)

		{

		access.Append(KSensitive);

		access.Append(space);

		}

	if (aAccess & CCTKeyInfo::EExtractable)

		{ 

		access.Append(KExtractable);

		access.Append(space);		

		}

	if (aAccess & CCTKeyInfo::EAlwaysSensitive)

		{

		access.Append(KAlwaysSensitive);

		access.Append(space);

		}

	if (aAccess & CCTKeyInfo::ENeverExtractable)

		{ 

		access.Append(KNeverExtractable);

		access.Append(space);

		}

	if (aAccess & CCTKeyInfo::ELocal)	

		{ 

		access.Append(KLocal);

		access.Append(space);

		}

	return access.AllocLC();	

	}

/*static*/ HBufC* KeyToolUtils::AlgorithmDesLC(CCTKeyInfo::EKeyAlgorithm aAlgorithm)

	{

	TBuf<32> alg;

	switch (aAlgorithm)

		{

		case CCTKeyInfo::EInvalidAlgorithm:

			{

			alg = _L("Invalid Algorithm");

			}

			break;

		case CCTKeyInfo::ERSA:

			{

			alg = _L("RSA");

			}

			break;

		case CCTKeyInfo::EDSA:

			{

			alg = _L("DSA");

			}

			break;

		case CCTKeyInfo::EDH :

			{

			alg = _L("Diffie Hellman");

			}

			break;

		default:

			{

			alg = _L("Unsupported algorithm!");			

			}

		}	

	return alg.AllocLC();

	}

/*static*/ void KeyToolUtils::PrintKeyInfoL(const CCTKeyInfo& aKey, TBool aIsDetailed,TBool aPageWise)

	{

	HBufC* alg = KeyToolUtils::AlgorithmDesLC(aKey.Algorithm());

	TFileName buf;

	MCTToken& token = aKey.Token();

	TFileName msg,msg1;

	const TDesC& tmp = token.Label();

	msg.Format(_L("Store Label: %S"), &tmp);	

	const TDesC& tmp1 = token.Information(MCTToken::EVersion);

	const TDesC& tmp2 = token.Information(MCTToken::ESerialNo);

	const TDesC& tmp3 = token.Information(MCTToken::EManufacturer);

	msg1.Format(_L("Version: %S \t Serial Number: %S \t Manufacturer: %S Store Type: Read only"), &tmp1, &tmp2, &tmp3);	

	if (!aIsDetailed)

		{

		PrintInfoL(msg, aPageWise);

		PrintInfoL(newline, aPageWise);

		PrintInfoL(aKey.Label().Left(KMaxLabel));

		if (aKey.Label().Length() > KMaxLabel)

			{

			PrintInfoL(KEllipsis);

			}

		PrintInfoL(_L(" is a "));			

		_LIT(KKeySizeShort, "%d");

		buf.Format(KKeySizeShort,  aKey.Size());

		PrintInfoL(buf);

		PrintInfoL(_L(" bits "));

		PrintInfoL(*alg);

		PrintInfoL(_L(" key "));	

		CleanupStack::PopAndDestroy(alg);	

		PrintInfoL(newline, aPageWise);	

		return;

		}

	PrintInfoL(msg, aPageWise);

	PrintInfoL(newline, aPageWise);

	PrintInfoL(msg1, aPageWise);

	PrintInfoL(newline, aPageWise);

	PrintInfoL(_L("\t\tAlgorithm: "));	

	PrintInfoL(*alg);

	CleanupStack::PopAndDestroy(alg);			

	_LIT(KKeySize, "\tSize: %d ");

	buf.Format(KKeySize,  aKey.Size());

	PrintInfoL(buf);

	PrintInfoL(_L(" bits"));

	PrintInfoL(newline, aPageWise);

	KeyToolUtils::PrintUsageL(aKey.Usage());

	_LIT(KKeyOwner, "\t\tOwner : 0x%x ");

	_LIT(KKeyUser, "\t\tUser : 0x%x ");

	TCompiledSecurityPolicy managementPolicy = aKey.ManagementPolicy();

	TCompiledSecurityPolicy usePolicy = aKey.UsePolicy();

	TUint32 mSecureid = managementPolicy.SecureId();

	if (mSecureid == 0xffffffff)

		{

		TCapability cab = managementPolicy.Capability(0);

		_LIT(KKeyOwnerCab, "\t\tOwner : %S ");

		// currently only possible for keyowner other than secure id.

		if (cab == ECapabilityWriteDeviceData)

			{

			_LIT(KCab, "WriteDeviceData");

			buf.Format(KKeyOwnerCab, &KCab);

			PrintInfoL(buf);	

			}

		else

			{

			_LIT(KCab, "Unknown");

			buf.Format(KKeyOwnerCab, &KCab);

			PrintInfoL(buf);

			}

		}

	else

		{

		buf.Format(KKeyOwner, mSecureid);

		PrintInfoL(buf);		

		}

	PrintInfoL(newline, aPageWise);

	TUint32 uSecureid = usePolicy.SecureId();

	if (uSecureid == 0xffffffff)

		{

		TSecurityPolicy::TType utype = usePolicy.Type();

		_LIT(KKeyUserType, "\t\tUser : %S ");

		// currently only possible for keyuser other than secure id

		if (utype == TSecurityPolicy::ETypePass)

			{

			_LIT(KType, "ALL");

			buf.Format(KKeyUserType, &KType);

			PrintInfoL(buf);	

			}

		else

			{

			_LIT(KType, "Unknown");

			buf.Format(KKeyUserType, &KType);

			PrintInfoL(buf);

			}

		}

	else

		{

		buf.Format(KKeyUser, uSecureid);

		PrintInfoL(buf);

		if (uSecureid == KUidSecurityKeytool)

			{

			_LIT(KUser, " (KeyTool)");

			PrintInfoL(KUser);

			}

		}

	PrintInfoL(newline, aPageWise);

	_LIT(KKeySens, "\t\tAccess flags: ");

	PrintInfoL(KKeySens);

	HBufC* access = KeyToolUtils::KeyAccessDesLC(aKey.AccessType());

	PrintInfoL(*access);

	CleanupStack::PopAndDestroy(access);

	PrintInfoL(newline, aPageWise);

	_LIT(KKeyID, "\t\tID: ");

	PrintInfoL(KKeyID);

	KeyToolUtils::WriteOctetStringL(aKey.ID());

	PrintInfoL(newline, aPageWise);

	_LIT(KKeyLabel, "\t\tLabel: ");

	PrintInfoL(KKeyLabel);

	PrintInfoL(aKey.Label().Left(KMaxLabel));

	if (aKey.Label().Length() > KMaxLabel)

		{

		PrintInfoL(KEllipsis);

		}

	PrintInfoL(newline, aPageWise);

	_LIT(KKeyNative, "\t\tNative: Yes ");

	_LIT(KKeyNotNative, "\t\tNative: No ");

	if ( aKey.Native())

		{

		PrintInfoL(KKeyNative);	

		}

	else

		{

		PrintInfoL(KKeyNotNative);			

		}

	PrintInfoL(newline, aPageWise);

	_LIT(KTimeFormat, "%1/%2/%3 %H:%T:%S");

	_LIT(KKeyStartDate, "\t\tStart date: ");

	PrintInfoL(KKeyStartDate);

	if (aKey.StartDate().Int64() == 0)

		{