En esta página

Cliente CoAP rápido y seguro

Cómo proteger el cliente CoAP y utilizarlo con una interfaz de usuario de Qt Quick.

Cliente CoAP seguro con configuración de certificado y respuesta

El cliente CoAP rápido y seguro muestra cómo crear un cliente CoAP seguro y utilizarlo en una aplicación de Qt Quick.

Nota: Qt CoAP no ofrece una API QML en su versión actual. Sin embargo, puedes hacer que las clases C++ del módulo estén disponibles para QML tal y como se muestra en el ejemplo.

Ejecución del ejemplo

Puede ejecutar el ejemplo desde:

Para ejecutar la aplicación de ejemplo, primero debe configurar un servidor CoAP seguro. Puede ejecutar el ejemplo con cualquier servidor CoAP seguro que admita uno de los modos de autenticación: clave precompartida (PSK) o certificado. Para obtener más información sobre cómo configurar un servidor CoAP seguro, consulte «Configuración de un servidor CoAP seguro».

Exposición de clases de C++ a QML

En este ejemplo, debe exponer la clase ` QCoapClient ` y el espacio de nombres ` QtCoap ` a QML. Para ello, cree una clase envolventora personalizada y utilice las macros de registro especiales.

Crea la clase ` QmlCoapSecureClient ` como envoltura de ` QCoapClient`. Esta clase también contiene el modo de seguridad seleccionado y los parámetros de configuración de seguridad. Utiliza la macro ` Q_INVOKABLE ` para exponer varios métodos a QML. Utiliza también la macro ` QML_NAMED_ELEMENT ` para registrar la clase en QML como ` CoapSecureClient`.

class QmlCoapSecureClient : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(CoapSecureClient)

public:
    QmlCoapSecureClient(QObject *parent = nullptr);
    ~QmlCoapSecureClient() override;

    Q_INVOKABLE void setSecurityMode(QtCoap::SecurityMode mode);
    Q_INVOKABLE void sendGetRequest(const QString &host, const QString &path, int port);
    Q_INVOKABLE void setSecurityConfiguration(const QString &preSharedKey, const QString &identity);
    Q_INVOKABLE void setSecurityConfiguration(const QString &localCertificatePath,
                                              const QString &caCertificatePath,
                                              const QString &privateKeyPath);
    Q_INVOKABLE void disconnect();

Q_SIGNALS:
    void finished(const QString &result);

private:
    QCoapClient *m_coapClient;
    QCoapSecurityConfiguration m_configuration;
    QtCoap::SecurityMode m_securityMode;
};

A continuación, registra el espacio de nombres QtCoap, para que puedas utilizar las enumeraciones que allí se proporcionan:

namespace QCoapForeignNamespace
{
    Q_NAMESPACE
    QML_FOREIGN_NAMESPACE(QtCoap)
    QML_NAMED_ELEMENT(QtCoap)
}

Ajuste de los archivos de compilación

Para que los tipos personalizados estén disponibles desde QML, actualiza los archivos del sistema de compilación como corresponda.

CMake

Para una compilación basada en CMake, añade lo siguiente al archivo CMakeLists.txt:

qt_add_qml_module(quicksecureclient
    URI CoapSecureClientModule
    SOURCES
        qmlcoapsecureclient.cpp qmlcoapsecureclient.h
    QML_FILES
        FilePicker.qml
        Main.qml
)
qmake

Para una compilación con qmake, modifica el archivo ` quicksecureclient.pro ` de la siguiente manera:

CONFIG += qmltypes
QML_IMPORT_NAME = CoapSecureClientModule
QML_IMPORT_MAJOR_VERSION = 1
    ...
qml_resources.files = \
    qmldir \
    FilePicker.qml \
    Main.qml

qml_resources.prefix = /qt/qml/CoapSecureClientModule

RESOURCES += qml_resources

Uso de los nuevos tipos de QML

