/*

* Copyright (c) 1998-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 "tcertwriter.h"

#include <x509keys.h>

#include <asn1dec.h>

EXPORT_C CertWriter::CertWriter(Output* aOut)

	:iOut(aOut)

	{

	}

EXPORT_C void CertWriter::SetOut(Output* aOut)

	{

	iOut = aOut;

	}

EXPORT_C void CertWriter::WriteCert(const CX509Certificate& aCertificate)

	{

	CX509Certificate* cert = CX509Certificate::NewLC(aCertificate);

//	iOut->writeString(_L("\n Certificate Version = ")):

//	iOut->writeNum(cert->Version());

//	iOut.writeNewLine();

	WriteEncodings(*cert);

	iOut->writeNewLine();	

	ShowSerialNumber(cert->SerialNumber());

	ShowValidityPeriod(*cert);

	iOut->writeString(_L("Issuer Name = "));

	iOut->writeNewLine();	

	ShowDN(cert->IssuerName());	

	iOut->writeString(_L("Subject Name = "));

	iOut->writeNewLine();	

	ShowDN(cert->SubjectName());

	ShowSigningAlgorithm(cert->SigningAlgorithm());

	ShowExtensions(*cert);

	ShowPublicKey(*cert);

	iOut->writeNewLine();	

	ShowFingerprint(*cert);

	ShowSignature(*cert);

/*	CalculateSignature(*cert);

	if (IsSelfSigned(*cert))

		{

		iOut->writeString(_L("\nSelf-signed\n"));

		}

	else

		{

		iOut->writeString(_L("\nNot self-signed\n"));

		}

*/

	iOut->writeString(_L("Short Issuer Name = "));

	HBufC* issuer = cert->IssuerL();

	iOut->writeString(*issuer);

	iOut->writeNewLine();

	delete issuer;

	iOut->writeString(_L("Short Subject Name = "));

	HBufC* subject = cert->SubjectL();

	iOut->writeString(*subject);

	iOut->writeNewLine();

	delete subject;

	iOut->writeNewLine();

	CleanupStack::PopAndDestroy();//cert

	}

EXPORT_C void CertWriter::ShowPublicKey(const CX509Certificate& aCertificate)

	{

	const CSubjectPublicKeyInfo& spki = aCertificate.PublicKey();

	switch(spki.AlgorithmId())

		{

		case ERSA:

			ShowRSAKey(spki);

			break;

		case EDSA:

			ShowDSAKey(spki);

			break;

		case EDH:

			ShowDHKey(spki);

			break;

		default:

			User::Panic(_L("CertWriter"), 1);

			break;

		}

	}

void CertWriter::ShowRSAKey(const CSubjectPublicKeyInfo& aSpki)

	{

	CX509RSAPublicKey* key = CX509RSAPublicKey::NewLC(aSpki.KeyData());

	iOut->writeString(_L("RSA Key:"));

	iOut->writeNewLine();

	iOut->writeSpaces(4);

	iOut->writeString(_L("Modulus = "));

	iOut->writeNewLine();

	const TInteger& mod = key->N();

	HBufC8* mBuf = mod.BufferLC();

	iOut->writeOctetStringL(mBuf->Des());

	iOut->writeNewLine();	

	iOut->writeSpaces(4);

	iOut->writeString(_L("Exponent = "));

	iOut->writeNewLine();

	const TInteger& exp = key->E();

	HBufC8* eBuf = exp.BufferLC();

	iOut->writeOctetStringL(eBuf->Des());

	iOut->writeNewLine();	

	CleanupStack::PopAndDestroy(eBuf);

	CleanupStack::PopAndDestroy(mBuf);

	CleanupStack::PopAndDestroy(key);

	}

