En esta página

Descripción general de OAuth 2.0

RFC 6749: el marco de autorización OAuth 2.0 especifica un protocolo para la autorización de servicios mediante una aplicación de terceros. OAuth 2.0 utiliza tokens para separar el proceso de autorización del servicio y de los usuarios. Este método es más seguro, ya que el propietario del servicio no tiene que gestionar las credenciales de los usuarios. Sustituye al RFC 5849 (OAuth 1.0).

El marco OAuth 2.0 define dos tipos de clientes, públicos o confidenciales, y flujos como el flujo de código de autorización, la concesión implícita de código y varios otros para la autorización. Una aplicación Qt típica se considera una aplicación nativa pública. Una aplicación cliente pública es aquella en la que no se puede confiar para que contenga información confidencial, como contraseñas, que se vaya a incluir en el binario distribuido.

El RFC 8252 «OAuth 2.0 para aplicaciones nativas» define con mayor detalle las prácticas recomendadas para las aplicaciones nativas. En concreto, el RFC 8252 recomienda el flujo de autorización a través del navegador. Por lo tanto, las clases QtNetworkAuth proporcionan una implementación concreta de este flujo.

Como novedad en Qt 6.9, QtNetworkAuth ofrece compatibilidad con el RFC 8628: Concesión de autorización de dispositivos OAuth 2.0. Este flujo de dispositivos está pensado para dispositivos con capacidades de entrada limitadas o poco prácticas. En este flujo, las concesiones de autorización utilizan un dispositivo secundario, como un smartphone, en lugar del dispositivo en sí. Algunos ejemplos de estos dispositivos son televisores, consolas multimedia, interfaces hombre-máquina (HMI) y dispositivos IoT. El usuario puede entonces utilizar una aplicación en su smartphone para autorizar el dispositivo.

La siguiente tabla destaca los dos flujos OAuth 2.0 compatibles con la autorización « Qt Network »:

AspectoFlujo de código de autorizaciónFlujo de autorización del dispositivo
Conexión de redSíSí
Interacción del usuarioNavegador / agente de usuario en el mismo dispositivoNavegador / agente de usuario en un dispositivo diferente
Se requiere gestión de redireccionamientosSíNo
Capacidad de entrada en el dispositivoAmplias capacidades de entradaCapacidad de entrada limitada o inexistente
DestinatariosAplicaciones de escritorio y móvilesTelevisores, consolas, interfaces hombre-máquina (HMI) y dispositivos IoT

OAuth 2.0 requiere el uso de un agente de usuario, que suele ser un navegador. Para obtener más información, consulta la sección «Compatibilidad de Qt con OAuth 2.0 en navegadores».

Clases de OAuth 2.0

Qt Network La autorización proporciona clases OAuth 2.0 tanto concretas como abstractas. Las clases abstractas están pensadas para implementar flujos personalizados, mientras que las clases concretas proporcionan una implementación concreta.

Para consultar la lista de clases de C++, véase la página « QtNetworkAuth ».

Qt Network La autorización cuenta con dos clases abstractas para implementar flujos OAuth 2.0:

Flujo del código de autorización

Esta sección ofrece una visión general del flujo del código de autorización según las normas RFC 6749 — Código de autorización — y RFC 8252 — Solicitud de autorización desde una aplicación nativa — para aplicaciones nativas.

Consideremos la siguiente configuración de ejemplo:

QOAuth2AuthorizationCodeFlow m_oauth;
QOAuthUriSchemeReplyHandler m_handler;

m_oauth.setAuthorizationUrl(QUrl(authorizationUrl));
m_oauth.setTokenUrl(QUrl(accessTokenUrl));
m_oauth.setClientIdentifier(clientIdentifier);
m_oauth.setRequestedScopeTokens({scope});

connect(&m_oauth, &QAbstractOAuth::authorizeWithBrowser, this, &QDesktopServices::openUrl);
connect(&m_oauth, &QAbstractOAuth::granted, this, [this]() {
    // Here we use QNetworkRequestFactory to store the access token
    m_api.setBearerToken(m_oauth.token().toLatin1());
    m_handler.close();
});

m_handler.setRedirectUrl(QUrl{"com.example.myqtapp://oauth2redirect"_L1});
m_oauth.setReplyHandler(&m_handler);

