/****************************************************************************

**

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

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtNetwork module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

//#define QSSLSOCKET_DEBUG

#include "qsslsocket_openssl_p.h"

#include "qsslsocket_openssl_symbols_p.h"

#include "qsslsocket.h"

#include "qsslcertificate_p.h"

#include "qsslcipher_p.h"

#include <QtCore/qdatetime.h>

#include <QtCore/qdebug.h>

#include <QtCore/qdir.h>

#include <QtCore/qdiriterator.h>

#include <QtCore/qfile.h>

#include <QtCore/qfileinfo.h>

#include <QtCore/qmutex.h>

#include <QtCore/qthread.h>

#include <QtCore/qurl.h>

#include <QtCore/qvarlengtharray.h>

#include <QLibrary> // for loading the security lib for the CA store

QT_BEGIN_NAMESPACE

#if defined(Q_OS_MAC)

#define kSecTrustSettingsDomainSystem 2 // so we do not need to include the header file

    PtrSecCertificateGetData QSslSocketPrivate::ptrSecCertificateGetData = 0;

    PtrSecTrustSettingsCopyCertificates QSslSocketPrivate::ptrSecTrustSettingsCopyCertificates = 0;

    PtrSecTrustCopyAnchorCertificates QSslSocketPrivate::ptrSecTrustCopyAnchorCertificates = 0;

#elif defined(Q_OS_WIN)

    PtrCertOpenSystemStoreW QSslSocketPrivate::ptrCertOpenSystemStoreW = 0;

    PtrCertFindCertificateInStore QSslSocketPrivate::ptrCertFindCertificateInStore = 0;

    PtrCertCloseStore QSslSocketPrivate::ptrCertCloseStore = 0;

#elif defined(Q_OS_SYMBIAN)

#include <QtCore/private/qcore_symbian_p.h>

#endif

bool QSslSocketPrivate::s_libraryLoaded = false;

bool QSslSocketPrivate::s_loadedCiphersAndCerts = false;

// Useful defines

#define SSL_ERRORSTR() QString::fromLocal8Bit(q_ERR_error_string(q_ERR_get_error(), NULL))

/* \internal

    From OpenSSL's thread(3) manual page:

    OpenSSL can safely be used in multi-threaded applications provided that at

    least two callback functions are set.

    locking_function(int mode, int n, const char *file, int line) is needed to

    perform locking on shared data structures.  (Note that OpenSSL uses a

    number of global data structures that will be implicitly shared

    when-whenever ever multiple threads use OpenSSL.)  Multi-threaded

    applications will crash at random if it is not set.  ...

    ...

    id_function(void) is a function that returns a thread ID. It is not

    needed on Windows nor on platforms where getpid() returns a different

    ID for each thread (most notably Linux)

*/

class QOpenSslLocks

{

public:

    inline QOpenSslLocks()

        : initLocker(QMutex::Recursive),

          locksLocker(QMutex::Recursive)

    {

        QMutexLocker locker(&locksLocker);

        int numLocks = q_CRYPTO_num_locks();

        locks = new QMutex *[numLocks];

        memset(locks, 0, numLocks * sizeof(QMutex *));

    }

    inline ~QOpenSslLocks()

    {

        QMutexLocker locker(&locksLocker);

        for (int i = 0; i < q_CRYPTO_num_locks(); ++i)

            delete locks[i];

        delete [] locks;

        QSslSocketPrivate::deinitialize();

    }

    inline QMutex *lock(int num)

    {

        QMutexLocker locker(&locksLocker);

        QMutex *tmp = locks[num];

        if (!tmp)

            tmp = locks[num] = new QMutex(QMutex::Recursive);

        return tmp;

    }

    QMutex *globalLock()

    {

        return &locksLocker;

    }

    QMutex *initLock()

    {

        return &initLocker;

    }

private:

    QMutex initLocker;

    QMutex locksLocker;

    QMutex **locks;

};

Q_GLOBAL_STATIC(QOpenSslLocks, openssl_locks)

extern "C" {

static void locking_function(int mode, int lockNumber, const char *, int)

{

    QMutex *mutex = openssl_locks()->lock(lockNumber);

    // Lock or unlock it

    if (mode & CRYPTO_LOCK)

        mutex->lock();

    else

        mutex->unlock();

}

static unsigned long id_function()

{

    return (quintptr)QThread::currentThreadId();

}

} // extern "C"

QSslSocketBackendPrivate::QSslSocketBackendPrivate()

    : ssl(0),

      ctx(0),

      pkey(0),

      readBio(0),

      writeBio(0),

      session(0)

