Cliente CoAP rápido y seguro
Cómo proteger el cliente CoAP y utilizarlo con una interfaz de usuario de Qt Quick.

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:
- Qt Creator
Abre el modo « Welcome » y selecciona el ejemplo en « Examples ». Para obtener más información, consulta Qt Creator: Tutorial: Compilar y ejecutar.
- Qt Extension for Visual Studio Code
Ejecute el comando « Qt: Open Qt examples » desde Command Palette y seleccione el ejemplo de la lista. Para obtener más información, consulte Qt Extension for Visual Studio Code: Tutorial: Compilar y ejecutar.
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_resourcesUso 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.0Se 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:freecoapPara 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.0A continuación, puede obtener la dirección IP con el siguiente comando:
docker inspect <container_id> | grep IPAddressPor 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.