Ahora que las clases de C++ están correctamente expuestas a QML, ya puedes utilizar los nuevos tipos.

Creación del cliente

CoapSecureClient se instancia a partir del archivo Main.qml. Este gestiona la señal QmlCoapSecureClient::finished() y actualiza la interfaz de usuario en consecuencia:

CoapSecureClient {
    id: client
    onFinished: (result) => {
        outputView.text = result;
        statusLabel.text = "";
        disconnectButton.enabled = true;
    }
}

La instancia de ` QCoapClient ` se crea cuando el usuario selecciona o cambia el modo de seguridad en la interfaz de usuario. El método ` QmlCoapSecureClient::setSecurityMode() ` se invoca desde el código QML cuando se selecciona uno de los modos de seguridad:

ButtonGroup {
    id: securityModeGroup
    onClicked: {
        if ((securityModeGroup.checkedButton as RadioButton) === preSharedMode)
            client.setSecurityMode(QtCoap.SecurityMode.PreSharedKey);
        else
            client.setSecurityMode(QtCoap.SecurityMode.Certificate);
    }
}

En el lado de C++, este método crea un objeto ` QCoapClient ` y se conecta a sus señales ` finished()` y ` error()`. La clase gestiona ambas señales internamente y las reenvía a la nueva señal ` finished() `.

void QmlCoapSecureClient::setSecurityMode(QtCoap::SecurityMode mode)
{
    // Create a new client, if the security mode has changed
    if (m_coapClient && mode != m_securityMode) {
        delete m_coapClient;
        m_coapClient = nullptr;
    }

    if (!m_coapClient) {
        m_coapClient = new QCoapClient(mode);
        m_securityMode = mode;

        connect(m_coapClient, &QCoapClient::finished, this,
                [this](QCoapReply *reply) {
                    if (!reply)
                        emit finished(tr("Something went wrong, received a null reply"));
                    else if (reply->errorReceived() != QtCoap::Error::Ok)
                        emit finished(errorMessage(reply->errorReceived()));
                    else
                        emit finished(reply->message().payload());
                });

        connect(m_coapClient, &QCoapClient::error, this,
                [this](QCoapReply *, QtCoap::Error errorCode) {
                    emit finished(errorMessage(errorCode));
                });
    }
}
Envío de una solicitud

Haz clic en el botón « Send Request » para establecer la configuración de seguridad en función del modo de seguridad seleccionado y enviar una solicitud « GET »:

Button {
    id: requestButton
    text: qsTr("Send Request")
    enabled: securityModeGroup.checkState !== Qt.Unchecked

    onClicked: {
        outputView.text = "";
        if ((securityModeGroup.checkedButton as RadioButton) === preSharedMode)
            client.setSecurityConfiguration(pskField.text, identityField.text);
        else
            client.setSecurityConfiguration(localCertificatePicker.selectedFile,
                                            caCertificatePicker.selectedFile,
                                            privateKeyPicker.selectedFile);

        client.sendGetRequest(hostComboBox.editText, resourceField.text,
                              parseInt(portField.text));

        statusLabel.text = qsTr("Sending request to %1%2...").arg(hostComboBox.editText)
                                                             .arg(resourceField.text);
    }
}

Existen dos sobrecargas para el método « setSecurityConfiguration ».

La sobrecarga para el modo PSK simplemente establece la identidad del cliente y la clave precompartida:

void
QmlCoapSecureClient::setSecurityConfiguration(const QString &preSharedKey, const QString &identity)
{
    QCoapSecurityConfiguration configuration;
    configuration.setPreSharedKey(preSharedKey.toUtf8());
    configuration.setPreSharedKeyIdentity(identity.toUtf8());
    m_configuration = configuration;
}

Y la sobrecarga para certificados X.509 lee los archivos de certificado y la clave privada, y establece la configuración de seguridad:

void QmlCoapSecureClient::setSecurityConfiguration(const QString &localCertificatePath,
                                                   const QString &caCertificatePath,
                                                   const QString &privateKeyPath)
{
    QCoapSecurityConfiguration configuration;

    const auto localCerts =
            QSslCertificate::fromPath(QUrl(localCertificatePath).toLocalFile(), QSsl::Pem,
                                      QSslCertificate::PatternSyntax::FixedString);
    if (localCerts.isEmpty())
        qCWarning(lcCoapClient, "The specified local certificate file is not valid.");
    else
        configuration.setLocalCertificateChain(localCerts.toVector());

    const auto caCerts = QSslCertificate::fromPath(QUrl(caCertificatePath).toLocalFile(), QSsl::Pem,
                                                   QSslCertificate::PatternSyntax::FixedString);
    if (caCerts.isEmpty())
        qCWarning(lcCoapClient, "The specified CA certificate file is not valid.");
    else
        configuration.setCaCertificates(caCerts.toVector());

    QFile privateKey(QUrl(privateKeyPath).toLocalFile());
    if (privateKey.open(QIODevice::ReadOnly)) {
        QCoapPrivateKey key(privateKey.readAll(), QSsl::Ec);
        configuration.setPrivateKey(key);
    } else {
        qCWarning(lcCoapClient) << "Unable to read the specified private key file"
                                << privateKeyPath;
    }
    m_configuration = configuration;
}

Tras establecer la configuración de seguridad, el método ` sendGetRequest ` establece la URL de la solicitud y envía una solicitud ` GET `:

void QmlCoapSecureClient::sendGetRequest(const QString &host, const QString &path, int port)
{
    if (!m_coapClient)
        return;

    m_coapClient->setSecurityConfiguration(m_configuration);

    QUrl url;
    url.setHost(host);
    url.setPath(path);
    url.setPort(port);
    m_coapClient->get(url);
}

Al enviar la primera solicitud, se realiza un protocolo de enlace con el servidor CoAP. Una vez completado con éxito el protocolo de enlace, todos los mensajes posteriores se cifran, y cambiar la configuración de seguridad tras un protocolo de enlace satisfactorio no tendrá ningún efecto. Si deseas modificarla, o cambiar el host, primero debes desconectarte.

void QmlCoapSecureClient::disconnect()
{
    if (m_coapClient)
        m_coapClient->disconnect();
}

Esto interrumpirá el establecimiento de conexión y cerrará los sockets abiertos.

Para la autenticación mediante certificados X.509, es necesario especificar los archivos de certificado. Para ello se utiliza el componente FilePicker. Este combina un campo de texto y un botón que abre un cuadro de diálogo de archivo al pulsarlo:

Item {
    id: filePicker

    property string dialogText
    property alias selectedFile: filePathField.text

    height: addFileButton.height

    FileDialog {
        id: fileDialog
        title: qsTr("Please Choose %1").arg(filePicker.dialogText)
        currentFolder: StandardPaths.writableLocation(StandardPaths.HomeLocation)
        fileMode: FileDialog.OpenFile
        onAccepted: filePathField.text = fileDialog.selectedFile
    }

    RowLayout {
        anchors.fill: parent
        TextField {
            id: filePathField
            placeholderText: qsTr("<%1>").arg(filePicker.dialogText)
            inputMethodHints: Qt.ImhUrlCharactersOnly
            selectByMouse: true
            Layout.fillWidth: true
        }

        Button {
            id: addFileButton
            text: qsTr("Add %1").arg(filePicker.dialogText)
            onClicked: fileDialog.open()
        }
    }
}

FilePicker se instancia varias veces en el archivo « Main.qml » para crear campos de entrada para los certificados y la clave privada:

FilePicker {
    id: localCertificatePicker
    dialogText: qsTr("Local Certificate")
    enabled: (securityModeGroup.checkedButton as RadioButton) === certificateMode
    Layout.columnSpan: 2
    Layout.fillWidth: true
}

