qtlsbackend_st.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtlsbackend_st_p.h"
#include "qtlskey_st_p.h"
#include "qx509_st_p.h"
#include "qtls_st_p.h"
 
#include <QtCore/qsysinfo.h>
#include <QtCore/qmutex.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_GLOBAL_STATIC(QRecursiveMutex, qt_securetransport_mutex)
 
Q_LOGGING_CATEGORY(lcSecureTransport, "qt.tlsbackend.securetransport");
 
namespace QTlsPrivate {
 
QList<QSslCertificate> systemCaCertificates(); // defined in qsslsocket_mac_shared.cpp
 
SSLContextRef qt_createSecureTransportContext(QSslSocket::SslMode mode);
 
QSslCipher QSslCipher_from_SSLCipherSuite(SSLCipherSuite cipher)
{
    QString name;
    switch (cipher) {
    // Sorted as in CipherSuite.h (and groupped by their RFC)
    // TLS addenda using AES, per RFC 3268
    case TLS_RSA_WITH_AES_128_CBC_SHA:
        name = "AES128-SHA"_L1;
        break;
    case TLS_DHE_RSA_WITH_AES_128_CBC_SHA:
        name = "DHE-RSA-AES128-SHA"_L1;
        break;
    case TLS_RSA_WITH_AES_256_CBC_SHA:
        name = "AES256-SHA"_L1;
        break;
    case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
        name = "DHE-RSA-AES256-SHA"_L1;
        break;
 
    // ECDSA addenda, RFC 4492
    case TLS_ECDH_ECDSA_WITH_NULL_SHA:
        name = "ECDH-ECDSA-NULL-SHA"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_RC4_128_SHA:
        name = "ECDH-ECDSA-RC4-SHA"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA:
        name = "ECDH-ECDSA-DES-CBC3-SHA"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA:
        name = "ECDH-ECDSA-AES128-SHA"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA:
        name = "ECDH-ECDSA-AES256-SHA"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_NULL_SHA:
        name = "ECDHE-ECDSA-NULL-SHA"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:
        name = "ECDHE-ECDSA-RC4-SHA"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA:
        name = "ECDHE-ECDSA-DES-CBC3-SHA"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:
        name = "ECDHE-ECDSA-AES128-SHA"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:
        name = "ECDHE-ECDSA-AES256-SHA"_L1;
        break;
    case TLS_ECDH_RSA_WITH_NULL_SHA:
        name = "ECDH-RSA-NULL-SHA"_L1;
        break;
    case TLS_ECDH_RSA_WITH_RC4_128_SHA:
        name = "ECDH-RSA-RC4-SHA"_L1;
        break;
    case TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA:
        name = "ECDH-RSA-DES-CBC3-SHA"_L1;
        break;
    case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA:
        name = "ECDH-RSA-AES128-SHA"_L1;
        break;
    case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA:
        name = "ECDH-RSA-AES256-SHA"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_NULL_SHA:
        name = "ECDHE-RSA-NULL-SHA"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_RC4_128_SHA:
        name = "ECDHE-RSA-RC4-SHA"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:
        name = "ECDHE-RSA-DES-CBC3-SHA"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:
        name = "ECDHE-RSA-AES128-SHA"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
        name = "ECDHE-RSA-AES256-SHA"_L1;
        break;
 
    // TLS 1.2 addenda, RFC 5246
    case TLS_RSA_WITH_3DES_EDE_CBC_SHA:
        name = "DES-CBC3-SHA"_L1;
        break;
    case TLS_RSA_WITH_AES_128_CBC_SHA256:
        name = "AES128-SHA256"_L1;
        break;
    case TLS_RSA_WITH_AES_256_CBC_SHA256:
        name = "AES256-SHA256"_L1;
        break;
    case TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
        name = "DHE-RSA-DES-CBC3-SHA"_L1;
        break;
    case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:
        name = "DHE-RSA-AES128-SHA256"_L1;
        break;
    case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:
        name = "DHE-RSA-AES256-SHA256"_L1;
        break;
 
    // Addendum from RFC 4279, TLS PSK
    // all missing atm.
 
    // RFC 4785 - Pre-Shared Key (PSK) Ciphersuites with NULL Encryption
    // all missing atm.
 
    // Addenda from rfc 5288 AES Galois Counter Mode (CGM) Cipher Suites for TLS
    case TLS_RSA_WITH_AES_256_GCM_SHA384:
        name = "AES256-GCM-SHA384"_L1;
        break;
 
    // RFC 5487 - PSK with SHA-256/384 and AES GCM
    // all missing atm.
 
    // Addenda from rfc 5289 Elliptic Curve Cipher Suites with HMAC SHA-256/384
    case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
        name = "ECDHE-ECDSA-AES128-SHA256"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
        name = "ECDHE-ECDSA-AES256-SHA384"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256:
        name = "ECDH-ECDSA-AES128-SHA256"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384:
        name = "ECDH-ECDSA-AES256-SHA384"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
        name = "ECDHE-RSA-AES128-SHA256"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384:
        name = "ECDHE-RSA-AES256-SHA384"_L1;
        break;
    case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256:
        name = "ECDH-RSA-AES128-SHA256"_L1;
        break;
    case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384:
        name = "ECDH-RSA-AES256-SHA384"_L1;
        break;
 
    // Addenda from rfc 5289 Elliptic Curve Cipher Suites
    // with SHA-256/384 and AES Galois Counter Mode (GCM)
    case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
        name = "ECDHE-RSA-AES256-GCM-SHA384"_L1;
        break;
 
    // TLS 1.3 standard cipher suites for ChaCha20+Poly1305.
    // Note: TLS 1.3 ciphersuites do not specify the key exchange
    // algorithm -- they only specify the symmetric ciphers.
    case TLS_AES_128_GCM_SHA256:
        name = "AES128-GCM-SHA256"_L1;
        break;
    case TLS_AES_256_GCM_SHA384:
        name = "AES256-GCM-SHA384"_L1;
        break;
    case TLS_CHACHA20_POLY1305_SHA256:
        name = "CHACHA20-POLY1305-SHA256"_L1;
        break;
    case TLS_AES_128_CCM_SHA256:
        name = "AES128-CCM-SHA256"_L1;
        break;
    case TLS_AES_128_CCM_8_SHA256:
        name = "AES128-CCM8-SHA256"_L1;
        break;
    // Addenda from rfc 5289  Elliptic Curve Cipher Suites with
    // SHA-256/384 and AES Galois Counter Mode (GCM).
    case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
        name = "ECDHE-ECDSA-AES128-GCM-SHA256"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
        name = "ECDHE-ECDSA-AES256-GCM-SHA384"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256:
        name = "ECDH-ECDSA-AES128-GCM-SHA256"_L1;
        break;
    case TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384:
        name = "ECDH-ECDSA-AES256-GCM-SHA384"_L1;
        break;
    case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
        name = "ECDHE-RSA-AES128-GCM-SHA256"_L1;
        break;
    case TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256:
        name = "ECDH-RSA-AES128-GCM-SHA256"_L1;
        break;
    case TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384:
        name = "ECDH-RSA-AES256-GCM-SHA384"_L1;
        break;
    // Addenda from rfc 7905  ChaCha20-Poly1305 Cipher Suites for
    // Transport Layer Security (TLS).
    case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256:
        name = "ECDHE-RSA-CHACHA20-POLY1305-SHA256"_L1;
        break;
    case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256:
        name = "ECDHE-ECDSA-CHACHA20-POLY1305-SHA256"_L1;
        break;
    default:
        return {};
    }
 
    return QTlsBackend::createCiphersuite(name, QSsl::TlsV1_2, "TLSv1.2"_L1);
}
 
} // namespace QTlsPrivate
 