// Initiate the authorization
if (m_handler.listen()) {
    m_oauth.grant();
}

Etapas del flujo de autorización

El flujo de código de autorización de la RFC 6749 consta de dos etapas principales: la autorización del recurso (que incluye cualquier autenticación de usuario necesaria) seguida de una solicitud de token de acceso. A estas les siguen, de forma opcional, el uso del token de acceso y la actualización del token de acceso. La siguiente figura ilustra estas etapas:

Proceso de autorización simplificado en una aplicación Qt mediante un servidor de autorización y un navegador

  • En la etapa de autorización, se autentica al usuario y este autoriza el acceso a los recursos. Esto requiere la interacción del usuario a través del navegador.
  • Tras la autorización, el código de autorización recibido se utiliza para solicitar un token de acceso y, opcionalmente, un token de actualización.
  • Una vez obtenido el token de acceso, la aplicación lo utiliza para acceder a los recursos de interés. El token de acceso se incluye en las solicitudes de recursos, y corresponde al servidor de recursos verificar la validez del token. Existen varias formas de incluir el token como parte de las solicitudes con tokens de portador. La más habitual es, sin duda, incluir el token en el encabezado HTTP « Authorization ».
  • Actualización del token de acceso. Los tokens de acceso suelen caducar con relativa rapidez, por ejemplo, al cabo de una hora. Si la aplicación ha recibido un token de actualización además del token de acceso, dicho token de actualización puede utilizarse para solicitar un nuevo token de acceso. Las aplicaciones pueden almacenar tokens de actualización de mayor duración para evitar la necesidad de una nueva fase de autorización (y, por lo tanto, otra interacción con el navegador).

Detalles y personalización

Los flujos de OAuth 2.0 son dinámicos y la implementación de las especificaciones puede resultar complicada al principio. La siguiente figura ilustra los principales detalles de un flujo de código de autorización correcto.

Detalles del flujo de OAuth 2.0 que muestran las llamadas a eventos específicos

Para mayor claridad, la figura omite algunas señales, pero en conjunto ilustra los detalles y los principales puntos de personalización. Los puntos de personalización son las diversas señales y ranuras que puede utilizar la aplicación, así como las devoluciones de llamada que se pueden configurar con QAbstractOAuth::setModifyParametersFunction() y QAbstractOAuth2::setNetworkRequestModifier().

Elección de un gestor de respuestas

La elección del controlador que se va a utilizar depende del elemento «redirect_uri ». La URL « redirect_uri » se establece como la dirección a la que se redirige el navegador una vez concluida la fase de autorización.

Para recibir la respuesta de autorización en aplicaciones nativas, la RFC 8252 especifica tres tipos principales de esquemas URI de respuesta: uso privado, bucle de retorno y https.

  • URI de uso privado: se pueden utilizar si el sistema operativo permite que una aplicación registre un esquema URI personalizado. Al intentar abrir una URL con dicho esquema personalizado, se abrirá la aplicación nativa correspondiente. Véase QOAuthUriSchemeReplyHandler.
  • URI HTTPS: se pueden utilizar si el sistema operativo permite que la aplicación registre una URL HTTPS personalizada. Al intentar abrir esta URL, se abrirá la aplicación nativa correspondiente. Se recomienda este esquema si el sistema operativo lo admite. Véase QOAuthUriSchemeReplyHandler.
  • Interfaces de bucle cerrado: se utilizan habitualmente para aplicaciones de escritorio y aplicaciones en fase de desarrollo. El QOAuthHttpServerReplyHandler está diseñado para gestionar estas URI mediante la configuración de un servidor local que se encarga de la redirección.

La elección depende de varios factores, tales como:

  • Los URI de redirección compatibles con el proveedor del servidor de autorización. La compatibilidad varía de un proveedor a otro y, a menudo, es específica de un tipo de cliente y un sistema operativo concretos. Además, la compatibilidad puede variar en función de si la aplicación está publicada o no.
  • Los esquemas de URI de redirección compatibles con las plataformas de destino.
  • Requisitos específicos de la aplicación en materia de usabilidad, seguridad y otros aspectos.

La RFC 8252 recomienda utilizar el esquema https por sus ventajas en materia de seguridad y usabilidad frente a los demás métodos.

Concesión de autorización de dispositivos OAuth 2.0

