QDtlsClientVerifier Class

Ausführliche Beschreibung

Die Klasse „QDtlsClientVerifier“ implementiert die serverseitige Generierung und Überprüfung von DTLS-Cookies. Datagramm-Sicherheitsprotokolle sind in hohem Maße anfällig für eine Vielzahl von Denial-of-Service-Angriffen. Gemäß RFC 6347, Abschnitt 4.2.1, sind dies zwei der häufigsten Angriffsarten:

• Ein Angreifer sendet eine Reihe von Handshake-Initiierungsanfragen, wodurch der Server übermäßig viele Ressourcen zuweist und möglicherweise aufwendige kryptografische Operationen ausführt.
• Ein Angreifer sendet eine Reihe von Handshake-Initiierungsanfragen mit einer gefälschten Absenderadresse des Opfers, wodurch der Server als Verstärker fungiert. Normalerweise würde der Server dem Rechner des Opfers mit einer Zertifikatsnachricht antworten, die recht groß sein kann, wodurch der Rechner des Opfers mit Datagrammen überflutet wird.

Als Gegenmaßnahme gegen diese Angriffe schlägt RFC 6347, Abschnitt 4.2.1, eine zustandslose Cookie-Technik vor, die ein Server einsetzen kann:

• Als Antwort auf die anfängliche „ClientHello“-Nachricht sendet der Server eine „HelloVerifyRequest“-Nachricht, die ein Cookie enthält. Dieses Cookie ist ein kryptografischer Hash und wird unter Verwendung der Adresse des Clients, der Portnummer und des Geheimnisses des Servers (bei dem es sich um eine kryptografisch starke pseudozufällige Bytefolge handelt) generiert.
• 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, generiert er wie oben beschrieben ein neues Cookie. Dieses neue Cookie wird mit dem in der „ClientHello“-Nachricht enthaltenen verglichen.
• Sind die Cookies identisch, wird der Client als echt angesehen, und der Server kann mit dem TLS-Handshake-Vorgang fortfahren.

„QDtlsClientVerifier“ ist für den Einsatz in Kombination mit „ QUdpSocket “ ausgelegt, wie im folgenden Codeausschnitt gezeigt:

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 schränkt die Art und Weise, wie die Anwendung „ QUdpSocket “ nutzt, in keiner Weise ein. So ist es beispielsweise möglich, dass ein Server mit einem einzigen „ QUdpSocket “ im Status „ QAbstractSocket::BoundState “ mehrere DTLS-Clients gleichzeitig bedient:

• Prüfung, ob neue Clients echte DTLS-fähige Clients sind.
• Durchführung von TLS-Handshakes mit den verifizierten Clients (siehe QDtls).
• Entschlüsseln von Datagrammen, die von den verbundenen Clients stammen (siehe QDtls).
• Versenden verschlüsselter Datagramme an die verbundenen Clients (siehe QDtls).

Dies bedeutet, dass „QDtlsClientVerifier“ nicht direkt aus einem Socket liest, sondern erwartet, dass die Anwendung ein eingehendes Datagramm liest, die Adresse und den Port des Absenders extrahiert und diese Daten anschließend an „ verifyClient()“ übergibt. Um eine „HelloVerifyRequest“-Nachricht zu senden, kann „ verifyClient()“ in „ QUdpSocket “ schreiben.

Standardmäßig bezieht QDtlsClientVerifier sein Geheimnis aus einem kryptografisch sicheren Pseudozufallszahlengenerator.

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

Das DTLS-Server-Beispiel veranschaulicht die Verwendung von `QDtlsClientVerifier` in einer Serveranwendung.