void CertWriter::ShowDSAKey(const CSubjectPublicKeyInfo& aSpki)

	{

	const TDesC8& encParams = aSpki.EncodedParams();

	if (encParams.Length() != 0)

		{

		CDSAPublicKey* key = CX509DSAPublicKey::NewLC(encParams, aSpki.KeyData());

		iOut->writeString(_L("DSA Key:"));

		iOut->writeNewLine();

		iOut->writeSpaces(4);

		iOut->writeString(_L("Y = "));

		iOut->writeNewLine();

		const TInteger& y = key->Y();

		HBufC8* yBuf = y.BufferLC();

		iOut->writeOctetStringL(yBuf->Des());

		iOut->writeNewLine();	

		iOut->writeSpaces(4);

		iOut->writeString(_L("Params = "));

		iOut->writeNewLine();

		iOut->writeSpaces(8);

		iOut->writeString(_L("P = "));

		iOut->writeNewLine();

		const TInteger& p = key->P();

		HBufC8* pBuf = p.BufferLC();

		iOut->writeOctetStringL(pBuf->Des());

		iOut->writeNewLine();

		iOut->writeSpaces(8);

		iOut->writeString(_L("Q = "));

		iOut->writeNewLine();

		const TInteger& q = key->Q();

		HBufC8* qBuf = q.BufferLC();

		iOut->writeOctetStringL(qBuf->Des());

		iOut->writeNewLine();

		iOut->writeSpaces(8);

		iOut->writeString(_L("G = "));

		iOut->writeNewLine();

		const TInteger& g = key->G();

		HBufC8* gBuf = g.BufferLC();

		iOut->writeOctetStringL(gBuf->Des());

		iOut->writeNewLine();

		CleanupStack::PopAndDestroy(5);

		}

	}

void CertWriter::ShowDHKey(const CSubjectPublicKeyInfo& aSpki)

	{

	TASN1DecInteger encInt;

	TInt pos = 0;

	RInteger keyVal = encInt.DecodeDERLongL(aSpki.KeyData(), pos);

	CleanupStack::PushL(keyVal);

	HBufC8* keyValBuf = keyVal.BufferLC();

	iOut->writeString(_L("Y = "));

	iOut->writeNewLine();

	iOut->writeOctetStringL(keyValBuf->Des());

	CleanupStack::PopAndDestroy(2, &keyVal);

	CX509DHDomainParams* params = CX509DHDomainParams::NewLC(aSpki.EncodedParams());

	const TInteger& p = params->P();

	const TInteger& g = params->G();

	const TInteger& q = params->Q();

	const TInteger& j = params->J();

	const CX509DHValidationParams* valParams = params->ValidationParams();

	iOut->writeNewLine();

	iOut->writeString(_L("Params = "));

	iOut->writeNewLine();

	iOut->writeString(_L("P = "));

	iOut->writeNewLine();

	HBufC8* pBuf = p.BufferLC();

	iOut->writeOctetStringL(pBuf->Des());

	iOut->writeNewLine();

	CleanupStack::PopAndDestroy();

	iOut->writeString(_L("G = "));

	iOut->writeNewLine();

	HBufC8* gBuf = g.BufferLC();

	iOut->writeOctetStringL(gBuf->Des());

	iOut->writeNewLine();

	CleanupStack::PopAndDestroy();

	iOut->writeString(_L("Q = "));

	iOut->writeNewLine();

	HBufC8* qBuf = q.BufferLC();

	iOut->writeOctetStringL(qBuf->Des());

	iOut->writeNewLine();

	CleanupStack::PopAndDestroy();

	iOut->writeString(_L("J = "));

	iOut->writeNewLine();

	HBufC8* jBuf = j.BufferLC();

	iOut->writeOctetStringL(jBuf->Des());

	iOut->writeNewLine();

	CleanupStack::PopAndDestroy();

	if (valParams)

		{

		iOut->writeString(_L("Seed = "));

		iOut->writeNewLine();

		iOut->writeOctetStringL(valParams->Seed());

		iOut->writeNewLine();

		const TInteger& pGC = valParams->PGenCounter();

		HBufC8* pgBuf = pGC.BufferLC();

		iOut->writeString(_L("pGenCounter = "));

		iOut->writeNewLine();

		iOut->writeOctetStringL(pgBuf->Des());

		iOut->writeNewLine();

		CleanupStack::PopAndDestroy();

		}

	CleanupStack::PopAndDestroy();

	}

