QDtlsClientVerifier Class

Detaillierte Beschreibung

Die Klasse QDtlsClientVerifier implementiert die serverseitige Erzeugung und Überprüfung von DTLS-Cookies. Datagramm-Sicherheitsprotokolle sind sehr anfällig für eine Vielzahl von Denial-of-Service-Angriffen. Nach RFC 6347, Abschnitt 4.2.1, sind dies zwei der häufigsten Angriffsarten:

• Ein Angreifer sendet eine Reihe von Handshake-Initiierungsanfragen, die einen Server dazu veranlassen, übermäßige Ressourcen zuzuweisen und möglicherweise teure kryptografische Operationen durchzuführen.
• Ein Angreifer sendet eine Reihe von Handshake-Initiierungsanfragen mit einer gefälschten Quelle des Opfers, so dass der Server als Verstärker fungiert. Normalerweise würde der Server dem Opferrechner mit einer Zertifikatsnachricht antworten, die recht groß sein kann, so dass der Opferrechner mit Datagrammen überflutet wird.

Als Gegenmaßnahme zu diesen Angriffen wird in RFC 6347, Abschnitt 4.2.1 eine zustandslose Cookie-Technik vorgeschlagen, die ein Server einsetzen kann:

• Als Antwort auf die erste ClientHello-Nachricht sendet der Server eine HelloVerifyRequest, die ein Cookie enthält. Dieser Cookie ist ein kryptographischer Hash und wird unter Verwendung der Adresse des Clients, der Portnummer und des Geheimnisses des Servers (einer kryptographisch starken Pseudo-Zufallsfolge von Bytes) erzeugt.
• Von einem erreichbaren DTLS-Client wird erwartet, dass er mit einer neuen ClientHello-Nachricht antwortet, die dieses Cookie enthält.
• Wenn der Server die ClientHello-Nachricht mit einem Cookie empfängt, erzeugt er ein neues Cookie wie oben beschrieben. Dieses neue Cookie wird mit dem in der ClientHello-Nachricht gefundenen Cookie verglichen.
• Wenn die Cookies gleich sind, wird der Client als echt angesehen, und der Server kann mit dem TLS-Handshake-Verfahren fortfahren.

QDtlsClientVerifier wurde entwickelt, um zusammen mit QUdpSocket zu arbeiten, wie im folgenden Code-Auszug gezeigt wird:

class DtlsServer : public QObject
{
public:
    bool listen(const QHostAddress &address, quint16 port);
    // ...

private:
    void readyRead();
    // ...

    QUdpSocket serverSocket;
    QDtlsClientVerifier verifier;
    // ...
};

bool DtlsServer::listen(const QHostAddress &serverAddress, quint16 serverPort)
{
    if (serverSocket.bind(serverAddress, serverPort))
        connect(&serverSocket, &QUdpSocket::readyRead, this, &DtlsServer::readyRead);
    return serverSocket.state() == QAbstractSocket::BoundState;
}

void DtlsServer::readyRead()
{
    QByteArray dgram(serverSocket.pendingDatagramSize(), Qt::Uninitialized);
    QHostAddress address;
    quint16 port = {};
    serverSocket.readDatagram(dgram.data(), dgram.size(), &address, &port);
    if (verifiedClients.contains({address, port}) {
        // This client was verified previously, we either continue the
        // handshake or decrypt the incoming message.
    } else if (verifier.verifyClient(&serverSocket, dgram, address, port)) {
        // Apparently we have a real DTLS client who wants to send us
        // encrypted datagrams. Remember this client as verified
        // and proceed with a handshake.
    } else {
        // No matching cookie was found in the incoming datagram,
        // verifyClient() has sent a ClientVerify message.
        // We'll hear from the client again soon, if they're real.
    }
}

QDtlsClientVerifier erlegt der Anwendung keine Beschränkungen bei der Verwendung von QUdpSocket auf. Es ist zum Beispiel möglich, einen Server mit einem einzigen QUdpSocket im Zustand QAbstractSocket::BoundState zu haben, der mehrere DTLS-Clients gleichzeitig bedient:

• Testen, ob neue Clients echte DTLS-fähige Clients sind.
• Abschluss von TLS-Handshakes mit den verifizierten Clients (siehe QDtls).
• Entschlüsselung von Datagrammen, die von den verbundenen Clients kommen (siehe QDtls).
• Senden von verschlüsselten Datagrammen an die angeschlossenen Clients (siehe QDtls).

Dies bedeutet, dass QDtlsClientVerifier nicht direkt von einem Socket liest, sondern erwartet, dass die Anwendung ein eingehendes Datagramm liest, die Adresse und den Port des Absenders extrahiert und diese Daten dann an verifyClient() weitergibt. Um eine HelloVerifyRequest-Nachricht zu senden, kann verifyClient() in den QUdpSocket schreiben.

Standardmäßig bezieht QDtlsClientVerifier sein Geheimnis von einem kryptographisch starken Pseudozufallszahlengenerator.

void DtlsServer::updateServerSecret()
{
    const QByteArray newSecret(generateCryptoStrongSecret());
    if (newSecret.size()) {
        usedCookies.append(newSecret);
        verifier.setCookieGeneratorParameters({QCryptographicHash::Sha1, newSecret});
    }
}

Das DTLS-Server-Beispiel veranschaulicht, wie QDtlsClientVerifier in einer Server-Anwendung verwendet werden kann.