La concesión de autorización de dispositivos OAuth 2.0 (RFC 8628 ) está pensada para dispositivos conectados con capacidades de entrada limitadas o en los que no resulta práctico utilizar un navegador como agente de usuario. Un ejemplo de dispositivos que utilizan este flujo son los electrodomésticos inteligentes que necesitan dispositivos externos para la autorización.

Consideremos la siguiente configuración de ejemplo:

m_deviceFlow.setAuthorizationUrl(QUrl(authorizationUrl));
m_deviceFlow.setTokenUrl(QUrl(accessTokenUrl));
m_deviceFlow.setRequestedScopeTokens({scope});
m_deviceFlow.setClientIdentifier(clientIdentifier);
// La necesidad de un secreto de cliente depende del servidor de autorización
m_deviceFlow.setClientIdentifierSharedKey(clientSecret);

connect(&m_deviceFlow, &QOAuth2DeviceAuthorizationFlow::authorizeWithUserCode, this,
    [](const QUrl&verificationUrl, const QString&userCode, const QUrl&completeVerificationUrl) {
        if (completeVerificationUrl.isValid()) {
            // Si el servidor de autorización ha proporcionado una URL completa
            // que ya contiene los datos necesarios como parte de los parámetros de la URL,
            // puedes optar por utilizarla
            qDebug() << "Complete verification uri:" << completeVerificationUrl;
        } else {
            // El servidor de autorización solo ha facilitado una URL de verificación; utilízala
            qDebug() << "Verification uri and usercode:" << verificationUrl << userCode;
        }
    }
);

connect(&m_deviceFlow, &QAbstractOAuth::granted, this, [this](){
    // Aquí utilizamos QNetworkRequestFactory para almacenar el token de acceso
    m_api.setBearerToken(m_deviceFlow.token().toLatin1());
});
m_deviceFlow.grant();

Etapas de la concesión de autorización del dispositivo

El flujo de concesión de autorización del dispositivo consta de tres etapas principales: inicialización de la autorización, solicitud de tokens y finalización de la autorización. A estas les siguen, de forma opcional, el uso del token y la actualización del token. La siguiente figura ilustra estas etapas:

Flujo simplificado de concesión de autorizaciones en una aplicación Qt utilizando un navegador en un dispositivo independiente

  • La autorización se inicia enviando una solicitud HTTP al servidor de autorización. El servidor de autorización proporciona, en respuesta, un código de usuario, unas URL de verificación y un código de dispositivo.
  • Una vez inicializada la autorización, se proporciona al usuario un código de usuario y una o varias URL de verificación para completar la autorización. El mecanismo para el usuario final varía: puede ser una URL visible en la pantalla, un código QR, un correo electrónico, etc. Consulte el RFC 8628 — Interacción del usuario para obtener más información.
  • Mientras se espera a que el usuario final complete la autorización, el flujo del dispositivo consulta al servidor de autorización para obtener tokens. El código de dispositivo recibido en el paso anterior se utiliza para hacer coincidir la sesión de autorización. El intervalo de consulta lo determina el servidor de autorización y suele ser de 5 segundos.
  • Una vez que el usuario final ha aceptado o denegado la autorización, el servidor de autorización responde a una solicitud de sondeo con los tokens solicitados o con un código de error en caso de denegación, y la autorización queda completada.

Detalles y personalización

La siguiente figura ilustra con más detalle el flujo de concesión de autorización del dispositivo. La figura muestra los principales puntos de personalización, que en ocasiones resultan necesarios. Por ejemplo, parámetros propios o credenciales de autenticación adicionales.

Detalles del flujo de concesión de dispositivos de OAuth 2.0, en los que se muestran las llamadas a eventos específicas

Tokens de actualización

La actualización de tokens requiere que el servidor de autorización proporcione un token de actualización durante la autorización. La decisión de proporcionar un token de actualización recae en el servidor de autorización: algunos servidores pueden optar por proporcionarlo siempre, otros pueden no proporcionarlo nunca y otros lo proporcionan si en la solicitud de autorización se incluye un « scope » específico.

La siguiente figura ilustra la actualización del token con más detalle:

Detalles de los tokens de actualización que muestran las llamadas a eventos concretas

Como se muestra en la figura anterior, los puntos de personalización habituales también están disponibles al actualizar los tokens.