FilePicker {
    id: caCertificatePicker
    dialogText: qsTr("CA Certificate")
    enabled: (securityModeGroup.checkedButton as RadioButton) === certificateMode
    Layout.columnSpan: 2
    Layout.fillWidth: true
}

FilePicker {
    id: privateKeyPicker
    dialogText: qsTr("Private Key")
    enabled: (securityModeGroup.checkedButton as RadioButton) === certificateMode
    Layout.columnSpan: 2
    Layout.fillWidth: true
}

Configuración de un servidor CoAP seguro

Para ejecutar este ejemplo, es necesario disponer de un servidor CoAP seguro que admita los modos PSK o Certificado (o ambos). Dispones de las siguientes opciones:

  • Compilar y ejecutar manualmente un servidor CoAP seguro utilizando, por ejemplo, libcoap, Californium, FreeCoAP o cualquier otra biblioteca CoAP que admita DTLS.
  • Utilizar las imágenes de Docker ya preparadas disponibles en Docker Hub, que crean y ejecutan los servidores CoAP seguros adecuados para nuestro ejemplo. A continuación se describen los pasos necesarios para utilizar los servidores CoAP basados en Docker.
Configuración de un servidor para el modo PSK

El siguiente comando descarga del Docker Hub el contenedor Docker para un servidor CoAP seguro basado en Californium plugtest (que no es seguro de forma predeterminada) y lo inicia:

docker run --name coap-test-server -d --rm -p 5683:5683/udp -p 5684:5684/udp tqtc/coap-californium-test-server:3.8.0

Se podrá acceder al servidor de prueba CoAP a través de los puertos 5683 (no seguro) y 5684 (seguro). Para obtener instrucciones sobre cómo obtener la dirección IP, consulta «Obtener la dirección IP».

Para ejecutar el ejemplo con este servidor, debes establecer la clave precompartida en secretPSK y la identidad en Client_identity.

Configuración de un servidor para el modo de certificado

La imagen de Docker del servidor seguro que utiliza la autenticación con certificados X.509 se basa en el ejemplo de servidor de hora de la biblioteca FreeCoAP. El siguiente comando descarga el contenedor desde Docker Hub y lo inicia:

docker run --name coap-time-server -d --rm -p 5684:5684/udp tqtc/coap-secure-time-server:freecoap

Para obtener instrucciones sobre cómo recuperar la dirección IP, consulta «Obtener la dirección IP». Se podrá acceder al servidor de prueba CoAP mediante la dirección IP recuperada en el puerto 5684 y la ruta de recurso /time.

Para ejecutar el ejemplo con este servidor, es necesario especificar los archivos de certificado que requiere el servidor. Se encuentran en el contenedor de Docker, en el directorio /root/certs. Para copiarlos a un directorio local, utiliza el siguiente comando:

docker cp <container_id>:/root/certs <local_directory_path>

Por ejemplo:

$ docker cp 5e46502df88f:/root/certs ~/

A continuación se describen las instrucciones para obtener el ID del contenedor.

Obtener la dirección IP

Para averiguar la dirección IP de un contenedor de Docker, primero hay que obtener el ID del contenedor ejecutando el comando ` docker ps `, que mostrará un resultado similar a este:

$ docker ps
CONTAINER ID        IMAGE
5e46502df88f        tqtc/coap-californium-test-server:3.8.0

A continuación, puede obtener la dirección IP con el siguiente comando:

docker inspect <container_id> | grep IPAddress

Por ejemplo:

$ docker inspect 5e46502df88f | grep IPAddress
...
"IPAddress": "172.17.0.2",
...
Cerrar un contenedor de Docker

Para cerrar un contenedor de Docker tras su uso, utiliza el siguiente comando:

docker stop <container_id>

El « <container_id> » que aparece aquí es el mismo que se obtiene con el comando « docker ps ».

Archivos:

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.