/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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 <x509cert.h>

#include <unifiedcertstore.h>

#include <X509CertNameParser.h>

#include <securitydefs.h>

#include <hash.h>                   // MD5 fingerprint

#include <asymmetrickeys.h>

#include <e32math.h>                // Pow

#include <e32cmn.h>

#include <QDateTime>

#include <QStringList>

#include <QGraphicsLinearLayout>

#include <hblineedit.h>

#include <hbdataform.h>

#include <hbdataformmodel.h>

#include <hbdataformmodelitem.h>

#include <hblabel.h>

#include <hbpushbutton.h>

#include <hbaction.h>

#include <HbListWidget>

#include <HbListWidgetItem>

#include <HbGroupBox>

#include <hbpushbutton.h>

#include <hbdataform.h>

#include <hbdataformmodel.h>

#include <hbdataformmodelitem.h>

#include "cpcertdetailview.h"

#include "cpcertview.h"

#include "cpcertdatacontainer.h"

#include "cpcertmanuisyncwrapper.h"

#include "../../../pkiutilities/DeviceToken/Inc/TrustedSitesStore.h"

const TInt KFileCertStoreUid( 0x101F501A );

const TInt KTrustedServerCertStoreUid( 0x101FB66F );

const TInt KDeviceCertStoreUid( 0x101FB668 );

const TInt KDeviceKeyStoreUid( 0x101FB66A );

const TInt KWIMCertStoreUid ( 0x101F79D9 );

const TInt KMaxLengthTextSerialNumberFormatting = 3;

_LIT( KCertManUIDetailsViewHexaFormat, "%02X" );

_LIT( KBlockSeparator, " " );

template <class T>

class CleanupResetAndDestroy

    {

public:

    inline static void PushL( T& aRef );

private:

    static void ResetAndDestroy( TAny *aPtr );

    };

template <class T>

inline void CleanupResetAndDestroyPushL( T& aRef );

template <class T>

inline void CleanupResetAndDestroy<T>::PushL( T& aRef )

    {

    CleanupStack::PushL( TCleanupItem( &ResetAndDestroy, &aRef ) );

    }

template <class T>

void CleanupResetAndDestroy<T>::ResetAndDestroy( TAny *aPtr )

    {

    if( aPtr )

        {

        static_cast<T*>( aPtr )->ResetAndDestroy();

        }

    }

template <class T>

inline void CleanupResetAndDestroyPushL( T& aRef )

    {

    CleanupResetAndDestroy<T>::PushL( aRef );

    }

CpCertDetailView::CpCertDetailView(CpCertView::TCertificateViews aCurrentView,TInt aPos, CpCertDataContainer& aCertDataContainer, QGraphicsItem *parent /*= 0*/)

: CpBaseSettingView(0,parent), mCertDataContainer(aCertDataContainer)

	{

	setTitle(tr("Certificate Details"));

	try

		{

		QT_TRAP_THROWING(viewCertificateDetailsL(aPos, aCurrentView));

		}

	catch(const std::exception& exception)

		{

		HbMessageBox::information(exception.what());

		throw(exception);

		}

	}

CpCertDetailView::~CpCertDetailView()

	{}

