6998ed4c96
For auto-tests that were temporarily disabled. Similar to network-settings.h, header-only stuff. Fixes: QTBUG-92866 Fixes: QTBUG-92877 Change-Id: I15b5c0b41f0d8bfe59b09c844884ff6d99e6d41a Reviewed-by: Edward Welbourne <edward.welbourne@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
840 lines
30 KiB
C++
840 lines
30 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2018 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include <QTest>
|
|
#include <QTestEventLoop>
|
|
|
|
#include <QtNetwork/private/qtnetworkglobal_p.h>
|
|
|
|
#include "../shared/qopenssl_symbols.h"
|
|
|
|
#include <QtNetwork/qsslcertificate.h>
|
|
#include <QtNetwork/qocspresponse.h>
|
|
#include <QtNetwork/qtcpserver.h>
|
|
#include <QtNetwork/qsslerror.h>
|
|
#include <QtNetwork/qsslkey.h>
|
|
#include <QtNetwork/qssl.h>
|
|
|
|
#include <QtCore/qsharedpointer.h>
|
|
#include <QtCore/qbytearray.h>
|
|
#include <QtCore/qfileinfo.h>
|
|
#include <QtCore/qstring.h>
|
|
#include <QtCore/qfile.h>
|
|
#include <QtCore/qlist.h>
|
|
#include <QtCore/qdir.h>
|
|
|
|
#include <openssl/ocsp.h>
|
|
|
|
#include <algorithm>
|
|
#include <utility>
|
|
|
|
// NOTE: the word 'subject' in the code below means the subject of a status request,
|
|
// so in general it's our peer's certificate we are asking about.
|
|
|
|
using SslError = QT_PREPEND_NAMESPACE(QSslError);
|
|
using VectorOfErrors = QT_PREPEND_NAMESPACE(QList<SslError>);
|
|
using Latin1String = QT_PREPEND_NAMESPACE(QLatin1String);
|
|
|
|
Q_DECLARE_METATYPE(SslError)
|
|
Q_DECLARE_METATYPE(Latin1String)
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
namespace {
|
|
|
|
using OcspResponse = QSharedPointer<OCSP_RESPONSE>;
|
|
using BasicResponse = QSharedPointer<OCSP_BASICRESP>;
|
|
using SingleResponse = QSharedPointer<OCSP_SINGLERESP>;
|
|
using CertId = QSharedPointer<OCSP_CERTID>;
|
|
using EvpKey = QSharedPointer<EVP_PKEY>;
|
|
using Asn1Time = QSharedPointer<ASN1_TIME>;
|
|
using CertificateChain = QList<QSslCertificate>;
|
|
using NativeX509Ptr = X509 *;
|
|
|
|
class X509Stack {
|
|
public:
|
|
explicit X509Stack(const QList<QSslCertificate> &chain);
|
|
|
|
~X509Stack();
|
|
|
|
int size() const;
|
|
X509 *operator[](int index) const;
|
|
operator STACK_OF(X509) *() const;
|
|
|
|
private:
|
|
OPENSSL_STACK *stack = nullptr;
|
|
|
|
Q_DISABLE_COPY(X509Stack)
|
|
};
|
|
|
|
X509Stack::X509Stack(const QList<QSslCertificate> &chain)
|
|
{
|
|
if (!chain.size())
|
|
return;
|
|
|
|
stack = q_OPENSSL_sk_new_null();
|
|
if (!stack)
|
|
return;
|
|
|
|
for (const QSslCertificate &cert : chain) {
|
|
X509 *nativeCert = NativeX509Ptr(cert.handle());
|
|
if (!nativeCert)
|
|
continue;
|
|
q_OPENSSL_sk_push(stack, nativeCert);
|
|
q_X509_up_ref(nativeCert);
|
|
}
|
|
}
|
|
|
|
X509Stack::~X509Stack()
|
|
{
|
|
if (stack)
|
|
q_OPENSSL_sk_pop_free(stack, reinterpret_cast<void(*)(void*)>(q_X509_free));
|
|
}
|
|
|
|
int X509Stack::size() const
|
|
{
|
|
if (stack)
|
|
return q_OPENSSL_sk_num(stack);
|
|
return 0;
|
|
}
|
|
|
|
X509 *X509Stack::operator[](int index) const
|
|
{
|
|
return NativeX509Ptr(q_OPENSSL_sk_value(stack, index));
|
|
}
|
|
|
|
X509Stack::operator STACK_OF(X509) *() const
|
|
{
|
|
return reinterpret_cast<STACK_OF(X509)*>(stack);
|
|
}
|
|
|
|
struct OcspTimeStamp
|
|
{
|
|
OcspTimeStamp() = default;
|
|
OcspTimeStamp(long secondsBeforeNow, long secondsAfterNow);
|
|
|
|
static Asn1Time timeToAsn1Time(long adjustment);
|
|
|
|
Asn1Time thisUpdate;
|
|
Asn1Time nextUpdate;
|
|
};
|
|
|
|
OcspTimeStamp::OcspTimeStamp(long secondsBeforeNow, long secondsAfterNow)
|
|
{
|
|
Asn1Time start = timeToAsn1Time(secondsBeforeNow);
|
|
Asn1Time end = timeToAsn1Time(secondsAfterNow);
|
|
if (start.data() && end.data()) {
|
|
thisUpdate.swap(start);
|
|
nextUpdate.swap(end);
|
|
}
|
|
}
|
|
|
|
Asn1Time OcspTimeStamp::timeToAsn1Time(long adjustment)
|
|
{
|
|
if (ASN1_TIME *adjusted = q_X509_gmtime_adj(nullptr, adjustment))
|
|
return Asn1Time(adjusted, q_ASN1_TIME_free);
|
|
return Asn1Time{};
|
|
}
|
|
|
|
struct OcspResponder
|
|
{
|
|
OcspResponder(const OcspTimeStamp &stamp, const CertificateChain &subjs,
|
|
const CertificateChain &respChain, const QSslKey &respPKey);
|
|
|
|
QByteArray buildResponse(int responseStatus, int certificateStatus) const;
|
|
static EvpKey privateKeyToEVP_PKEY(const QSslKey &privateKey);
|
|
static CertId certificateToCertId(X509 *subject, X509 *issuer);
|
|
static QByteArray responseToDer(OCSP_RESPONSE *response);
|
|
|
|
OcspTimeStamp timeStamp;
|
|
// Plural, we can send a 'wrong' BasicResponse containing more than
|
|
// 1 SingleResponse.
|
|
X509Stack subjects;
|
|
X509Stack responderChain;
|
|
QSslKey responderKey;
|
|
};
|
|
|
|
OcspResponder::OcspResponder(const OcspTimeStamp &stamp, const CertificateChain &subjs,
|
|
const CertificateChain &respChain, const QSslKey &respPKey)
|
|
: timeStamp(stamp),
|
|
subjects(subjs),
|
|
responderChain(respChain),
|
|
responderKey(respPKey)
|
|
{
|
|
}
|
|
|
|
QByteArray OcspResponder::buildResponse(int responseStatus, int certificateStatus) const
|
|
{
|
|
if (responseStatus != OCSP_RESPONSE_STATUS_SUCCESSFUL) {
|
|
OCSP_RESPONSE *response = q_OCSP_response_create(responseStatus, nullptr);
|
|
if (!response)
|
|
return {};
|
|
const OcspResponse rGuard(response, q_OCSP_RESPONSE_free);
|
|
return responseToDer(response);
|
|
}
|
|
|
|
Q_ASSERT(subjects.size() && responderChain.size() && responderKey.handle());
|
|
|
|
const EvpKey nativeKey = privateKeyToEVP_PKEY(responderKey);
|
|
if (!nativeKey.data())
|
|
return {};
|
|
|
|
OCSP_BASICRESP *basicResponse = q_OCSP_BASICRESP_new();
|
|
if (!basicResponse)
|
|
return {};
|
|
const BasicResponse brGuard(basicResponse, q_OCSP_BASICRESP_free);
|
|
|
|
for (int i = 0, e = subjects.size(); i < e; ++i) {
|
|
X509 *subject = subjects[i];
|
|
Q_ASSERT(subject);
|
|
CertId certId = certificateToCertId(subject, responderChain[0]);
|
|
if (!certId.data())
|
|
return {};
|
|
|
|
// NOTE: we do not own this 'singleResponse':
|
|
ASN1_TIME *revisionTime = certificateStatus == V_OCSP_CERTSTATUS_REVOKED ?
|
|
timeStamp.thisUpdate.data() : nullptr;
|
|
|
|
if (!q_OCSP_basic_add1_status(basicResponse, certId.data(), certificateStatus, 0, revisionTime,
|
|
timeStamp.thisUpdate.data(), timeStamp.nextUpdate.data())) {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
if (q_OCSP_basic_sign(basicResponse, responderChain[0], nativeKey.data(), q_EVP_sha1(),
|
|
responderChain, 0) != 1) {
|
|
return {};
|
|
}
|
|
|
|
OCSP_RESPONSE *ocspResponse = q_OCSP_response_create(OCSP_RESPONSE_STATUS_SUCCESSFUL, basicResponse);
|
|
if (!ocspResponse)
|
|
return {};
|
|
const OcspResponse rGuard(ocspResponse, q_OCSP_RESPONSE_free);
|
|
return responseToDer(ocspResponse);
|
|
}
|
|
|
|
EvpKey OcspResponder::privateKeyToEVP_PKEY(const QSslKey &privateKey)
|
|
{
|
|
const EvpKey nullKey;
|
|
if (privateKey.isNull() || privateKey.algorithm() != QSsl::Rsa) {
|
|
// We use only RSA keys in this auto-test, since we test OCSP only,
|
|
// not handshake/TLS in general.
|
|
return nullKey;
|
|
}
|
|
|
|
EVP_PKEY *nativeKey = q_EVP_PKEY_new();
|
|
if (!nativeKey)
|
|
return nullKey;
|
|
|
|
const EvpKey keyGuard(nativeKey, q_EVP_PKEY_free);
|
|
if (!q_EVP_PKEY_set1_RSA(nativeKey, reinterpret_cast<RSA *>(privateKey.handle())))
|
|
return nullKey;
|
|
|
|
return keyGuard;
|
|
}
|
|
|
|
CertId OcspResponder::certificateToCertId(X509 *subject, X509 *issuer)
|
|
{
|
|
const CertId nullId;
|
|
if (!subject || !issuer)
|
|
return nullId;
|
|
|
|
const EVP_MD *digest = q_EVP_sha1();
|
|
if (!digest)
|
|
return nullId;
|
|
|
|
OCSP_CERTID *certId = q_OCSP_cert_to_id(digest, subject, issuer);
|
|
if (!certId)
|
|
return nullId;
|
|
|
|
return CertId(certId, q_OCSP_CERTID_free);
|
|
}
|
|
|
|
QByteArray OcspResponder::responseToDer(OCSP_RESPONSE *response)
|
|
{
|
|
if (!response)
|
|
return {};
|
|
|
|
const int derSize = q_i2d_OCSP_RESPONSE(response, nullptr);
|
|
if (derSize <= 0)
|
|
return {};
|
|
|
|
QByteArray derData(derSize, Qt::Uninitialized);
|
|
unsigned char *pData = reinterpret_cast<unsigned char *>(derData.data());
|
|
const int serializedSize = q_i2d_OCSP_RESPONSE(response, &pData);
|
|
if (serializedSize != derSize)
|
|
return {};
|
|
|
|
return derData;
|
|
}
|
|
|
|
// The QTcpServer capable of sending OCSP status responses.
|
|
class OcspServer : public QTcpServer
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
OcspServer(const CertificateChain &serverChain, const QSslKey &privateKey);
|
|
|
|
void configureResponse(const QByteArray &responseDer);
|
|
QString hostName() const;
|
|
QString peerVerifyName() const;
|
|
|
|
Q_SIGNALS:
|
|
void internalServerError();
|
|
|
|
private:
|
|
void incomingConnection(qintptr descriptor) override;
|
|
|
|
public:
|
|
QSslConfiguration serverConfig;
|
|
QSslSocket serverSocket;
|
|
};
|
|
|
|
OcspServer::OcspServer(const CertificateChain &serverChain, const QSslKey &privateKey)
|
|
{
|
|
Q_ASSERT(serverChain.size());
|
|
Q_ASSERT(!privateKey.isNull());
|
|
|
|
serverConfig = QSslConfiguration::defaultConfiguration();
|
|
serverConfig.setLocalCertificateChain(serverChain);
|
|
serverConfig.setPrivateKey(privateKey);
|
|
}
|
|
|
|
void OcspServer::configureResponse(const QByteArray &responseDer)
|
|
{
|
|
serverConfig.setBackendConfigurationOption("Qt-OCSP-response", responseDer);
|
|
}
|
|
|
|
QString OcspServer::hostName() const
|
|
{
|
|
// It's 'name' and not 'address' to be consistent with QSslSocket's naming style,
|
|
// where it's connectToHostEncrypted(hostName, ...)
|
|
const QHostAddress &addr = serverAddress();
|
|
if (addr == QHostAddress::Any || addr == QHostAddress::AnyIPv4)
|
|
return QStringLiteral("127.0.0.1");
|
|
if (addr == QHostAddress::AnyIPv6)
|
|
return QStringLiteral("::1");
|
|
return addr.toString();
|
|
}
|
|
|
|
QString OcspServer::peerVerifyName() const
|
|
{
|
|
const CertificateChain &localChain = serverConfig.localCertificateChain();
|
|
if (localChain.isEmpty())
|
|
return {};
|
|
const auto cert = localChain.first();
|
|
if (cert.isNull())
|
|
return {};
|
|
|
|
const QStringList &names = cert.subjectInfo(QSslCertificate::CommonName);
|
|
return names.isEmpty() ? QString{} : names.first();
|
|
}
|
|
|
|
void OcspServer::incomingConnection(qintptr socketDescriptor)
|
|
{
|
|
close();
|
|
|
|
if (!serverSocket.setSocketDescriptor(socketDescriptor)) {
|
|
emit internalServerError();
|
|
return;
|
|
}
|
|
|
|
serverSocket.setSslConfiguration(serverConfig);
|
|
// Since we test a client, not a server, we don't care about any
|
|
// possible errors on the server (QAbstractSocket or QSslSocket-related).
|
|
// Thus, we don't connect to any error signal.
|
|
serverSocket.startServerEncryption();
|
|
}
|
|
|
|
} // unnamed namespace
|
|
|
|
class tst_QOcsp : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public slots:
|
|
void initTestCase();
|
|
|
|
private slots:
|
|
void connectSelfSigned();
|
|
void badStatus_data();
|
|
void badStatus();
|
|
void multipleSingleResponses();
|
|
void malformedResponse();
|
|
void expiredResponse_data();
|
|
void expiredResponse();
|
|
void noNextUpdate();
|
|
void wrongCertificateInResponse_data();
|
|
void wrongCertificateInResponse();
|
|
void untrustedResponder();
|
|
|
|
// OCSPTODO: more tests in future ...
|
|
|
|
private:
|
|
void setupOcspClient(QSslSocket &clientSocket, const CertificateChain &trustedCAs,
|
|
const QString &peerName);
|
|
bool containsOcspErrors(const QList<QSslError> &errorsFound) const;
|
|
static bool containsError(const QList<QSslError> &errors, QSslError::SslError code);
|
|
static QByteArray goodResponse(const CertificateChain &subject, const CertificateChain &responder,
|
|
const QSslKey &privateKey, long beforeNow = -1000, long afterNow = 1000);
|
|
static bool loadPrivateKey(const QString &keyName, QSslKey &key);
|
|
static CertificateChain issuerToChain(const CertificateChain &chain);
|
|
static CertificateChain subjectToChain(const CertificateChain &chain);
|
|
|
|
static QString certDirPath;
|
|
|
|
void (QSslSocket::*tlsErrorsSignal)(const QList<QSslError> &) = &QSslSocket::sslErrors;
|
|
void (QTestEventLoop::*exitLoopSlot)() = &QTestEventLoop::exitLoop;
|
|
|
|
const int handshakeTimeoutMS = 500;
|
|
QTestEventLoop loop;
|
|
|
|
std::vector<QSslError::SslError> ocspErrorCodes = {QSslError::OcspNoResponseFound,
|
|
QSslError::OcspMalformedRequest,
|
|
QSslError::OcspMalformedResponse,
|
|
QSslError::OcspInternalError,
|
|
QSslError::OcspTryLater,
|
|
QSslError::OcspSigRequred,
|
|
QSslError::OcspUnauthorized,
|
|
QSslError::OcspResponseCannotBeTrusted,
|
|
QSslError::OcspResponseCertIdUnknown,
|
|
QSslError::OcspResponseExpired,
|
|
QSslError::OcspStatusUnknown};
|
|
};
|
|
|
|
#define QCOMPARE_SINGLE_ERROR(sslSocket, expectedError) \
|
|
const auto &tlsErrors = sslSocket.sslHandshakeErrors(); \
|
|
QCOMPARE(tlsErrors.size(), 1); \
|
|
QCOMPARE(tlsErrors[0].error(), expectedError)
|
|
|
|
#define QVERIFY_HANDSHAKE_WITHOUT_ERRORS(sslSocket) \
|
|
QVERIFY(sslSocket.isEncrypted()); \
|
|
QCOMPARE(sslSocket.state(), QAbstractSocket::ConnectedState); \
|
|
QVERIFY(sslSocket.sslHandshakeErrors().isEmpty())
|
|
|
|
#define QDECLARE_CHAIN(object, chainFileName) \
|
|
CertificateChain object = QSslCertificate::fromPath(certDirPath + QLatin1String(chainFileName)); \
|
|
QVERIFY(object.size())
|
|
|
|
#define QDECLARE_PRIVATE_KEY(key, keyFileName) \
|
|
QSslKey key; \
|
|
QVERIFY(loadPrivateKey(QLatin1String(keyFileName), key))
|
|
|
|
QString tst_QOcsp::certDirPath;
|
|
|
|
void tst_QOcsp::initTestCase()
|
|
{
|
|
// I'm not testing feature here, I need 'openssl', since the test
|
|
// is very OpenSSL-oriented:
|
|
if (QSslSocket::activeBackend() != QStringLiteral("openssl"))
|
|
QSKIP("This test requires the OpenSSL backend");
|
|
|
|
if (!qt_auto_test_resolve_OpenSSL_symbols())
|
|
QSKIP("Failed to resolve OpenSSL symbols required by this test");
|
|
|
|
certDirPath = QFileInfo(QFINDTESTDATA("certs")).absolutePath();
|
|
QVERIFY(certDirPath.size() > 0);
|
|
certDirPath += QDir::separator() + QStringLiteral("certs") + QDir::separator();
|
|
}
|
|
|
|
void tst_QOcsp::connectSelfSigned()
|
|
{
|
|
// This test may look a bit confusing, since we have essentially 1
|
|
// self-signed certificate, which we trust for the purpose of this test,
|
|
// but we also request its (the certificate's) status and then we sign
|
|
// the status response using the same certificate and the corresponding
|
|
// private key. Anyway, we test the very basic things here: we send
|
|
// an OCSP status request, we verify the response (if server has sent it),
|
|
// and detect errors (if any).
|
|
QDECLARE_CHAIN(subjectChain, "ss1.crt");
|
|
QDECLARE_CHAIN(responderChain, "ss1.crt");
|
|
QDECLARE_PRIVATE_KEY(privateKey, "ss1-private.key");
|
|
{
|
|
// This server ignores our status request:
|
|
const QSslError::SslError expectedError = QSslError::OcspNoResponseFound;
|
|
|
|
OcspServer server(subjectChain, privateKey);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
QSslConfiguration clientConfig = QSslConfiguration::defaultConfiguration();
|
|
auto roots = clientConfig.caCertificates();
|
|
setupOcspClient(clientSocket, issuerToChain(subjectChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QCOMPARE_SINGLE_ERROR(clientSocket, expectedError);
|
|
}
|
|
{
|
|
// Now the server will send a valid 'status: good' response.
|
|
OcspServer server(subjectChain, privateKey);
|
|
const QByteArray responseData(goodResponse(subjectChain, responderChain, privateKey));
|
|
QVERIFY(responseData.size());
|
|
server.configureResponse(responseData);
|
|
QVERIFY(server.listen());
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(subjectChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY_HANDSHAKE_WITHOUT_ERRORS(clientSocket);
|
|
|
|
const auto responses = clientSocket.ocspResponses();
|
|
QCOMPARE(responses.size(), 1);
|
|
const auto &response = responses.at(0);
|
|
QVERIFY(response != QOcspResponse());
|
|
const auto copy = response;
|
|
QCOMPARE(copy, response);
|
|
QVERIFY(qHash(response, 0) != 0);
|
|
|
|
QCOMPARE(response.revocationReason(), QOcspRevocationReason::None);
|
|
QCOMPARE(response.certificateStatus(), QOcspCertificateStatus::Good);
|
|
QCOMPARE(response.subject(), clientSocket.peerCertificate());
|
|
QCOMPARE(response.responder(), clientSocket.peerCertificate());
|
|
}
|
|
}
|
|
|
|
void tst_QOcsp::badStatus_data()
|
|
{
|
|
QTest::addColumn<int>("responseStatus");
|
|
QTest::addColumn<int>("certificateStatus");
|
|
QTest::addColumn<QSslError>("expectedError");
|
|
|
|
QTest::addRow("malformed-request") << OCSP_RESPONSE_STATUS_MALFORMEDREQUEST << 1 << QSslError(QSslError::OcspMalformedRequest);
|
|
QTest::addRow("internal-error") << OCSP_RESPONSE_STATUS_INTERNALERROR << 2 << QSslError(QSslError::OcspInternalError);
|
|
QTest::addRow("try-later") << OCSP_RESPONSE_STATUS_TRYLATER << 3 << QSslError(QSslError::OcspTryLater);
|
|
QTest::addRow("signed-request-require") << OCSP_RESPONSE_STATUS_SIGREQUIRED << 2 << QSslError(QSslError::OcspSigRequred);
|
|
QTest::addRow("unauthorized-request") << OCSP_RESPONSE_STATUS_UNAUTHORIZED << 1 <<QSslError(QSslError::OcspUnauthorized);
|
|
|
|
QTest::addRow("certificate-revoked") << OCSP_RESPONSE_STATUS_SUCCESSFUL << V_OCSP_CERTSTATUS_REVOKED
|
|
<< QSslError(QSslError::CertificateRevoked);
|
|
QTest::addRow("status-unknown") << OCSP_RESPONSE_STATUS_SUCCESSFUL << V_OCSP_CERTSTATUS_UNKNOWN
|
|
<< QSslError(QSslError::OcspStatusUnknown);
|
|
}
|
|
|
|
void tst_QOcsp::badStatus()
|
|
{
|
|
// This test works with two types of 'bad' responses:
|
|
// 1. 'Error messages' (the response's status is anything but SUCCESSFUL,
|
|
// no information about the certificate itself, no signature);
|
|
// 2. 'REVOKED' or 'UNKNOWN' status for a certificate in question.
|
|
QFETCH(const int, responseStatus);
|
|
QFETCH(const int, certificateStatus);
|
|
QFETCH(const QSslError, expectedError);
|
|
|
|
QDECLARE_CHAIN(subjectChain, "infbobchain.crt");
|
|
QCOMPARE(subjectChain.size(), 2);
|
|
QDECLARE_CHAIN(responderChain, "ca1.crt");
|
|
QDECLARE_PRIVATE_KEY(subjPrivateKey, "infbob.key");
|
|
QDECLARE_PRIVATE_KEY(respPrivateKey, "ca1.key");
|
|
|
|
OcspServer server(subjectChain, subjPrivateKey);
|
|
const OcspTimeStamp stamp(-1000, 1000);
|
|
OcspResponder builder(stamp, subjectToChain(subjectChain), responderChain, respPrivateKey);
|
|
const QByteArray response(builder.buildResponse(responseStatus, certificateStatus));
|
|
QVERIFY(response.size());
|
|
server.configureResponse(response);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(subjectChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QCOMPARE_SINGLE_ERROR(clientSocket, expectedError.error());
|
|
}
|
|
|
|
void tst_QOcsp::multipleSingleResponses()
|
|
{
|
|
// We handle a response with more than one SingleResponse as malformed:
|
|
const QSslError::SslError expectedError = QSslError::OcspMalformedResponse;
|
|
|
|
// Here we use subjectChain only to generate a response, the server
|
|
// is configured with the responder chain (it's the same cert after all).
|
|
QDECLARE_CHAIN(subjectChain, "ss1.crt");
|
|
QDECLARE_CHAIN(responderChain, "ss1.crt");
|
|
QDECLARE_PRIVATE_KEY(privateKey, "ss1-private.key");
|
|
|
|
// Let's have more than 1 certificate in a chain:
|
|
subjectChain.append(subjectChain[0]);
|
|
|
|
OcspServer server(responderChain, privateKey);
|
|
// Generate a BasicOCSPResponse containing 2 SingleResponses:
|
|
const QByteArray response(goodResponse(subjectChain, responderChain, privateKey));
|
|
QVERIFY(response.size());
|
|
server.configureResponse(response);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(responderChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QCOMPARE_SINGLE_ERROR(clientSocket, expectedError);
|
|
}
|
|
|
|
void tst_QOcsp::malformedResponse()
|
|
{
|
|
QDECLARE_CHAIN(serverChain, "ss1.crt");
|
|
QDECLARE_PRIVATE_KEY(privateKey, "ss1-private.key");
|
|
|
|
OcspServer server(serverChain, privateKey);
|
|
// Let's send some arbitrary bytes instead of DER and see what happens next:
|
|
server.configureResponse("Sure, you can trust me, this cert was not revoked (I don't say it was issued at all)!");
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(serverChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QCOMPARE(clientSocket.error(), QAbstractSocket::SslHandshakeFailedError);
|
|
}
|
|
|
|
void tst_QOcsp::expiredResponse_data()
|
|
{
|
|
QTest::addColumn<long>("beforeNow");
|
|
QTest::addColumn<long>("afterNow");
|
|
|
|
QTest::addRow("expired") << -2000L << -1000L;
|
|
QTest::addRow("not-valid-yet") << 5000L << 10000L;
|
|
QTest::addRow("next-before-this") << -1000L << -2000L;
|
|
}
|
|
|
|
void tst_QOcsp::expiredResponse()
|
|
{
|
|
// We report different kinds of problems with [thisUpdate, nextUpdate]
|
|
// as 'expired' (to keep it simple):
|
|
const QSslError::SslError expectedError = QSslError::OcspResponseExpired;
|
|
|
|
QFETCH(const long, beforeNow);
|
|
QFETCH(const long, afterNow);
|
|
|
|
QDECLARE_CHAIN(subjectChain, "ss1.crt");
|
|
QDECLARE_CHAIN(responderChain, "ss1.crt");
|
|
QDECLARE_PRIVATE_KEY(privateKey, "ss1-private.key");
|
|
|
|
OcspServer server(subjectChain, privateKey);
|
|
const QByteArray response(goodResponse(subjectChain, responderChain, privateKey, beforeNow, afterNow));
|
|
QVERIFY(response.size());
|
|
server.configureResponse(response);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(subjectChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QCOMPARE_SINGLE_ERROR(clientSocket, expectedError);
|
|
}
|
|
|
|
void tst_QOcsp::noNextUpdate()
|
|
{
|
|
// RFC2560, 2.4:
|
|
// "If nextUpdate is not set, the responder is indicating that newer
|
|
// revocation information is available all the time."
|
|
//
|
|
// This test is just to verify that we correctly handle such responses.
|
|
QDECLARE_CHAIN(subjectChain, "ss1.crt");
|
|
QDECLARE_CHAIN(responderChain, "ss1.crt");
|
|
QDECLARE_PRIVATE_KEY(privateKey, "ss1-private.key");
|
|
|
|
OcspServer server(subjectChain, privateKey);
|
|
OcspTimeStamp openRange(-1000, 0);
|
|
openRange.nextUpdate.clear();
|
|
const OcspResponder responder(openRange, subjectChain, responderChain, privateKey);
|
|
const QByteArray response(responder.buildResponse(OCSP_RESPONSE_STATUS_SUCCESSFUL,
|
|
V_OCSP_CERTSTATUS_GOOD));
|
|
QVERIFY(response.size());
|
|
server.configureResponse(response);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(subjectChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY_HANDSHAKE_WITHOUT_ERRORS(clientSocket);
|
|
}
|
|
|
|
void tst_QOcsp::wrongCertificateInResponse_data()
|
|
{
|
|
QTest::addColumn<QLatin1String>("respChainName");
|
|
QTest::addColumn<QLatin1String>("respKeyName");
|
|
QTest::addColumn<QLatin1String>("wrongChainName");
|
|
|
|
QTest::addRow("same-CA-wrong-subject") << QLatin1String("ca1.crt") << QLatin1String("ca1.key")
|
|
<< QLatin1String("alice.crt");
|
|
QTest::addRow("wrong-CA-same-subject") << QLatin1String("ss1.crt") << QLatin1String("ss1-private.key")
|
|
<< QLatin1String("alice.crt");
|
|
QTest::addRow("wrong-CA-wrong-subject") << QLatin1String("ss1.crt") << QLatin1String("ss1-private.key")
|
|
<< QLatin1String("ss1.crt");
|
|
}
|
|
|
|
void tst_QOcsp::wrongCertificateInResponse()
|
|
{
|
|
QFETCH(const QLatin1String, respChainName);
|
|
QFETCH(const QLatin1String, respKeyName);
|
|
QFETCH(const QLatin1String, wrongChainName);
|
|
// In this test, the server will send a valid response (correctly signed
|
|
// by a trusted key/cert) but for a wrong certificate (not the one the
|
|
// server presented to the client in the server's 'Certificate' message).
|
|
const QSslError::SslError expectedError = QSslError::OcspResponseCertIdUnknown;
|
|
|
|
QDECLARE_CHAIN(subjectChain, "infbobchain.crt");
|
|
QDECLARE_PRIVATE_KEY(subjectKey, "infbob.key");
|
|
QDECLARE_CHAIN(responderChain, respChainName);
|
|
QDECLARE_PRIVATE_KEY(responderKey, respKeyName);
|
|
|
|
QDECLARE_CHAIN(wrongChain, wrongChainName);
|
|
|
|
OcspServer server(subjectToChain(subjectChain), subjectKey);
|
|
const QByteArray wrongResponse(goodResponse(wrongChain, responderChain, responderKey));
|
|
QVERIFY(wrongResponse.size());
|
|
server.configureResponse(wrongResponse);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, issuerToChain(subjectChain), server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QVERIFY(containsError(clientSocket.sslHandshakeErrors(), expectedError));
|
|
}
|
|
|
|
void tst_QOcsp::untrustedResponder()
|
|
{
|
|
const QSslError::SslError expectedError = QSslError::OcspResponseCannotBeTrusted;
|
|
|
|
QDECLARE_CHAIN(subjectChain, "infbobchain.crt");
|
|
QDECLARE_PRIVATE_KEY(subjectKey, "infbob.key");
|
|
QDECLARE_CHAIN(responderChain, "ca1.crt");
|
|
QDECLARE_PRIVATE_KEY(responderKey, "ca1.key");
|
|
|
|
OcspServer server(subjectChain, subjectKey);
|
|
const QByteArray response(goodResponse(subjectToChain(subjectChain), responderChain, responderKey));
|
|
QVERIFY(response.size());
|
|
server.configureResponse(response);
|
|
QVERIFY(server.listen());
|
|
connect(&server, &OcspServer::internalServerError, &loop, exitLoopSlot);
|
|
|
|
QSslSocket clientSocket;
|
|
setupOcspClient(clientSocket, {}, server.peerVerifyName());
|
|
clientSocket.connectToHostEncrypted(server.hostName(), server.serverPort());
|
|
loop.enterLoopMSecs(handshakeTimeoutMS);
|
|
|
|
QVERIFY(!clientSocket.isEncrypted());
|
|
QVERIFY(containsError(clientSocket.sslHandshakeErrors(), expectedError));
|
|
}
|
|
|
|
void tst_QOcsp::setupOcspClient(QSslSocket &clientSocket, const CertificateChain &caCerts, const QString &name)
|
|
{
|
|
QSslConfiguration clientConfig = QSslConfiguration::defaultConfiguration();
|
|
clientConfig.setOcspStaplingEnabled(true);
|
|
|
|
if (caCerts.size()) {
|
|
auto roots = clientConfig.caCertificates();
|
|
roots.append(caCerts);
|
|
clientConfig.setCaCertificates(roots);
|
|
}
|
|
|
|
clientSocket.setSslConfiguration(clientConfig);
|
|
clientSocket.setPeerVerifyName(name);
|
|
|
|
connect(&clientSocket, &QAbstractSocket::errorOccurred, &loop, exitLoopSlot);
|
|
connect(&clientSocket, tlsErrorsSignal, &loop, exitLoopSlot);
|
|
connect(&clientSocket, &QSslSocket::encrypted, &loop, exitLoopSlot);
|
|
}
|
|
|
|
bool tst_QOcsp::containsOcspErrors(const QList<QSslError> &errorsFound) const
|
|
{
|
|
for (auto code : ocspErrorCodes) {
|
|
if (containsError(errorsFound, code))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool tst_QOcsp::containsError(const QList<QSslError> &errors, QSslError::SslError code)
|
|
{
|
|
const auto it = std::find_if(errors.begin(), errors.end(),
|
|
[&code](const QSslError &other){return other.error() == code;});
|
|
return it != errors.end();
|
|
}
|
|
|
|
QByteArray tst_QOcsp::goodResponse(const CertificateChain &subject, const CertificateChain &responder,
|
|
const QSslKey &privateKey, long beforeNow, long afterNow)
|
|
{
|
|
const OcspResponder builder(OcspTimeStamp(beforeNow, afterNow), subject, responder, privateKey);
|
|
return builder.buildResponse(OCSP_RESPONSE_STATUS_SUCCESSFUL, V_OCSP_CERTSTATUS_GOOD);
|
|
}
|
|
|
|
bool tst_QOcsp::loadPrivateKey(const QString &keyFileName, QSslKey &key)
|
|
{
|
|
QFile keyFile(certDirPath + keyFileName);
|
|
if (!keyFile.open(QIODevice::ReadOnly))
|
|
return false;
|
|
key = QSslKey(keyFile.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);
|
|
return !key.isNull();
|
|
}
|
|
|
|
CertificateChain tst_QOcsp::issuerToChain(const CertificateChain &chain)
|
|
{
|
|
// Here we presume that, if the chain isn't a single self-signed certificate, its second
|
|
// entry is the issuer.
|
|
const int length = chain.size();
|
|
Q_ASSERT(length > 0);
|
|
return CertificateChain() << chain[length > 1 ? 1 : 0];
|
|
}
|
|
|
|
CertificateChain tst_QOcsp::subjectToChain(const CertificateChain &chain)
|
|
{
|
|
Q_ASSERT(chain.size());
|
|
return CertificateChain() << chain[0];
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
QTEST_MAIN(tst_QOcsp)
|
|
|
|
#include "tst_qocsp.moc"
|