QDtlsClientVerifier Class

Descripción detallada

La clase QDtlsClientVerifier implementa la generación y verificación de cookies DTLS del lado del servidor. Los protocolos de seguridad de datagramas son altamente susceptibles a una variedad de ataques de Denegación de Servicio. Según el RFC 6347, sección 4.2.1, estos son dos de los tipos de ataque más comunes:

• Un atacante transmite una serie de peticiones de iniciación de handshake, provocando que un servidor asigne recursos excesivos y potencialmente realice costosas operaciones criptográficas.
• Un atacante transmite una serie de peticiones de inicio de apretón de manos con una fuente falsificada de la víctima, haciendo que el servidor actúe como amplificador. Normalmente, el servidor respondería a la máquina víctima con un mensaje de certificado, que puede ser bastante grande, inundando así la máquina víctima con datagramas.

Como contramedida a estos ataques, el RFC 6347, sección 4.2.1 propone una técnica de cookies sin estado que un servidor puede desplegar:

• En respuesta al mensaje inicial ClientHello, el servidor envía un HelloVerifyRequest, que contiene una cookie. Esta cookie es un hash criptográfico y se genera utilizando la dirección del cliente, el número de puerto y el secreto del servidor (que es una secuencia de bytes pseudoaleatoria criptográficamente fuerte).
• Se espera que un cliente DTLS alcanzable responda con un nuevo mensaje ClientHello que contenga esta cookie.
• Cuando el servidor recibe el mensaje ClientHello con una cookie, genera una nueva cookie como se ha descrito anteriormente. Esta nueva cookie se compara con la que se encuentra en el mensaje ClientHello.
• En las cookies son iguales, se considera que el cliente es real, y el servidor puede continuar con un procedimiento de handshake TLS.

QDtlsClientVerifier está diseñado para trabajar en pareja con QUdpSocket, como se muestra en el siguiente extracto de código:

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 no impone ninguna restricción sobre cómo la aplicación utiliza QUdpSocket. Por ejemplo, es posible tener un servidor con un único QUdpSocket en estado QAbstractSocket::BoundState, manejando múltiples clientes DTLS simultáneamente:

• Comprobación de si los nuevos clientes son clientes DTLS reales.
• Completar los handshakes TLS con los clientes verificados (ver QDtls).
• Descifrar los datagramas procedentes de los clientes conectados (véase QDtls).
• Enviar datagramas encriptados a los clientes conectados (ver QDtls).

Esto implica que QDtlsClientVerifier no lee directamente de un socket, en su lugar espera que la aplicación lea un datagrama entrante, extraiga la dirección del remitente, y el puerto, y luego pase estos datos a verifyClient(). Para enviar un mensaje HelloVerifyRequest, verifyClient() puede escribir en el QUdpSocket.

Por defecto QDtlsClientVerifier obtiene su secreto de un generador de números pseudoaleatorios criptográficamente fuerte.

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

El ejemplo de servidor DTLS ilustra cómo utilizar QDtlsClientVerifier en una aplicación de servidor.