void CpCertDetailView::viewCertificateDetailsL( TInt aIndex, CpCertView::TCertificateViews aType )

	{

	QGraphicsLinearLayout *layout = q_check_ptr(new QGraphicsLinearLayout(Qt::Vertical));	

	setLayout(layout);

	HbListWidget* mCertDetails = q_check_ptr(new HbListWidget(this));

    HBufC8* urlBuf = NULL;

    CCertificate* details = NULL;

    CUnifiedCertStore*& store = mCertDataContainer.CertManager();

    const CCTCertInfo* entry = certInfo(aIndex, aType);

    TCertificateFormat certificateFormat = entry->CertificateFormat();

    if( certificateFormat != EX509CertificateUrl )

        {

        mCertDataContainer.iWrapper->GetCertificateL( store, *entry, details );

        CleanupStack::PushL( details );

        validateCertificateL( aIndex, *details, *entry, aType );

        }

    else

        {

        urlBuf = HBufC8::NewLC( entry->Size() );

        TPtr8 urlPtr = urlBuf->Des();

        mCertDataContainer.iWrapper->GetUrlCertificateL( store, *entry, urlPtr );

        }

    if( aType == CpCertView::ETrustedView )

        {

		addTrustedSitesL(*details, *mCertDetails);

        }

    else

        {

		addLabel(*entry, *mCertDetails);

        }

    // certificate issuer and owner

    if( certificateFormat == EX509Certificate )

        {

		addIssuerL(*details, *mCertDetails);

		addSubjectL(*details, *mCertDetails);

        }

    // Get key usage and location. This is done only client certificates.

    const TInt KLocationUnknown = 0;

    TUid keyLocation = { KLocationUnknown };

    if(( aType == CpCertView::EPersonalView ) || ( aType == CpCertView::EDeviceView ))

        {

		TKeyUsagePKCS15 usage = keyUsageAndLocationL( *entry, &keyLocation );

        addCertUsage(usage, *mCertDetails);		

        }

    if( certificateFormat == EX509Certificate )

        {

		addValidityPeriod( *details, *mCertDetails );                

        TUid certLoc;

        certLoc.iUid = entry->Token().TokenType().Type().iUid;

        // add the location of the certificate

        setLocationInfo( ETrue, certLoc, *mCertDetails );

        }

    else if( certificateFormat == EX509CertificateUrl )

        {

        setURLLocation( *urlBuf, *mCertDetails );

        }

    else

        {

        // nothing

        }

    addCertFormat(certificateFormat, *mCertDetails);

    // Private key location, only for user and device certicates

    if(( aType == CpCertView::EPersonalView ) || ( aType == CpCertView::EDeviceView ))

        {

        setLocationInfo( EFalse, keyLocation, *mCertDetails );

        }

    if( certificateFormat == EX509Certificate )

        {

		addAlgoDetails( *details, *mCertDetails);

        addSerialNo( *details, *mCertDetails );

        addFingerprint( *details, *mCertDetails);

        addPublicKeyDetailsL( *details, *mCertDetails );

        }

    else

        {

        // SetUrlCertAlgorihm()

        }

    if( certificateFormat != EX509CertificateUrl )

        {

        CleanupStack::PopAndDestroy( details );

        }

    else

        {

        CleanupStack::PopAndDestroy( urlBuf );

        }

    layout->addItem(mCertDetails);

    }

const CCTCertInfo* CpCertDetailView::certInfo( TInt index, CpCertView::TCertificateViews certView )

	{

	const CCTCertInfo* certinfo = NULL;

	if( certView == CpCertView::EAuthorityView )

		{

		certinfo = ( mCertDataContainer.iCALabelEntries )[ index ]->iCAEntry;

		}

	else if( certView == CpCertView::ETrustedView )

		{

		certinfo = ( mCertDataContainer.iPeerLabelEntries )[ index ]->iPeerEntry;

		}

	else if( certView == CpCertView::EDeviceView )

		{

		certinfo = ( mCertDataContainer.iDeviceLabelEntries )[ index ]->iDeviceEntry;

		}

	else if( certView == CpCertView::EPersonalView )

		{

		certinfo = ( mCertDataContainer.iUserLabelEntries )[ index ]->iUserEntry;

		}

	return certinfo;

	}

void CpCertDetailView::addTrustedSitesL( const CCertificate& certDetails, HbListWidget& certDisplayDetails )

	{

	CTrustSitesStore* trustedSitesStore = CTrustSitesStore::NewL();

	CleanupStack::PushL( trustedSitesStore );

	RPointerArray<HBufC> trustedSites;

	CleanupResetAndDestroyPushL( trustedSites );

	trustedSitesStore->GetTrustedSitesL( certDetails.Encoding(), trustedSites );

	QString sTrustedSites = "Site:";

	if( trustedSites.Count() > 0 )

		{

		// display trusted sites

		sTrustedSites = "Site:";

		}

	addToListWidget(certDisplayDetails, sTrustedSites);

	for(int index=0;index<trustedSites.Count(); ++index)

		{

		QString trustedSiteDetail = QString((QChar*)(trustedSites[index]->Ptr()), trustedSites[index]->Length());

		addToListWidget(certDisplayDetails, trustedSiteDetail);

		}

	CleanupStack::PopAndDestroy( &trustedSites );

	CleanupStack::PopAndDestroy( trustedSitesStore );

	}

void CpCertDetailView::addLabel( const CCTCertInfo& aCertInfo, HbListWidget& certDisplayDetails )

	{

	QString sLabel("Label:");

	QString sLabelDetails = "(No label)"; 

	if(aCertInfo.Label().Length()  != 0)

		{

		sLabelDetails = QString((QChar*)(aCertInfo.Label().Ptr()),aCertInfo.Label().Length());

		}

	addToListWidget(certDisplayDetails, sLabel, sLabelDetails);

	}