EXPORT_C void CertWriter::ShowSigningAlgorithm(const CSigningAlgorithmIdentifier& aSigningAlgorithm)

	{

	iOut->writeString(_L("Signed using: "));

	iOut->writeNewLine();

	iOut->writeSpaces(4);

	iOut->writeString(_L("Asymmetric algorithm = "));

	const CAlgorithmIdentifier& algId = aSigningAlgorithm.AsymmetricAlgorithm();

	switch(algId.Algorithm())

		{

		case ERSA:

			iOut->writeString(_L("RSA"));

			break;

		case EDSA:

			iOut->writeString(_L("DSA"));

			break;

		case EDH:

			iOut->writeString(_L("DH"));

			break;

		default:

			User::Panic(_L("CertWriter"), 1);

			break;

		}

	iOut->writeNewLine();

	iOut->writeSpaces(4);

	iOut->writeString(_L("Digest algorithm = "));

	const CAlgorithmIdentifier& digestId = aSigningAlgorithm.DigestAlgorithm();

	switch(digestId.Algorithm())

		{

		case EMD2:

			iOut->writeString(_L("MD2"));

			break;

		case EMD5:

			iOut->writeString(_L("MD5"));

			break;

		case ESHA1:

			iOut->writeString(_L("SHA1"));

			break;

		default:

			User::Panic(_L("CertWriter"), 1);

			break;

		}

	iOut->writeNewLine();

	}

EXPORT_C void CertWriter::ShowSerialNumber(const TPtrC8& aSerialNumber)

	{

	iOut->writeString(_L("Serial Number = "));

	iOut->writeOctetStringL(aSerialNumber);

	iOut->writeNewLine();

	}

//dn display code

EXPORT_C void CertWriter::ShowAVA(const CX520AttributeTypeAndValue& aAva)

	{

	iOut->writeString(aAva.Type());

	HBufC* val = aAva.ValueL();

	CleanupStack::PushL(val);

	iOut->writeString(_L(" = "));

	iOut->writeString(val->Des());

	CleanupStack::PopAndDestroy();

	}

EXPORT_C void CertWriter::ShowDN(const CX500DistinguishedName& aName)

	{

	iOut->writeNewLine();

	TInt count = aName.Count();

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

		{

  		const CX520AttributeTypeAndValue& ava = aName.Element(i);

		iOut->writeSpaces(4);

		ShowAVA(ava);

		iOut->writeNewLine();

		}

	}

EXPORT_C void CertWriter::ShowAKI(const CX509Certificate& aCert)

	{

	const CX509CertExtension* akiExt = aCert.Extension(KAuthorityKeyId);

	if (akiExt)

		{

		iOut->writeString(_L("Authority Key ID = "));

		iOut->writeNewLine();

		const CX509AuthorityKeyIdExt* ext = CX509AuthorityKeyIdExt::NewLC(akiExt->Data());

		const CArrayPtrFlat<CX509GeneralName>& authorityName = ext->AuthorityName();

		TInt count = authorityName.Count();

		if (count > 0)

			{

			iOut->writeSpaces(4);

			iOut->writeString(_L("Authority name = "));

			iOut->writeNewLine();

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

				{

				ShowGN(*(authorityName.At(i)));

				}

			}

		if (ext->AuthorityCertSerialNumber().Length() > 0)

			{

			iOut->writeSpaces(4);

			iOut->writeString(_L("Authority cert serial no = "));

			iOut->writeOctetStringL(ext->AuthorityCertSerialNumber());

			iOut->writeNewLine();

			}

		iOut->writeSpaces(4);

		iOut->writeString(_L("Key Id = "));

		iOut->writeOctetStringL(ext->KeyId());

		iOut->writeNewLine();

		CleanupStack::PopAndDestroy();

		}

	}

EXPORT_C void CertWriter::ShowSKI(const CX509Certificate& aCert)

	{

	const CX509CertExtension* skiExt = aCert.Extension(KSubjectKeyId);

	if (skiExt)

		{

		iOut->writeString(_L("Subject Key ID = "));

		iOut->writeNewLine();

		const CX509SubjectKeyIdExt* ext = CX509SubjectKeyIdExt::NewLC(skiExt->Data());

		iOut->writeSpaces(4);

		iOut->writeString(_L("Key Id = "));

		iOut->writeOctetStringL(ext->KeyId());

		iOut->writeNewLine();

		CleanupStack::PopAndDestroy();

		}

	}