{

    // Calls SSL_library_init().

    ensureInitialized();

}

QSslSocketBackendPrivate::~QSslSocketBackendPrivate()

{

}

QSslCipher QSslSocketBackendPrivate::QSslCipher_from_SSL_CIPHER(SSL_CIPHER *cipher)

{

    QSslCipher ciph;

    char buf [256];

    QString descriptionOneLine = QString::fromLatin1(q_SSL_CIPHER_description(cipher, buf, sizeof(buf)));

    QStringList descriptionList = descriptionOneLine.split(QLatin1String(" "), QString::SkipEmptyParts);

    if (descriptionList.size() > 5) {

        // ### crude code.

        ciph.d->isNull = false;

        ciph.d->name = descriptionList.at(0);

        QString protoString = descriptionList.at(1);

        ciph.d->protocolString = protoString;

        ciph.d->protocol = QSsl::UnknownProtocol;

        if (protoString == QLatin1String("SSLv3"))

            ciph.d->protocol = QSsl::SslV3;

        else if (protoString == QLatin1String("SSLv2"))

            ciph.d->protocol = QSsl::SslV2;

        else if (protoString == QLatin1String("TLSv1"))

            ciph.d->protocol = QSsl::TlsV1;

        if (descriptionList.at(2).startsWith(QLatin1String("Kx=")))

            ciph.d->keyExchangeMethod = descriptionList.at(2).mid(3);

        if (descriptionList.at(3).startsWith(QLatin1String("Au=")))

            ciph.d->authenticationMethod = descriptionList.at(3).mid(3);

        if (descriptionList.at(4).startsWith(QLatin1String("Enc=")))

            ciph.d->encryptionMethod = descriptionList.at(4).mid(4);

        ciph.d->exportable = (descriptionList.size() > 6 && descriptionList.at(6) == QLatin1String("export"));

        ciph.d->bits = cipher->strength_bits;

        ciph.d->supportedBits = cipher->alg_bits;

    }

    return ciph;

}

// ### This list is shared between all threads, and protected by a

// mutex. Investigate using thread local storage instead.

struct QSslErrorList

{

    QMutex mutex;

    QList<QPair<int, int> > errors;

};

Q_GLOBAL_STATIC(QSslErrorList, _q_sslErrorList)

static int q_X509Callback(int ok, X509_STORE_CTX *ctx)

{

    if (!ok) {

        // Store the error and at which depth the error was detected.

        _q_sslErrorList()->errors << qMakePair<int, int>(ctx->error, ctx->error_depth);

    }

    // Always return OK to allow verification to continue. We're handle the

    // errors gracefully after collecting all errors, after verification has

    // completed.

    return 1;

}

bool QSslSocketBackendPrivate::initSslContext()