Para actualizar los tokens tras el inicio de una aplicación, esta debe almacenar el token de actualización de forma segura y establecerlo mediante ` QAbstractOAuth2::setRefreshToken`. A continuación, se puede llamar a ` QAbstractOAuth2::refreshTokens ` para solicitar nuevos tokens.

Como novedad en Qt 6.9, las aplicaciones pueden actualizar automáticamente los tokens; véase QAbstractOAuth2::accessTokenAboutToExpire, QAbstractOAuth2::autoRefresh y QAbstractOAuth2::refreshLeadTime.

Por lo general, el servidor de autorización no indica el tiempo de caducidad de un token de actualización (salvo en la documentación del servidor). Su validez puede variar entre días, meses o períodos más largos. Además, al igual que con otros tokens, los tokens de actualización pueden ser revocados por el usuario y, por lo tanto, invalidarse en cualquier momento. Por lo tanto, es importante detectar correctamente un intento fallido de actualización con « QAbstractOAuth::requestFailed » o « QAbstractOAuth2::serverReportedErrorOccurred ».

Los flujos de OAuth 2.0 requieren muchas interacciones por parte del usuario, lo que puede resultar intrusivo para la experiencia del usuario. Para minimizar estas interacciones, los tokens se pueden actualizar de forma silenciosa para el usuario. Consulte el RFC 6749 — Actualización de tokens de acceso — para obtener más información.

Compatibilidad con Qt OpenID Connect

OpenID Connect (OIDC) es una capa de identidad sencilla que se superpone a OAuth 2.0. OIDC puede utilizar un servidor de autorización para autenticar la identidad de un usuario. Con OIDC también es posible acceder a información básica del perfil de usuario.

La compatibilidad de Qt con OIDC se limita, por el momento, a la obtención de tokens de identificación. Un token de identificación es un token web JSON (JWT) que contiene afirmaciones sobre el evento de autenticación.

Nota: Actualmente no se ha implementado la validación ni el descifrado de tokensde identificación . Debes utilizar una biblioteca JWT de terceros para la firma o verificación de tokens JWT.

Suponiendo que la aplicación sea capaz de validar los tokens recibidos, el token se puede utilizar para establecer la identidad del usuario de forma fiable (siempre y cuando el propio proveedor de OIDC sea de confianza).

Los tokens de identificación son información confidencial y deben mantenerse en secreto; no son lo mismo que los tokens de acceso. Los tokens de identificación no están pensados para enviarse en llamadas a la API; para ese fin se utiliza el token de acceso. Tenga en cuenta que algunos proveedores pueden utilizar el mismo formato JWT para los tokens de acceso, pero esto no debe confundirse con los tokens de identificación propiamente dichos, que utilizan el mismo formato. En el caso de los tokens de identificación, el cliente que recibe el token es responsable de verificarlo, mientras que, en el caso de los tokens de acceso, es el servidor de recursos que acepta el token el responsable de la verificación.

Obtener un token de identificación

La obtención de un token de identificación es similar a la de un token de acceso. En primer lugar, debemos establecer el ámbito adecuado. El proveedor del servidor de autorización puede admitir especificadores de ámbito adicionales, como profile y email, pero todas las solicitudes OIDC deben incluir el ámbito openid:

m_oauth.setRequestedScopeTokens({"openid"});

Para OIDC, se recomienda encarecidamente utilizar el parámetro nonce. Para ello, hay que asegurarse de que se ha establecido el NonceMode adecuado.

// This is for illustrative purposes, 'Automatic' is the default mode
m_oauth.setNonceMode(QAbstractOAuth2::NonceMode::Automatic);

Como último paso, podemos escuchar directamente la señal « QAbstractOAuth2::granted » o la « QAbstractOAuth2::idTokenChanged »:

connect(&m_oauth, &QAbstractOAuth2::idTokenChanged, this, [this](const QString &token) {
    Q_UNUSED(token); // Handle token
});

Validación de un token de identificación

La validación del token de identificación recibido es una parte fundamental del flujo de autenticación y, cuando se implementa por completo, resulta una tarea algo complicada. Consulta la información completa en Validación de identificadores de OpenID Connect.