bool QSecureTransportBackend::s_loadedCiphersAndCerts = false;
 
QString QSecureTransportBackend::tlsLibraryVersionString() const
{
    return "Secure Transport, "_L1 + QSysInfo::prettyProductName();
}
 
QString QSecureTransportBackend::tlsLibraryBuildVersionString() const
{
    return tlsLibraryVersionString();
}
 
void QSecureTransportBackend::ensureInitialized() const
{
    const QMutexLocker locker(qt_securetransport_mutex());
    if (s_loadedCiphersAndCerts)
        return;
 
    // We have to set it before setDefaultSupportedCiphers,
    // since this function can trigger static (global)'s initialization
    // and as a result - recursive ensureInitialized call
    // from QSslCertificatePrivate's ctor.
    s_loadedCiphersAndCerts = true;
 
    const QTlsPrivate::QSecureTransportContext context(QTlsPrivate::qt_createSecureTransportContext(QSslSocket::SslClientMode));
    if (context) {
        QList<QSslCipher> ciphers;
        QList<QSslCipher> defaultCiphers;
 
        size_t numCiphers = 0;
        // Fails only if any of parameters is null.
        SSLGetNumberSupportedCiphers(context, &numCiphers);
        QList<SSLCipherSuite> cfCiphers(numCiphers);
        // Fails only if any of parameter is null or number of ciphers is wrong.
        SSLGetSupportedCiphers(context, cfCiphers.data(), &numCiphers);
 
        for (size_t i = 0; i < size_t(cfCiphers.size()); ++i) {
            const QSslCipher ciph(QTlsPrivate::QSslCipher_from_SSLCipherSuite(cfCiphers.at(i)));
            if (!ciph.isNull()) {
                ciphers << ciph;
                if (ciph.usedBits() >= 128)
                    defaultCiphers << ciph;
            }
        }
 
        setDefaultSupportedCiphers(ciphers);
        setDefaultCiphers(defaultCiphers);
 
        if (!QSslSocketPrivate::rootCertOnDemandLoadingSupported())
            setDefaultCaCertificates(systemCaCertificates());
    } else {
        s_loadedCiphersAndCerts = false;
    }
}
 
