/*

* 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: Certificate info class for TLS untrusted certificate dialog.

*

*/

#include "untrustedcertificateinfo_symbian.h"

#include <signed.h>                             // TAlgorithmId

#include <x509cert.h>                           // CX509Certificate

#include <X509CertNameParser.h>                 // X509CertNameParser

#include <hash.h>                               // CMD5

// ======== LOCAL FUNCTIONS ========

// ----------------------------------------------------------------------------

// mapAlgorithm()

// ----------------------------------------------------------------------------

//

UntrustedCertificateInfoBase::Algorithm mapAlgorithm(TAlgorithmId aAlgId)

{

    UntrustedCertificateInfoBase::Algorithm algorithm =

        UntrustedCertificateInfoBase::Unknown;

    switch(aAlgId) {

        case ERSA:

            algorithm = UntrustedCertificateInfoBase::RSA;

            break;

        case EDSA:

            algorithm = UntrustedCertificateInfoBase::DSA;

            break;

        case EDH:

            algorithm = UntrustedCertificateInfoBase::DH;

            break;

        case EMD2:

            algorithm = UntrustedCertificateInfoBase::MD2;

            break;

        case EMD5:

            algorithm = UntrustedCertificateInfoBase::MD5;

            break;

        case ESHA1:

            algorithm = UntrustedCertificateInfoBase::SHA1;

            break;

        case ESHA224:

            algorithm = UntrustedCertificateInfoBase::SHA224;

            break;

        case ESHA256:

            algorithm = UntrustedCertificateInfoBase::SHA256;

            break;

        case ESHA384:

            algorithm = UntrustedCertificateInfoBase::SHA384;

            break;

        case ESHA512:

            algorithm = UntrustedCertificateInfoBase::SHA512;

            break;

        default:

            break;

    }

    return algorithm;

}

// ----------------------------------------------------------------------------

// convertDateTime()

// ----------------------------------------------------------------------------

//

void convertDateTime(const TTime& aFromTime, QDateTime& aToDateTime)

{

    const TDateTime &symbianDateTime = aFromTime.DateTime();

    QDate date(symbianDateTime.Year(), symbianDateTime.Month()+1, symbianDateTime.Day()+1);

    QTime time(symbianDateTime.Hour(), symbianDateTime.Minute(), symbianDateTime.Second());

    aToDateTime.setDate(date);

    aToDateTime.setTime(time);

}

// ======== MEMBER FUNCTIONS ========

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::UntrustedCertificateInfoSymbian()

// ----------------------------------------------------------------------------

//

UntrustedCertificateInfoSymbian::UntrustedCertificateInfoSymbian(

    const QByteArray &aEncodedCert) : UntrustedCertificateInfoBase(),

    mCert(0), mMd5Fingerprint()

{

    QT_TRAP_THROWING(ConstructL(aEncodedCert));

}

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::~UntrustedCertificateInfoSymbian()

// ----------------------------------------------------------------------------

//

UntrustedCertificateInfoSymbian::~UntrustedCertificateInfoSymbian()

{

    delete mCert;

}

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::commonNameMatches()

// ----------------------------------------------------------------------------

//

bool UntrustedCertificateInfoSymbian::commonNameMatches(const QString &siteName) const

{

    bool matches = false;

    QT_TRAP_THROWING(matches = CommonNameMatchesL(siteName));

    return matches;

}

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::certificateDetails()

// ----------------------------------------------------------------------------

//

QString UntrustedCertificateInfoSymbian::certificateDetails(const QString &siteName) const

{

    // TODO: localized UI string needed

    QString details = tr("Service:\n%1\n\nIssuer:\n%2\n\nSubject:\n%3\n\n"

        "Valid from:\n%4\n\nValid until:\n%5\n\nCertificate format:\n%6\n\n"

        "Algorithm:\n%7\n\nSerial number:\n%8\n\n"

        "Fingerprint (SHA1):\n%9\n\nFingerprint (MD5):\n%10")

        .arg(siteName)                                  // %1

        .arg(issuerName())                              // %2

        .arg(subjectName())                             // %3

        .arg(validFrom().toString())                    // %4

        .arg(validTo().toString())                      // %5

        .arg(format())                                  // %6

        .arg(combinedAlgorithmName())                   // %7

        .arg(formattedSerialNumber(serialNumber()))     // %8

        .arg(formattedFingerprint(fingerprint()))       // %9

        .arg(formattedFingerprint(mMd5Fingerprint));    // %10

    return details;

}

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::ConstructL()