{

    Q_Q(QSslSocket);

    // Create and initialize SSL context. Accept SSLv2, SSLv3 and TLSv1.

    bool client = (mode == QSslSocket::SslClientMode);

    bool reinitialized = false;

init_context:

    switch (configuration.protocol) {

    case QSsl::SslV2:

        ctx = q_SSL_CTX_new(client ? q_SSLv2_client_method() : q_SSLv2_server_method());

        break;

    case QSsl::SslV3:

        ctx = q_SSL_CTX_new(client ? q_SSLv3_client_method() : q_SSLv3_server_method());

        break;

    case QSsl::AnyProtocol:

    default:

        ctx = q_SSL_CTX_new(client ? q_SSLv23_client_method() : q_SSLv23_server_method());

        break;

    case QSsl::TlsV1:

        ctx = q_SSL_CTX_new(client ? q_TLSv1_client_method() : q_TLSv1_server_method());

        break;

    }

    if (!ctx) {

        // After stopping Flash 10 the SSL library looses its ciphers. Try re-adding them

        // by re-initializing the library.

        if (!reinitialized) {

            reinitialized = true;

            if (q_SSL_library_init() == 1)

                goto init_context;

        }

        // ### Bad error code

        q->setErrorString(QSslSocket::tr("Error creating SSL context (%1)").arg(SSL_ERRORSTR()));

        q->setSocketError(QAbstractSocket::UnknownSocketError);

        emit q->error(QAbstractSocket::UnknownSocketError);

        return false;

    }

    // Enable all bug workarounds.

    q_SSL_CTX_set_options(ctx, SSL_OP_ALL);

    // Initialize ciphers

    QByteArray cipherString;

    int first = true;

    QList<QSslCipher> ciphers = configuration.ciphers;

    if (ciphers.isEmpty())

        ciphers = defaultCiphers();

    foreach (const QSslCipher &cipher, ciphers) {

        if (first)

            first = false;

        else

            cipherString.append(':');

        cipherString.append(cipher.name().toLatin1());

    }

    if (!q_SSL_CTX_set_cipher_list(ctx, cipherString.data())) {

        // ### Bad error code

        q->setErrorString(QSslSocket::tr("Invalid or empty cipher list (%1)").arg(SSL_ERRORSTR()));

        q->setSocketError(QAbstractSocket::UnknownSocketError);

        emit q->error(QAbstractSocket::UnknownSocketError);

        return false;

    }

    // Add all our CAs to this store.

    QList<QSslCertificate> expiredCerts;

    foreach (const QSslCertificate &caCertificate, q->caCertificates()) {

        // add expired certs later, so that the

        // valid ones are used before the expired ones

        if (! caCertificate.isValid()) {

            expiredCerts.append(caCertificate);

        } else {

            q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle());

        }

    }

    // now add the expired certs

    foreach (const QSslCertificate &caCertificate, expiredCerts) {

        q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle());

    }

    // Register a custom callback to get all verification errors.

    X509_STORE_set_verify_cb_func(ctx->cert_store, q_X509Callback);

    if (!configuration.localCertificate.isNull()) {

        // Require a private key as well.

        if (configuration.privateKey.isNull()) {

            q->setErrorString(QSslSocket::tr("Cannot provide a certificate with no key, %1").arg(SSL_ERRORSTR()));

            emit q->error(QAbstractSocket::UnknownSocketError);

            return false;

        }

        // Load certificate

        if (!q_SSL_CTX_use_certificate(ctx, (X509 *)configuration.localCertificate.handle())) {

            q->setErrorString(QSslSocket::tr("Error loading local certificate, %1").arg(SSL_ERRORSTR()));

            emit q->error(QAbstractSocket::UnknownSocketError);

            return false;

        }

        // Load private key

        pkey = q_EVP_PKEY_new();

        // before we were using EVP_PKEY_assign_R* functions and did not use EVP_PKEY_free.

        // this lead to a memory leak. Now we use the *_set1_* functions which do not

        // take ownership of the RSA/DSA key instance because the QSslKey already has ownership.

        if (configuration.privateKey.algorithm() == QSsl::Rsa)

            q_EVP_PKEY_set1_RSA(pkey, (RSA *)configuration.privateKey.handle());

        else

            q_EVP_PKEY_set1_DSA(pkey, (DSA *)configuration.privateKey.handle());

        if (!q_SSL_CTX_use_PrivateKey(ctx, pkey)) {

            q->setErrorString(QSslSocket::tr("Error loading private key, %1").arg(SSL_ERRORSTR()));

            emit q->error(QAbstractSocket::UnknownSocketError);

            return false;

        }

        // Check if the certificate matches the private key.

        if (!q_SSL_CTX_check_private_key(ctx)) {

            q->setErrorString(QSslSocket::tr("Private key does not certify public key, %1").arg(SSL_ERRORSTR()));

            emit q->error(QAbstractSocket::UnknownSocketError);

            return false;

        }

    }

    // Initialize peer verification.

    if (configuration.peerVerifyMode == QSslSocket::VerifyNone) {

        q_SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);

    } else {

        q_SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, q_X509Callback);

    }

    // Set verification depth.

    if (configuration.peerVerifyDepth != 0)

        q_SSL_CTX_set_verify_depth(ctx, configuration.peerVerifyDepth);

    // Create and initialize SSL session

    if (!(ssl = q_SSL_new(ctx))) {

        // ### Bad error code

        q->setErrorString(QSslSocket::tr("Error creating SSL session, %1").arg(SSL_ERRORSTR()));

        q->setSocketError(QAbstractSocket::UnknownSocketError);

        emit q->error(QAbstractSocket::UnknownSocketError);

        return false;

    }

    // Clear the session.

    q_SSL_clear(ssl);

    errorList.clear();

    // Initialize memory BIOs for encryption and decryption.

    readBio = q_BIO_new(q_BIO_s_mem());

    writeBio = q_BIO_new(q_BIO_s_mem());

    if (!readBio || !writeBio) {

        // ### Bad error code

        q->setErrorString(QSslSocket::tr("Error creating SSL session: %1").arg(SSL_ERRORSTR()));

        q->setSocketError(QAbstractSocket::UnknownSocketError);

        emit q->error(QAbstractSocket::UnknownSocketError);

        return false;

    }

    // Assign the bios.

    q_SSL_set_bio(ssl, readBio, writeBio);

    if (mode == QSslSocket::SslClientMode)

        q_SSL_set_connect_state(ssl);

    else

        q_SSL_set_accept_state(ssl);

    return true;

}