void CpCertDetailView::addIssuerL( 	const CCertificate& aCertDetails, 

									HbListWidget& certDisplayDetails )

	{

	HBufC* issuer = NULL;

	X509CertNameParser::IssuerFullNameL( (CX509Certificate&)aCertDetails, issuer );

	CleanupStack::PushL( issuer );

	QString sIssuer = "Issuer:";

	QString sIssuerDetails = "(Not defined)"; 

	if(issuer->Des().Length() != 0)

		{

		sIssuerDetails = QString((QChar*)issuer->Des().Ptr(),issuer->Des().Length());

		}

	addToListWidget(certDisplayDetails, sIssuer, sIssuerDetails);

	CleanupStack::PopAndDestroy( issuer ); 

	}

void CpCertDetailView::addSubjectL( const CCertificate& aCertDetails, 

									HbListWidget& certDisplayDetails )

	{

	HBufC* subject = NULL;

	X509CertNameParser::SubjectFullNameL( (CX509Certificate&)aCertDetails, subject );

	CleanupStack::PushL( subject );

	QString sSubject = "Subject:";

	QString sSubjectDetails = "(No subject)";

	if(subject->Des().Length() != 0)

		{

		sSubjectDetails = QString((QChar*)subject->Des().Ptr(),subject->Des().Length());

		}

	addToListWidget(certDisplayDetails, sSubject, sSubjectDetails);

	CleanupStack::PopAndDestroy( subject );

	}

void CpCertDetailView::addCertUsage( TKeyUsagePKCS15 usage, HbListWidget& certDisplayDetails )

	{

	QString strUsage;

	switch( usage )

		{

		case EPKCS15UsageSignSignRecover:

		case EPKCS15UsageSignDecrypt:

		case EPKCS15UsageSign:

			strUsage = "Client authentication";

			break;

		case EPKCS15UsageNonRepudiation:

			strUsage = "Digital signing";

			break;

		default:

			strUsage = "(Not defined)";

			break;

		}

	addToListWidget(certDisplayDetails, strUsage );     

	}

void CpCertDetailView::addValidityPeriod( 	const CCertificate& aCertDetails, 

											HbListWidget& certDisplayDetails)

	{

	// Certificate validity period

	// Hometime's offset to UTC

	TLocale locale;

	TTimeIntervalSeconds offSet = locale.UniversalTimeOffset();

	QString sValidFrom("Valid from: ");

	const CValidityPeriod& validityPeriod = aCertDetails.ValidityPeriod();

	TTime startValue = validityPeriod.Start();

	startValue += offSet;

	TDateTime dateTime = startValue.DateTime();

	TMonth month = dateTime.Month();

	TInt day = dateTime.Day();

	TInt year = dateTime.Year();

	QDateTime qValidityPeriod(QDate(year, month, day));

	QString sValidFromDetail = qValidityPeriod.toString("MM\\dd\\yyyy");

	addToListWidget(certDisplayDetails, sValidFrom, sValidFromDetail);

	QString sValidUntil("Valid until: ");

	TTime finishValue = validityPeriod.Finish();

	finishValue += offSet;

	dateTime = finishValue.DateTime();

	month = dateTime.Month();

	day = dateTime.Day();

	year = dateTime.Year();

	qValidityPeriod.setDate(QDate(year, month, day));

	QString sValidUntilDetail = qValidityPeriod.toString("MM\\dd\\yyyy");

	addToListWidget(certDisplayDetails, sValidUntil, sValidUntilDetail);

	}

void CpCertDetailView::setURLLocation( HBufC8& urlDetails, HbListWidget& certDisplayDetails )

	{

	TPtr8 urlPtr = urlDetails.Des();

	QString certUrl = "Location:"; 

	QString certURLDetail = "(Not defined)";

	TInt length = urlPtr.Length();

	if(length != 0)

		{

		certURLDetail = QString((QChar*)urlPtr.Ptr(),urlPtr.Length());

		}

	addToListWidget(certDisplayDetails, certUrl, certURLDetail);

	}

void CpCertDetailView::addCertFormat( TCertificateFormat aCertFormat, HbListWidget& certDisplayDetails )

	{

	// certificate format

	QString certFormat = "Certificate format:";

	QString certFormatDetails = "(Not defined)";

	if( aCertFormat == EX509Certificate || aCertFormat == EX509CertificateUrl)

		{

		certFormatDetails = "X509";

		}

	addToListWidget(certDisplayDetails, certFormat, certFormatDetails);

	}