// ----------------------------------------------------------------------------

//

void UntrustedCertificateInfoSymbian::ConstructL(const QByteArray &aEncodedCert)

{

    TPtrC8 encodedCert( reinterpret_cast<const TText8*>( aEncodedCert.constData() ),

        aEncodedCert.length() );

    ASSERT( mCert == 0 );

    mCert = CX509Certificate::NewL( encodedCert );

    HBufC16* subjectBuf = NULL;

    X509CertNameParser::SubjectFullNameL( *mCert, subjectBuf );

    CleanupStack::PushL( subjectBuf );

    QT_TRYCATCH_LEAVING( mSubjectName =

        QString::fromUtf16(subjectBuf->Ptr(), subjectBuf->Length()) );

    CleanupStack::PopAndDestroy( subjectBuf );

    HBufC16* issuerBuf = NULL;

    X509CertNameParser::IssuerFullNameL( *mCert, issuerBuf );

    CleanupStack::PushL( issuerBuf );

    QT_TRYCATCH_LEAVING( mIssuerName =

        QString::fromUtf16(issuerBuf->Ptr(), issuerBuf->Length()));

    CleanupStack::PopAndDestroy( issuerBuf );

    TPtrC8 fingerprint = mCert->Fingerprint();

    QT_TRYCATCH_LEAVING( mFingerprint = QByteArray::fromRawData(

        reinterpret_cast<const char*>(fingerprint.Ptr()), fingerprint.Length()) );

    mMd5Fingerprint = Md5FingerprintL( mCert->Encoding() );

    TPtrC8 serialNumber = mCert->SerialNumber();

    QT_TRYCATCH_LEAVING( mSerialNumber = QByteArray::fromRawData(

        reinterpret_cast<const char*>(serialNumber.Ptr()), serialNumber.Length()) );

    const CValidityPeriod& validityPeriod = mCert->ValidityPeriod();

    convertDateTime(validityPeriod.Start(), mValidFrom);

    convertDateTime(validityPeriod.Finish(), mValidTo);

    mFormat = X509Certificate;

    const CSigningAlgorithmIdentifier& alg = mCert->SigningAlgorithm();

    mDigestAlgorithm = mapAlgorithm(alg.DigestAlgorithm().Algorithm());

    mAsymmetricAlgorithm = mapAlgorithm(alg.AsymmetricAlgorithm().Algorithm());

}

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::CommonNameMatchesL()

// ----------------------------------------------------------------------------

//

bool UntrustedCertificateInfoSymbian::CommonNameMatchesL(const QString &siteName) const

{

    bool matches = false;

    const CX500DistinguishedName& distinguishedName = mCert->SubjectName();

    HBufC* commonNameSymbian = distinguishedName.ExtractFieldL( KX520CommonName );

    if (commonNameSymbian) {

        CleanupStack::PushL(commonNameSymbian);

        QString commonName = QString::fromRawData(

            reinterpret_cast<const QChar*>(commonNameSymbian->Ptr()),

            commonNameSymbian->Length());

        matches = ( commonName == siteName );       // TODO: accept '*' chars in commonName?

        CleanupStack::PopAndDestroy(commonNameSymbian);

    }

    return matches;

}

// ----------------------------------------------------------------------------

// UntrustedCertificateInfoSymbian::Md5FingerprintL()

// ----------------------------------------------------------------------------

//

QByteArray UntrustedCertificateInfoSymbian::Md5FingerprintL( const TDesC8& aEncodedCert ) const

{

    CMD5* md5 = CMD5::NewL();

    CleanupStack::PushL( md5 );

    const TPtrC8 fingerprintSymbian = md5->Hash( aEncodedCert );

    QByteArray fingerprint( reinterpret_cast<const char*>( fingerprintSymbian.Ptr() ),

        fingerprintSymbian.Length() );

    CleanupStack::PopAndDestroy( md5 );

    return fingerprint;

}