QDtlsClientVerifier Class

Description détaillée

La classe QDtlsClientVerifier implémente la génération et la vérification des cookies DTLS côté serveur. Les protocoles de sécurité des datagrammes sont très sensibles à une variété d'attaques par déni de service. Selon la RFC 6347, section 4.2.1, voici deux des types d'attaques les plus courants :

• Un attaquant transmet une série de demandes d'initiation de la poignée de main, ce qui amène un serveur à allouer des ressources excessives et à effectuer des opérations cryptographiques potentiellement coûteuses.
• Un attaquant transmet une série de demandes d'initiation de la poignée de main avec une source falsifiée de la victime, obligeant le serveur à agir comme un amplificateur. Normalement, le serveur répondrait à la machine victime par un message de certificat, qui peut être très volumineux, inondant ainsi la machine victime de datagrammes.

Pour contrer ces attaques, la section 4.2.1 du RFC 6347 propose une technique de cookie sans état qu'un serveur peut déployer :

• En réponse au message initial ClientHello, le serveur envoie une requête HelloVerifyRequest, qui contient un cookie. Ce cookie est un hachage cryptographique généré à partir de l'adresse du client, du numéro de port et du secret du serveur (qui est une séquence pseudo-aléatoire d'octets forte sur le plan cryptographique).
• Un client DTLS joignable est censé répondre par un nouveau message ClientHello contenant ce cookie.
• Lorsque le serveur reçoit le message ClientHello avec un cookie, il génère un nouveau cookie comme décrit ci-dessus. Ce nouveau cookie est comparé à celui trouvé dans le message ClientHello.
• Si les cookies sont égaux, le client est considéré comme réel et le serveur peut poursuivre la procédure de poignée de main TLS.

QDtlsClientVerifier est conçu pour fonctionner en paire avec QUdpSocket, comme le montre l'extrait de code suivant :

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 n'impose aucune restriction sur la manière dont l'application utilise QUdpSocket. Par exemple, il est possible d'avoir un serveur avec un seul QUdpSocket dans l'état QAbstractSocket::BoundState, traitant plusieurs clients DTLS simultanément :

• Tester si les nouveaux clients sont de vrais clients DTLS.
• Terminer les échanges TLS avec les clients vérifiés (voir QDtls).
• Décryptage des datagrammes provenant des clients connectés (voir QDtls).
• Envoi de datagrammes chiffrés aux clients connectés (voir QDtls).

Cela implique que QDtlsClientVerifier ne lit pas directement à partir d'une socket, mais attend de l'application qu'elle lise un datagramme entrant, qu'elle en extraie l'adresse et le port de l'expéditeur, puis qu'elle transmette ces données à verifyClient(). Pour envoyer un message HelloVerifyRequest, verifyClient() peut écrire sur la socket QUdpSocket.

Par défaut, QDtlsClientVerifier obtient son secret à partir d'un générateur de nombres pseudo-aléatoires cryptographiquement fort.

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

L'exemple du serveur DTLS illustre comment utiliser QDtlsClientVerifier dans une application serveur.