void CpCertDetailView::addAlgoDetails( 	const CCertificate& certificate, 

										HbListWidget& certDisplayDetails )

	{

	// certificate algorithms

	QString sDgstAlgoDetails = "Unknown";

	// digest algorithm

	TAlgorithmId algorithmId = certificate.SigningAlgorithm().DigestAlgorithm().Algorithm();

	switch( algorithmId )

		{

		case EMD2:

			{

			sDgstAlgoDetails = "MD2";

			break;

			}

		case EMD5:

			{

			sDgstAlgoDetails = "MD5";

			break;

			}

		case ESHA1:

			{

			sDgstAlgoDetails = "SHA1";

			break;

			}

		}

	QString sAsymmetricAlgoDetails = asymmetricAlgoId(certificate);

	QString sAlgorithm("Algorithm:");

	QString sAlgoDetails = "Unknown";

	// If other algorithm is unknown

	if( sDgstAlgoDetails != "Unknown" && sAsymmetricAlgoDetails != "Unknown" )

		{

		sAlgoDetails = sDgstAlgoDetails;

		sAlgoDetails.append(sAsymmetricAlgoDetails);

		}

	addToListWidget(certDisplayDetails, sAlgorithm, sAlgoDetails);

	}

void CpCertDetailView::addSerialNo( const CCertificate& certificate, 

									HbListWidget& certDisplayDetails )

	{

	// certificate serial number

	QString sCertSerialNo("Serial number:");

	QString sCertSerialNoDetails = 0;

	TPtrC8 serialNumber = certificate.SerialNumber();

	TBuf<KMaxLengthTextSerialNumberFormatting> buf2;

	for( TInt i = 0; i < serialNumber.Length(); i++ )

	   {

	   buf2.Format( KCertManUIDetailsViewHexaFormat, serialNumber[i] );

	   sCertSerialNoDetails.append( QString( (QChar*)buf2.Ptr(),buf2.Length() ) );

	   }

	addToListWidget(certDisplayDetails, sCertSerialNo, sCertSerialNoDetails);

	}

void CpCertDetailView::addFingerprint(	const CCertificate& certificate, 

										HbListWidget& certDisplayDetails)

	{

	// certificate fingerprint SHA-1

	QString sSha1("Fingerprint (SHA1):");

	TPtrC8 sha1_fingerprint = certificate.Fingerprint();

	HBufC* finalSha1 = NULL;

	QT_TRAP_THROWING(	 finalSha1 = HBufC::NewLC(100));

	TPtr finalShaPtr = finalSha1->Des();

	divideIntoBlocks( sha1_fingerprint, finalShaPtr );

	QString sSha1Details = QString( (QChar*)finalShaPtr.Ptr(), finalShaPtr.Length() );

	CleanupStack::PopAndDestroy(finalSha1);

	addToListWidget(certDisplayDetails, sSha1, sSha1Details);

	// certificate fingerprint MD5

	QString sMd5("Fingerprint (MD5):");

	CMD5* md5= NULL;

	QT_TRAP_THROWING(	 md5 = CMD5::NewL());

	QT_TRAP_THROWING(CleanupStack::PushL( md5 ));

	TBuf8<20> fingerprint = md5->Hash( certificate.Encoding() );

	CleanupStack::PopAndDestroy( md5 );

	HBufC* finalMd5 = NULL;

	QT_TRAP_THROWING(	finalMd5 = HBufC::NewLC(100));

	TPtr finalMd5Ptr = finalMd5->Des();

	divideIntoBlocks( fingerprint, finalMd5Ptr );

	QString sMd5Details = QString( (QChar*)finalMd5Ptr.Ptr(), finalMd5Ptr.Length());

	CleanupStack::PopAndDestroy(finalMd5);

	addToListWidget(certDisplayDetails, sMd5, sMd5Details);

	}

void CpCertDetailView::addPublicKeyDetailsL(	const CCertificate& certificate, 

											HbListWidget& certDisplayDetails )

	{

	// Public key

    // Should look like: "Public key (%0U %1N bit):"

	QString sPublicKey("Public key ("); // %S %d bits):");

	sPublicKey.append(asymmetricAlgoId(certificate));

	// Get public key already here to get length of it for string loader.

	const CSubjectPublicKeyInfo& publicKey = certificate.PublicKey();

	TPtrC8 keyData = publicKey.KeyData();

	TInt size = keyData.Size();  // %1N

	// To get key size decode DER encoded key got from the certificate.

	TX509KeyFactory key;

	// There doesn't seem to be definition of MAX_INT anywhere so calculate it.

	TReal maxInt;

	TReal intBits = sizeof( TInt ) * 8;

	Math::Pow( maxInt, 2, intBits );

	maxInt = ( maxInt / 2 ) - 1;

	TAlgorithmId algorithmId = certificate.SigningAlgorithm().AsymmetricAlgorithm().Algorithm();

	switch( algorithmId )

		{

		case ERSA:

			{

			const CRSAPublicKey* keyRSA = key.RSAPublicKeyL( keyData );

			const TInteger& n = keyRSA->N();

			TUint keySizeN = n.BitCount();

			// Play it safe.

			if( keySizeN < maxInt )

				{

				size = keySizeN;

				}

			delete keyRSA;