/*!

    \internal

*/

void QSslSocketPrivate::deinitialize()

{

    q_CRYPTO_set_id_callback(0);

    q_CRYPTO_set_locking_callback(0);

}

/*!

    \internal

    Does the minimum amount of initialization to determine whether SSL

    is supported or not.

*/

bool QSslSocketPrivate::supportsSsl()

{

    return ensureLibraryLoaded();

}

bool QSslSocketPrivate::ensureLibraryLoaded()

{

    if (!q_resolveOpenSslSymbols())

        return false;

    // Check if the library itself needs to be initialized.

    QMutexLocker locker(openssl_locks()->initLock());

    if (!s_libraryLoaded) {

        s_libraryLoaded = true;

        // Initialize OpenSSL.

        q_CRYPTO_set_id_callback(id_function);

        q_CRYPTO_set_locking_callback(locking_function);

        if (q_SSL_library_init() != 1)

            return false;

        q_SSL_load_error_strings();

        q_OpenSSL_add_all_algorithms();

        // Initialize OpenSSL's random seed.

        if (!q_RAND_status()) {

            struct {

                int msec;

                int sec;

                void *stack;

            } randomish;

            int attempts = 500;

            do {

                if (attempts < 500) {

#ifdef Q_OS_UNIX

                    struct timespec ts = {0, 33333333};

                    nanosleep(&ts, 0);

#else

                    Sleep(3);

#endif

                    randomish.msec = attempts;

                }

                randomish.stack = (void *)&randomish;

                randomish.msec = QTime::currentTime().msec();

                randomish.sec = QTime::currentTime().second();

                q_RAND_seed((const char *)&randomish, sizeof(randomish));

            } while (!q_RAND_status() && --attempts);

            if (!attempts)

                return false;

        }

    }

    return true;

}

void QSslSocketPrivate::ensureCiphersAndCertsLoaded()

{

    QMutexLocker locker(openssl_locks()->initLock());

    if (s_loadedCiphersAndCerts)

        return;

    s_loadedCiphersAndCerts = true;

    resetDefaultCiphers();

    //load symbols needed to receive certificates from system store

#if defined(Q_OS_MAC)

    QLibrary securityLib("/System/Library/Frameworks/Security.framework/Versions/Current/Security");

    if (securityLib.load()) {

        ptrSecCertificateGetData = (PtrSecCertificateGetData) securityLib.resolve("SecCertificateGetData");

        if (!ptrSecCertificateGetData)

            qWarning("could not resolve symbols in security library"); // should never happen

        ptrSecTrustSettingsCopyCertificates = (PtrSecTrustSettingsCopyCertificates) securityLib.resolve("SecTrustSettingsCopyCertificates");

        if (!ptrSecTrustSettingsCopyCertificates) { // method was introduced in Leopard, use legacy method if it's not there

            ptrSecTrustCopyAnchorCertificates = (PtrSecTrustCopyAnchorCertificates) securityLib.resolve("SecTrustCopyAnchorCertificates");

            if (!ptrSecTrustCopyAnchorCertificates)

                qWarning("could not resolve symbols in security library"); // should never happen

        }

    } else {

        qWarning("could not load security library");

    }

#elif defined(Q_OS_WIN)

    HINSTANCE hLib = LoadLibraryW(L"Crypt32");

    if (hLib) {

#if defined(Q_OS_WINCE)

        ptrCertOpenSystemStoreW = (PtrCertOpenSystemStoreW)GetProcAddress(hLib, L"CertOpenStore");

        ptrCertFindCertificateInStore = (PtrCertFindCertificateInStore)GetProcAddress(hLib, L"CertFindCertificateInStore");

        ptrCertCloseStore = (PtrCertCloseStore)GetProcAddress(hLib, L"CertCloseStore");

#else

        ptrCertOpenSystemStoreW = (PtrCertOpenSystemStoreW)GetProcAddress(hLib, "CertOpenSystemStoreW");

        ptrCertFindCertificateInStore = (PtrCertFindCertificateInStore)GetProcAddress(hLib, "CertFindCertificateInStore");

        ptrCertCloseStore = (PtrCertCloseStore)GetProcAddress(hLib, "CertCloseStore");

#endif

        if (!ptrCertOpenSystemStoreW || !ptrCertFindCertificateInStore || !ptrCertCloseStore)

            qWarning("could not resolve symbols in crypt32 library"); // should never happen

    } else {

        qWarning("could not load crypt32 library"); // should never happen

    }

#endif

    setDefaultCaCertificates(systemCaCertificates());