QString QSecureTransportBackend::backendName() const
{
    return builtinBackendNames[nameIndexSecureTransport];
}
 
QTlsPrivate::TlsKey *QSecureTransportBackend::createKey() const
{
    return new QTlsPrivate::TlsKeySecureTransport;
}
 
QTlsPrivate::X509Certificate *QSecureTransportBackend::createCertificate() const
{
    return new QTlsPrivate::X509CertificateSecureTransport;
}
 
QList<QSslCertificate> QSecureTransportBackend::systemCaCertificates() const
{
    return QTlsPrivate::systemCaCertificates();
}
 
QList<QSsl::SslProtocol> QSecureTransportBackend::supportedProtocols() const
{
    QList<QSsl::SslProtocol> protocols;
 
    protocols << QSsl::AnyProtocol;
    protocols << QSsl::SecureProtocols;
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
    protocols << QSsl::TlsV1_0;
    protocols << QSsl::TlsV1_0OrLater;
    protocols << QSsl::TlsV1_1;
    protocols << QSsl::TlsV1_1OrLater;
QT_WARNING_POP
    protocols << QSsl::TlsV1_2;
    protocols << QSsl::TlsV1_2OrLater;
 
    return protocols;
}
 
QList<QSsl::SupportedFeature> QSecureTransportBackend::supportedFeatures() const
{
    QList<QSsl::SupportedFeature> features;
    features << QSsl::SupportedFeature::ClientSideAlpn;
 
    return features;
}
 
QList<QSsl::ImplementedClass> QSecureTransportBackend::implementedClasses() const
{
    QList<QSsl::ImplementedClass> classes;
    classes << QSsl::ImplementedClass::Socket;
    classes << QSsl::ImplementedClass::Certificate;
    classes << QSsl::ImplementedClass::Key;
 
    return classes;
}
 
QTlsPrivate::X509PemReaderPtr QSecureTransportBackend::X509PemReader() const
{
    return QTlsPrivate::X509CertificateGeneric::certificatesFromPem;
}
 
QTlsPrivate::X509DerReaderPtr QSecureTransportBackend::X509DerReader() const
{
    return QTlsPrivate::X509CertificateGeneric::certificatesFromDer;
}
 
QTlsPrivate::TlsCryptograph *QSecureTransportBackend::createTlsCryptograph() const
{
    return new QTlsPrivate::TlsCryptographSecureTransport;
}
 
QT_END_NAMESPACE
 
 
#include "moc_qtlsbackend_st_p.cpp"