/*

* 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 "UntrustedCertificateInfoBase.h"

const char *KHexNumberFormatSimple = "%X";

const char *KHexNumberFormatTwoDigitsWithLeadingZeroes = "%02X";

const int KCharsPerBlock = 2;

const char KBlockSeparator = ' ';

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

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

// UntrustedCertificateInfoBase::UntrustedCertificateInfoBase()

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

//

UntrustedCertificateInfoBase::UntrustedCertificateInfoBase() : QObject(),

    mSubjectName(), mIssuerName(), mFingerprint(), mSerialNumber(), mValidFrom(), mValidTo(),

    mFormat(UnknownCertificate), mDigestAlgorithm(Unknown), mAsymmetricAlgorithm(Unknown)

{

}

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

// UntrustedCertificateInfoBase::~UntrustedCertificateInfoBase()

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

//

UntrustedCertificateInfoBase::~UntrustedCertificateInfoBase()

{

}

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

// UntrustedCertificateInfoBase::subjectName()

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

//

const QString UntrustedCertificateInfoBase::subjectName() const

{

    return mSubjectName;

}

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

// UntrustedCertificateInfoBase::issuerName()

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

//

const QString UntrustedCertificateInfoBase::issuerName() const

{

    return mIssuerName;

}

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

// UntrustedCertificateInfoBase::fingerprint()

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

//

const QByteArray UntrustedCertificateInfoBase::fingerprint() const

{

    return mFingerprint;

}

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

// UntrustedCertificateInfoBase::serialNumber()

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

//

const QByteArray UntrustedCertificateInfoBase::serialNumber() const

{

    return mSerialNumber;

}

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

// UntrustedCertificateInfoBase::validFrom()

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

//

const QDateTime UntrustedCertificateInfoBase::validFrom() const

{

    return mValidFrom;

}

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

// UntrustedCertificateInfoBase::validTo()

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

//

const QDateTime UntrustedCertificateInfoBase::validTo() const

{

    return mValidTo;

}

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

// UntrustedCertificateInfoBase::format()

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

//

const QString UntrustedCertificateInfoBase::format() const

{

    QString format;

    switch (mFormat) {

        case X509Certificate:

            //: Type name for X509 certificates displayed in certificate details.

            // TODO: localised UI string

            format = tr("X.509");

            break;

        default:

            //: Type name for unknown certificates displayed in certificate details.

            // TODO: localised UI string

            format = tr("Unknown");

            break;

    }

    return format;

}

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

// UntrustedCertificateInfoBase::digestAlgorithm()

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

//

const QString UntrustedCertificateInfoBase::digestAlgorithm() const

{

    return algorithmName(mDigestAlgorithm);

}

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

// UntrustedCertificateInfoBase::AsymmetricAlgorithm()

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

//

const QString UntrustedCertificateInfoBase::asymmetricAlgorithm() const

{

    return algorithmName(mAsymmetricAlgorithm);

}

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

// UntrustedCertificateInfoBase::AsymmetricAlgorithm()

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

//

const QString UntrustedCertificateInfoBase::combinedAlgorithmName() const

{

    if (mDigestAlgorithm != Unknown && mAsymmetricAlgorithm != Unknown) {

        //: Format to combine digest and asymmetric algorithm names.

        //: %1 is digest (signing) and %2 is asymmetric (public-key) algorithm.

        // TODO: localised UI string needed

        return tr("%1%2").arg(digestAlgorithm()).arg(asymmetricAlgorithm());

    }

    //: Algorithm name for unknown algorithm.

    // TODO: localised UI string needed

    return tr("Unknown");

}

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

// UntrustedCertificateInfoBase::formattedFingerprint()

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

//

const QString UntrustedCertificateInfoBase::formattedFingerprint(

    const QByteArray &byteArray) const

{

    QString formatted;

    QString number;

    int blockIndex = 0;

    int count = byteArray.count();

    for (int index = 0; index < count; ++index) {

        if (blockIndex == KCharsPerBlock) {

            formatted.append(KBlockSeparator);

            blockIndex = 0;

        }

        number.sprintf(KHexNumberFormatTwoDigitsWithLeadingZeroes,

            static_cast<unsigned char>(byteArray.at(index)));

        formatted.append(number);

        ++blockIndex;

    }

    return formatted;

}

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

// UntrustedCertificateInfoBase::formattedSerialNumber()

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

//

const QString UntrustedCertificateInfoBase::formattedSerialNumber(

    const QByteArray &serialNumber) const

{

    QString formatted;

    QString number;

    int count = serialNumber.count();

    for (int index = 0; index < count; ++index) {

        number.sprintf(KHexNumberFormatSimple,

            static_cast<unsigned char>(serialNumber.at(index)));

        formatted.append(number);

    }

    return formatted;

}

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

// UntrustedCertificateInfoBase::isDateValid()

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

//

bool UntrustedCertificateInfoBase::isDateValid() const

{

    QDateTime current = QDateTime::currentDateTime();

    return (mValidFrom <= current && mValidTo >= current);

}

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

// UntrustedCertificateInfoBase::algorithmName()

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

//

const QString UntrustedCertificateInfoBase::algorithmName(Algorithm algorithm) const

{

    QString name;

    switch (algorithm) {

        case RSA:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("RSA");

            break;

        case DSA:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("DSA");

            break;

        case DH:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("DH");

            break;

        case MD2:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("MD2");

            break;

        case MD5:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("MD5");

            break;

        case SHA1:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("SHA1");

            break;

        case SHA224:

        case SHA256:

        case SHA384:

        case SHA512:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("SHA2");

            break;

        case Unknown:

        default:

            //: Certificate details algorithm name

            // TODO: localized UI string

            name = tr("Unknown");

            break;

    }

    return name;

}