EXPORT_C void CertWriter::ShowGN(const CX509GeneralName& aName)

	{

	iOut->writeSpaces(4);

	switch(aName.Tag())

		{

		case 1:

			{

			//rfc822

			CX509RFC822NameSubtree* email = CX509RFC822NameSubtree::NewLC(aName.Data());

			iOut->writeString(email->Name());

			iOut->writeNewLine();

			CleanupStack::PopAndDestroy();//email

			break;

			}

		case 2:

			{

			//dns name

			CX509DNSNameSubtree* dns = CX509DNSNameSubtree::NewLC(aName.Data());

			iOut->writeString(dns->Name());

			CleanupStack::PopAndDestroy();//dns

			break;

			}

		case 4:

			{

			//DN

			CX500DistinguishedName* dN = CX500DistinguishedName::NewLC(aName.Data());

			ShowDN(*dN);

			CleanupStack::PopAndDestroy();

			break;

			}

		case 6:

			{

			//uri

			CX509IPBasedURI* uri = CX509IPBasedURI::NewLC(aName.Data());

			iOut->writeString(uri->Name());

			iOut->writeNewLine();

			iOut->writeString(_L("Host="));

			iOut->writeString(uri->Host().Name());

			iOut->writeNewLine();

			CleanupStack::PopAndDestroy();//uri

			break;

			}

		case 7:

			{

			CX509IPAddress* ip = CX509IPAddress::NewLC(aName.Data());

			TPtrC8 addressStr(ip->Address());

			// IPv6 output not implemented yet

			iOut->write(_L("IP=%d.%d.%d.%d"), addressStr[0], addressStr[1], addressStr[2], addressStr[3]);

			iOut->writeNewLine();			

			CleanupStack::PopAndDestroy();

			break;

			}

		}

	}

EXPORT_C void CertWriter::ShowFingerprint(const CX509Certificate& aCertificate)

	{

	iOut->writeString(_L("Fingerprint:"));

	iOut->writeNewLine();

	iOut->writeOctetString(aCertificate.Fingerprint());

	iOut->writeNewLine();

	}

EXPORT_C void CertWriter::ShowValidityPeriod(const CX509Certificate& aCertificate)

	{

	const CValidityPeriod& vp = aCertificate.ValidityPeriod();

	iOut->writeString(_L("Validity Period = "));

	iOut->writeNewLine();

	const TTime& start = vp.Start();

	const TTime& finish = vp.Finish();

	TBuf<30> dateString1;

	start.FormatL(dateString1,(_L("%H%:1%T:%S %*E%*D %X%*N%Y %1 %2 %3")));

	iOut->writeSpaces(4);

	iOut->writeString(_L("Valid From = "));

	iOut->writeString(dateString1);

	iOut->writeNewLine();

	TBuf<30> dateString2;

	finish.FormatL(dateString2,(_L("%H%:1%T:%S %*E%*D %X%*N%Y %1 %2 %3")));

	iOut->writeSpaces(4);

	iOut->writeString(_L("Valid Until = "));

	iOut->writeString(dateString2);

	iOut->writeNewLine();

	}

//extensions

EXPORT_C void CertWriter::ShowExtensions(const CX509Certificate& aCertificate)

	{

	const CArrayPtrFlat<CX509CertExtension>& exts = aCertificate.Extensions();

	TInt count = exts.Count();

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

		{

		const CX509CertExtension* ext = exts.At(i);

		iOut->writeString(_L("extension"));

		iOut->writeNum(i);

		if (!(ext->Critical()))

			{

			iOut->writeString(_L(" not"));

			}

		iOut->writeString(_L(" critical"));

		iOut->writeString(_L(" ID = "));

		TPtrC id(ext->Id());

		iOut->writeString(id);

		iOut->writeNewLine();

		if (id == KBasicConstraints)

			{

			ShowBC(*ext);

			}

		if (id == KSubjectAltName)

			{