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é par datagrammes sont très vulnérables à divers types 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 requêtes d'initiation de handshake, ce qui oblige le serveur à allouer des ressources excessives et peut l'amener à effectuer des opérations cryptographiques coûteuses.
• Un attaquant transmet une série de requêtes d’initiation de handshake en falsifiant l’adresse source de la victime, ce qui oblige le serveur à agir comme un amplificateur. Normalement, le serveur répondrait à la machine de la victime par un message de certificat, qui peut être assez volumineux, inondant ainsi la machine de la victime de datagrammes.

Pour contrer ces attaques, la section 4.2.1 de la RFC 6347 propose une technique de cookie sans état qu’un serveur peut mettre en œuvre :

• En réponse au message ClientHello initial, le serveur envoie une requête HelloVerifyRequest contenant 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 d’octets pseudo-aléatoire cryptographiquement forte).
• Un client DTLS joignable est censé répondre par un nouveau message ClientHello contenant ce cookie.
• Lorsque le serveur reçoit le message ClientHello accompagné d’un cookie, il génère un nouveau cookie comme décrit ci-dessus. Ce nouveau cookie est comparé à celui figurant dans le message ClientHello.
• Si les cookies sont identiques, le client est considéré comme authentique et le serveur peut poursuivre la procédure de poignée de main TLS.

QDtlsClientVerifier est conçu pour fonctionner en tandem 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 quant à la manière dont l’application utilise QUdpSocket. Par exemple, il est possible d’avoir un serveur avec une seule instance QUdpSocket dans l’état QAbstractSocket::BoundState, gérant simultanément plusieurs clients DTLS :

• Vérifier si les nouveaux clients sont de véritables clients compatibles DTLS.
• Effectuer les handshakes TLS avec les clients vérifiés (voir QDtls).
• Déchiffrer les 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’un socket ; il attend plutôt que l’application lise un datagramme entrant, en extraie l’adresse et le port de l’expéditeur, puis transmette ces données à ` verifyClient()` (). Pour envoyer un message `HelloVerifyRequest`, ` verifyClient()` peut écrire dans le ` 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 de serveur DTLS illustre comment utiliser QDtlsClientVerifier dans une application serveur.