A modo de breve resumen, la validación consta de los siguientes pasos:

  • Descifrar el token si es necesario (véase JWE)
  • Extraer el encabezado, la carga útil y la firma del token
  • Validar la firma
  • Validar los campos de la carga útil (como aud, iss, exp, nonce, iat)

Actualmente, Qt no ofrece soporte para la validación de tokens de identificación, pero existen bibliotecas JWT de terceros, como jwt-cpp.

Ejemplo de verificación de un token de identificación

En esta sección se muestra un ejemplo sencillo de verificación. Como requisitos previos, el entorno de desarrollo debe contar con las bibliotecas de OpenSSL y con jwt-cpp en la carpeta «include» del directorio de código fuente del proyecto de la aplicación.

En el archivo ` CMakeLists.txt ` del proyecto de la aplicación, primero comprobamos que se cumplan los requisitos previos:

find_package(OpenSSL 1.0.0 QUIET)
set(JWT_CPP_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/include")
if(OPENSSL_FOUND AND EXISTS "${JWT_CPP_INCLUDE_DIR}/jwt-cpp/jwt.h")

A continuación, añadimos las inclusiones y bibliotecas necesarias:

    target_include_directories(networkauth_oauth_snippets PRIVATE "${JWT_CPP_INCLUDE_DIR}")
    target_link_libraries(networkauth_oauth_snippets PRIVATE OpenSSL::SSL OpenSSL::Crypto)
    target_compile_definitions(networkauth_oauth_snippets PRIVATE JWT_CPP_AVAILABLE)

En los archivos fuente de la aplicación, incluye la biblioteca de verificación:

#ifdef JWT_CPP_AVAILABLE
#include "jwt-cpp/jwt.h"
#endif

Una vez que la aplicación recibe un token de identificación, es el momento de verificarlo. En primer lugar, buscamos una clave coincidente en los conjuntos de claves web JSON (JWKS); véase «OpenID Connect Discovery».

try {
    const auto jwt = jwt::decode(m_oauth.idToken().toStdString());
    const auto jwks = jwt::parse_jwks(m_jwks->toJson(QJsonDocument::Compact).toStdString());
    const auto jwk = jwks.get_jwk(jwt.get_key_id());

A continuación, llevamos a cabo la verificación propiamente dicha:

   // Aquí utilizamos el módulo y el exponente para derivar la clave
    const auto n = jwk.get_jwk_claim("n").as_string(); // módulo
   const auto e = jwk.get_jwk_claim("e").as_string(); // exponente
    if (n.empty()|| e.empty()) {
        qWarning() << "Modulus or exponent empty";
       return false;
    }
    if (jwt.get_algorithm() != "RS256") { // Este ejemplo solo admite RS256
        qWarning() << "Unsupported algorithm:" << jwt.get_algorithm();
       return false;
    }
    if (jwk.get_jwk_claim("kty").as_string() != "RSA") {
        qWarning() << "Unsupported key type:" << jwk.get_jwk_claim("kty").as_string();
       return false;
    }
    if (jwk.has_jwk_claim("use")&& jwk.get_jwk_claim("use").as_string() != "sig") {
        qWarning() << "Key not for signature" << jwk.get_jwk_claim("use").as_string();
       return false;
    }
    // Verificación sencilla y mínima (omite casos especiales y, por ejemplo, la verificación de «sub»).
    // jwt-cpp también comprueba «exp», «iat» y «nbf» si están presentes.
   const auto keyPEM = jwt::helper::create_public_key_from_rsa_components(n, e);
    auto verifier = jwt::verify()
                        .allow_algorithm(jwt::algorithm::rs256(keyPEM))
                       .with_claim("nonce", jwt::claim(m_oauth.nonce().toStdString()))
                        .with_issuer(m_oidcConfig->value("issuer"_L1).toString().toStdString())
                       .with_audience(std::string(clientIdentifier.data()))
                        .leeway(60UL);
    verifier.verify(jwt);
    qDebug() << "ID Token verified successfully";
   return true;
} catch(const std::exception &e) {
    // Gestionar el error. Como alternativa, pasar el parámetro de error a las llamadas a jwt-cpp
    qWarning() << "ID Token verification failed" << e.what();
   return false;
}

Lectura de los valores de los tokens de identificación

El token de identificación está en formato JSON Web Token (JWT) y consta de una cabecera, una carga útil y una firma, separadas por puntos ..

Leer los valores del token de identificación es muy sencillo. A modo de ejemplo, supongamos que hay una estructura:

struct IDToken {
    QJsonObject header;
    QJsonObject payload;
    QByteArray signature;
};

Y una función:

std::optional<IDToken> parseIDToken(const QString &token) const;

El token se puede extraer con:

if (token.isEmpty())
    return std::nullopt;

QList<QByteArray> parts = token.toLatin1().split('.');
if (parts.size() != 3)
    return std::nullopt;

QJsonParseError parsing;

QJsonDocument header = QJsonDocument::fromJson(
    QByteArray::fromBase64(parts.at(0), QByteArray::Base64UrlEncoding), &parsing);
if (parsing.error != QJsonParseError::NoError || !header.isObject())
    return std::nullopt;

QJsonDocument payload = QJsonDocument::fromJson(
    QByteArray::fromBase64(parts.at(1), QByteArray::Base64UrlEncoding), &parsing);
if (parsing.error != QJsonParseError::NoError || !payload.isObject())
    return std::nullopt;

QByteArray signature = QByteArray::fromBase64(parts.at(2), QByteArray::Base64UrlEncoding);

return IDToken{header.object(), payload.object(), signature};

En algunos casos, el token puede estar cifrado mediante JSON Web Encryption (JWE), que contiene internamente un token JWT. En este caso, primero hay que descifrar el token.

Descubrimiento de OpenID Connect

El descubrimiento de OpenID Connect define los medios para obtener los datos necesarios del proveedor de OpenID, con el fin de interactuar con él. Esto incluye información como las URL authorization_endpoint y token_endpoint.

Aunque estos datos del proveedor pueden configurarse de forma estática en la aplicación, su detección en tiempo de ejecución puede aportar mayor flexibilidad y solidez a la hora de interactuar con distintos proveedores.

Para obtener el documento de descubrimiento basta con realizar una sencilla solicitud HTTP GET. El documento suele encontrarse en https://<domain name>/.well-known/openid_configuration.

m_network->get(request, this, [this](QRestReply &reply) {
    if (reply.isSuccess()) {
        if (auto doc = reply.readJson(); doc && doc->isObject())
            m_oidcConfig = doc->object(); // Store the configuration
    }
});

Cabe destacar que, para la validación de tokens, el campo jwks_uri proporciona un enlace para acceder a las credenciales de seguridad (públicas) actuales. El uso de este enlace elimina la necesidad de codificar directamente dichas credenciales en la aplicación. Esto también facilita la rotación de claves; los proveedores pueden cambiar las claves utilizadas de vez en cuando, por lo que es importante garantizar que la clave esté actualizada.

La obtención de las claves se realiza, de forma similar, mediante una sencilla solicitud HTTP GET:

m_network->get(request, this, [this](QRestReply &reply) {
    if (reply.isSuccess()) {
        if (auto doc = reply.readJson(); doc && doc->isObject())
            m_jwks = doc; // Use the keys later to verify tokens
    }
});

El conjunto de claves suele contener varias claves. La clave correcta se indica en el encabezado del JWT (hay que tener cuidado de hacer coincidir las claves correctamente; no basta con comprobar el campo de ID de la clave, kid).

Punto final de UserInfo de OpenID

Una forma alternativa de acceder a la información del usuario es utilizar el punto final UserInfo de OpenID Connect, si el proveedor de OIDC lo admite. La URL de la información del usuario se encuentra en el campo userinfo_endpoint del documento de descubrimiento de OpenID Connect.

El punto final UserInfo no utiliza el token de identificación, sino que se accede a él mediante el token de acceso. El acceso a UserInfo es similar al acceso a cualquier otro recurso con un token de acceso.

Suponiendo que se haya recibido y configurado el token de acceso, por ejemplo, mediante:

QNetworkRequestFactory userInfoApi(url);
userInfoApi.setBearerToken(m_oauth.token().toLatin1());

Entonces, para acceder a UserInfo se realiza una solicitud HTTP GET:

m_network->get(userInfoApi.createRequest(), this, [this](QRestReply&reply) {
    if (reply.isSuccess()) {
        if (auto doc = reply.readJson(); doc&& doc->isObject())
            qDebug() << doc->object(); // Use the userinfo
    }
});

© 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.