QSslSocket Class
La clase QSslSocket proporciona un socket cifrado mediante SSL tanto para clientes como para servidores. Más información...
| Encabezado: | #include <QSslSocket> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Network) target_link_libraries(mytarget PRIVATE Qt6::Network) |
| qmake: | QT += network |
| Heredado de: | QTcpSocket |
- Lista de todos los miembros, incluidos los heredados
- QSslSocket forma parte de la API de programación de redes.
Nota: Todas las funciones de esta clase son reentrantes.
Tipos públicos
| enum | PeerVerifyMode { VerifyNone, QueryPeer, VerifyPeer, AutoVerifyPeer } |
| enum | SslMode { UnencryptedMode, SslClientMode, SslServerMode } |
Funciones públicas
| QSslSocket(QObject *parent = nullptr) | |
| virtual | ~QSslSocket() |
| void | connectToHostEncrypted(const QString &hostName, quint16 port, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol) |
| void | connectToHostEncrypted(const QString &hostName, quint16 port, const QString &sslPeerName, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol) |
(since 6.0) void | continueInterruptedHandshake() |
| qint64 | encryptedBytesAvailable() const |
| qint64 | encryptedBytesToWrite() const |
| void | ignoreSslErrors(const QList<QSslError> &errors) |
| bool | isEncrypted() const |
| QSslCertificate | localCertificate() const |
| QList<QSslCertificate> | localCertificateChain() const |
| QSslSocket::SslMode | mode() const |
| QList<QOcspResponse> | ocspResponses() const |
| QSslCertificate | peerCertificate() const |
| QList<QSslCertificate> | peerCertificateChain() const |
| int | peerVerifyDepth() const |
| QSslSocket::PeerVerifyMode | peerVerifyMode() const |
| QString | peerVerifyName() const |
| QSslKey | privateKey() const |
| QSsl::SslProtocol | protocol() const |
| QSslCipher | sessionCipher() const |
| QSsl::SslProtocol | sessionProtocol() const |
| void | setLocalCertificate(const QSslCertificate &certificate) |
| void | setLocalCertificate(const QString &path, QSsl::EncodingFormat format = QSsl::Pem) |
| void | setLocalCertificateChain(const QList<QSslCertificate> &localChain) |
| void | setPeerVerifyDepth(int depth) |
| void | setPeerVerifyMode(QSslSocket::PeerVerifyMode mode) |
| void | setPeerVerifyName(const QString &hostName) |
| void | setPrivateKey(const QSslKey &key) |
| void | setPrivateKey(const QString &fileName, QSsl::KeyAlgorithm algorithm = QSsl::Rsa, QSsl::EncodingFormat format = QSsl::Pem, const QByteArray &passPhrase = QByteArray()) |
| void | setProtocol(QSsl::SslProtocol protocol) |
| void | setSslConfiguration(const QSslConfiguration &configuration) |
| QSslConfiguration | sslConfiguration() const |
| QList<QSslError> | sslHandshakeErrors() const |
| bool | waitForEncrypted(int msecs = 30000) |
Funciones públicas reimplementadas
| virtual bool | atEnd() const override |
| virtual qint64 | bytesAvailable() const override |
| virtual qint64 | bytesToWrite() const override |
| virtual bool | canReadLine() const override |
| virtual void | close() override |
| virtual void | connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol) override |
| virtual void | disconnectFromHost() override |
| virtual void | resume() override |
| virtual void | setReadBufferSize(qint64 size) override |
| virtual bool | setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState state = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite) override |
| virtual void | setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value) override |
| virtual QVariant | socketOption(QAbstractSocket::SocketOption option) override |
| virtual bool | waitForBytesWritten(int msecs = 30000) override |
| virtual bool | waitForConnected(int msecs = 30000) override |
| virtual bool | waitForDisconnected(int msecs = 30000) override |
| virtual bool | waitForReadyRead(int msecs = 30000) override |
Ranuras públicas
| void | ignoreSslErrors() |
| void | startClientEncryption() |
| void | startServerEncryption() |
Señales
| void | alertReceived(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description) |
| void | alertSent(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description) |
| void | encrypted() |
| void | encryptedBytesWritten(qint64 written) |
| void | handshakeInterruptedOnError(const QSslError &error) |
| void | modeChanged(QSslSocket::SslMode mode) |
| void | newSessionTicketReceived() |
| void | peerVerifyError(const QSslError &error) |
| void | preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator) |
| void | sslErrors(const QList<QSslError> &errors) |
Miembros públicos estáticos
(since 6.1) QString | activeBackend() |
(since 6.1) QList<QString> | availableBackends() |
(since 6.1) QList<QSsl::ImplementedClass> | implementedClasses(const QString &backendName = {}) |
(since 6.1) bool | isClassImplemented(QSsl::ImplementedClass cl, const QString &backendName = {}) |
(since 6.1) bool | isFeatureSupported(QSsl::SupportedFeature ft, const QString &backendName = {}) |
(since 6.1) bool | isProtocolSupported(QSsl::SslProtocol protocol, const QString &backendName = {}) |
(since 6.1) bool | setActiveBackend(const QString &backendName) |
| long | sslLibraryBuildVersionNumber() |
| QString | sslLibraryBuildVersionString() |
| long | sslLibraryVersionNumber() |
| QString | sslLibraryVersionString() |
(since 6.1) QList<QSsl::SupportedFeature> | supportedFeatures(const QString &backendName = {}) |
(since 6.1) QList<QSsl::SslProtocol> | supportedProtocols(const QString &backendName = {}) |
| bool | supportsSsl() |
Funciones protegidas reimplementadas
| virtual qint64 | readData(char *data, qint64 maxlen) override |
| virtual qint64 | skipData(qint64 maxSize) override |
| virtual qint64 | writeData(const char *data, qint64 len) override |
Elementos no miembros relacionados
(since 6.0) enum class | AlertLevel { Warning, Fatal, Unknown } |
(since 6.0) enum class | AlertType { CloseNotify, UnexpectedMessage, BadRecordMac, RecordOverflow, DecompressionFailure, …, UnknownAlertMessage } |
(since 6.1) enum class | ImplementedClass { Key, Certificate, Socket, DiffieHellman, EllipticCurve, …, DtlsCookie } |
(since 6.1) enum class | SupportedFeature { CertificateVerification, ClientSideAlpn, ServerSideAlpn, Ocsp, Psk, …, Alerts } |
Descripción detallada
QSslSocket establece una conexión TCP segura y cifrada que se puede utilizar para transmitir datos cifrados. Puede funcionar tanto en modo cliente como en modo servidor, y es compatible con los protocolos TLS modernos, incluido TLS 1.3. Por defecto, QSslSocket utiliza únicamente protocolos TLS que se consideran seguros (QSsl::SecureProtocols), pero puedes cambiar el protocolo TLS llamando a setProtocol() siempre que lo hagas antes de que comience el protocolo de enlace.
El cifrado SSL se aplica sobre el flujo TCP existente una vez que el socket entra en el estado «ConnectedState». Hay dos formas sencillas de establecer una conexión segura utilizando QSslSocket: mediante un protocolo de enlace SSL inmediato o mediante un protocolo de enlace SSL diferido que tiene lugar después de que la conexión se haya establecido en modo no cifrado.
La forma más habitual de utilizar QSslSocket es crear un objeto e iniciar una conexión segura llamando a connectToHostEncrypted(). Este método inicia un protocolo de enlace SSL inmediato una vez establecida la conexión.
QSslSocket *socket = new QSslSocket(this);
connect(socket, &QSslSocket::encrypted, this, &Receiver::ready);
socket->connectToHostEncrypted("imap.example.com", 993);Al igual que con un ` QTcpSocket` sin más, `QSslSocket` pasa por los estados `HostLookupState`, `ConnectingState` y, finalmente, `ConnectedState`, si la conexión se establece correctamente. A continuación, el protocolo de enlace se inicia automáticamente y, si tiene éxito, se emite la señal ` encrypted()` para indicar que el socket ha entrado en el estado cifrado y está listo para su uso.
Tenga en cuenta que se pueden escribir datos en el socket inmediatamente después de que se devuelva el resultado de ` connectToHostEncrypted()` (es decir, antes de que se emita la señal ` encrypted()`). Los datos se colocan en cola en `QSslSocket` hasta que se emita la señal ` encrypted()`.
Un ejemplo del uso del handshake SSL retardado para proteger una conexión existente es el caso en el que un servidor SSL protege una conexión entrante. Supongamos que creas una clase de servidor SSL como subclase de ` QTcpServer`. Tendrías que sobrescribir ` QTcpServer::incomingConnection()` con algo similar al ejemplo siguiente, que primero crea una instancia de `QSslSocket` y, a continuación, llama a ` setSocketDescriptor()` para establecer el descriptor del nuevo socket en el ya existente que se le ha pasado como parámetro. A continuación, inicia el protocolo de enlace SSL llamando a ` startServerEncryption()`.
void SslServer::incomingConnection(qintptr socketDescriptor)
{
QSslSocket *serverSocket = new QSslSocket;
if (serverSocket->setSocketDescriptor(socketDescriptor)) {
addPendingConnection(serverSocket);
connect(serverSocket, &QSslSocket::encrypted, this, &SslServer::ready);
serverSocket->startServerEncryption();
} else {
delete serverSocket;
}
}Si se produce un error, QSslSocket emite la señal sslErrors(). En este caso, si no se toma ninguna medida para ignorar el error o los errores, la conexión se interrumpe. Para continuar, a pesar de que se haya producido un error, se puede llamar a ` ignoreSslErrors()` (), ya sea desde dentro de esta ranura tras producirse el error, o en cualquier momento tras la creación del `QSslSocket` y antes de que se intente establecer la conexión. Esto permitirá a `QSslSocket` ignorar los errores que encuentre al establecer la identidad del interlocutor. Ignorar los errores durante un protocolo de enlace SSL debe hacerse con precaución, ya que una característica fundamental de las conexiones seguras es que deben establecerse mediante un protocolo de enlace correcto.
Una vez cifrado, se utiliza QSslSocket como un ` QTcpSocket` normal. Cuando se emite ` readyRead()`, se puede llamar a ` read()`, ` canReadLine()` y ` readLine()`, o a ` getChar()` para leer los datos descifrados del búfer interno de QSslSocket, y se puede llamar a ` write()` o ` putChar()` para reescribir datos al interlocutor. QSslSocket cifrará automáticamente los datos escritos y emitirá encryptedBytesWritten() una vez que los datos se hayan escrito al interlocutor.
Para mayor comodidad, QSslSocket admite las funciones de bloqueo de QTcpSocket: waitForConnected(), waitForReadyRead(), waitForBytesWritten() y waitForDisconnected(). También proporciona waitForEncrypted(), que bloqueará el hilo de llamada hasta que se haya establecido una conexión cifrada.
QSslSocket socket;
socket.connectToHostEncrypted("http.example.com", 443);
if (!socket.waitForEncrypted()) {
qDebug() << socket.errorString();
return false;
}
socket.write("GET / HTTP/1.0\r\n\r\n");
while (socket.waitForReadyRead())
qDebug() << socket.readAll().data();QSslSocket ofrece una API completa y fácil de usar para gestionar algoritmos criptográficos, claves privadas y certificados locales, de pares y de Autoridades de Certificación (CA). También proporciona una API para gestionar los errores que se producen durante la fase de establecimiento de la conexión.
Las siguientes características también se pueden personalizar:
- El conjunto de algoritmos criptográficos del socket se puede personalizar antes de la fase de establecimiento de la conexión mediante QSslConfiguration::setCiphers().
- El certificado local y la clave privada del socket se pueden personalizar antes de la fase de establecimiento de conexión mediante setLocalCertificate() y setPrivateKey().
- La base de datos de certificados de CA se puede ampliar y personalizar con QSslConfiguration::addCaCertificate() y QSslConfiguration::addCaCertificates().
Para ampliar la lista de certificados de CA predeterminados que utilizan los sockets SSL durante el protocolo de enlace SSL, debes actualizar la configuración predeterminada, tal y como se muestra en el fragmento de código siguiente:
QList<QSslCertificate> certificates = getCertificates();
QSslConfiguration configuration = QSslConfiguration::defaultConfiguration();
configuration.addCaCertificates(certificates);
QSslConfiguration::setDefaultConfiguration(configuration);Nota: Si están disponibles, los certificados raíz en Unix (excepto en macOS) se cargarán bajo demanda desde los directorios de certificados estándar. Si no deseas cargar los certificados raíz bajo demanda, debes llamar a ` QSslConfiguration::defaultConfiguration()`.setCaCertificates()` antes de que se realice el primer protocolo de enlace SSL en tu aplicación (por ejemplo, pasándole QSslSocket::systemCaCertificates()), o bien llamar a QSslConfiguration::defaultConfiguration()::setCaCertificates() en tu instancia de QSslSocket antes del protocolo de enlace SSL.
Para obtener más información sobre cifrados y certificados, consulte QSslCipher y QSslCertificate.
Este producto incluye software desarrollado por el Proyecto OpenSSL para su uso en el kit de herramientas OpenSSL (http://www.openssl.org/).
Nota: Tenga en cuenta la diferencia entre la señal bytesWritten() y la señal encryptedBytesWritten(). En el caso de un QTcpSocket, se emitirá bytesWritten() tan pronto como se hayan escrito datos en el socket TCP. En el caso de un QSslSocket, se emitirá bytesWritten() cuando se estén cifrando los datos y encryptedBytesWritten() tan pronto como se hayan escrito datos en el socket TCP.
Véase también QSslCertificate, QSslCipher y QSslError.
Documentación sobre los tipos de miembros
enum QSslSocket::PeerVerifyMode
Describe los modos de verificación de pares para ` QSslSocket`. El modo predeterminado es `AutoVerifyPeer`, que selecciona el modo adecuado en función del valor de `QSocket::SslMode` del socket.
| Constante | Valor | Descripción |
|---|---|---|
QSslSocket::VerifyNone | 0 | QSslSocket No solicitará un certificado al par. Puedes establecer este modo si no te interesa la identidad de la otra parte de la conexión. La conexión seguirá estando cifrada, y tu socket seguirá enviando su certificado local al par si se le solicita. |
QSslSocket::QueryPeer | 1 | QSslSocket Solicitará un certificado al par, pero no exige que dicho certificado sea válido. Esto resulta útil cuando se desea mostrar al usuario los detalles del certificado del par sin afectar al protocolo de enlace SSL propiamente dicho. Este modo es el predeterminado para los servidores. Nota: En Schannel, este valor funciona igual que VerifyNone. |
QSslSocket::VerifyPeer | 2 | QSslSocket Solicitará un certificado al par durante la fase de establecimiento de la conexión SSL y exigirá que dicho certificado sea válido. En caso de fallo, QSslSocket emitirá la señal QSslSocket::sslErrors(). Este modo es el predeterminado para los clientes. |
QSslSocket::AutoVerifyPeer | 3 | QSslSocket Utilizará automáticamente QueryPeer para los sockets de servidor y VerifyPeer para los sockets de cliente. |
Véase también QSslSocket::peerVerifyMode().
enum QSslSocket::SslMode
Describe los modos de conexión disponibles para QSslSocket.
| Constante | Valor | Descripción |
|---|---|---|
QSslSocket::UnencryptedMode | 0 | El socket no está cifrado. Su comportamiento es idéntico al de QTcpSocket. |
QSslSocket::SslClientMode | 1 | El socket es un socket SSL del lado del cliente. O bien ya está cifrado, o bien se encuentra en la fase de establecimiento de conexión SSL (véase QSslSocket::isEncrypted()). |
QSslSocket::SslServerMode | 2 | El socket es un socket SSL del lado del servidor. O bien ya está cifrado, o bien se encuentra en la fase de establecimiento de conexión SSL (véase QSslSocket::isEncrypted()). |
Documentación de las funciones miembro
[explicit] QSslSocket::QSslSocket(QObject *parent = nullptr)
Crea un objeto QSslSocket. Se pasa « parent » al constructor de « QObject ». El conjunto de cifrado « cipher » del nuevo socket se establece en el que devuelve el método estático «defaultCiphers()».
[virtual noexcept] QSslSocket::~QSslSocket()
Destruye el « QSslSocket ».
[static, since 6.1] QString QSslSocket::activeBackend()
Devuelve el nombre del backend que utilizan QSslSocket y las clases relacionadas. Si el backend activo no se ha establecido explícitamente, esta función devuelve el nombre de un backend por defecto que QSslSocket selecciona implícitamente de la lista de backends disponibles.
Nota: Al seleccionar un backend predeterminado de forma implícita, QSslSocket da preferencia al backend de OpenSSL si está disponible. Si no lo está, se selecciona implícitamente el backend de Schannel en Windows y el de Secure Transport en plataformas Darwin. En su defecto, si se encuentra un backend TLS personalizado, se utiliza este. Si no se encuentra ningún otro backend, se selecciona el backend «solo certificado». Para obtener más información sobre los complementos TLS, consulta «Habilitar y deshabilitar la compatibilidad con SSL al compilar Qt desde el código fuente».
Esta función se introdujo en Qt 6.1.
Véase también setActiveBackend() y availableBackends().
[signal] void QSslSocket::alertReceived(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)
QSslSocket Emite esta señal si se ha recibido un mensaje de alerta de un par. « level » indica si la alerta fue grave o si se trataba de una advertencia. « type » es el código que explica por qué se envió la alerta. Cuando hay disponible una descripción textual del mensaje de alerta, se proporciona en « description ».
Nota: La señal tiene principalmente fines informativos y de depuración, y no requiere ningún tipo de gestión por parte de la aplicación. Si la alerta fue grave, el backend subyacente se encargará de gestionarla y cerrará la conexión.
Nota: No todos los backends admiten esta funcionalidad.
Véase también alertSent(), QSsl::AlertLevel y QSsl::AlertType.
[signal] void QSslSocket::alertSent(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)
QSslSocket Emite esta señal si se ha enviado un mensaje de alerta a un par. level indica si se trata de una advertencia o de un error grave. type proporciona el código del mensaje de alerta. Cuando hay disponible una descripción textual del mensaje de alerta, se incluye en description.
Nota: Esta señal tiene carácter principalmente informativo y puede utilizarse con fines de depuración; normalmente no requiere ninguna acción por parte de la aplicación.
Nota: No todos los backends admiten esta funcionalidad.
Véase también alertReceived(), QSsl::AlertLevel y QSsl::AlertType.
[override virtual] bool QSslSocket::atEnd() const
Reimplementa: QIODevice::atEnd() const.
[static, since 6.1] QList<QString> QSslSocket::availableBackends()
Devuelve los nombres de los backends disponibles actualmente. Estos nombres están en minúsculas, por ejemplo: «openssl», «securetransport», «schannel» (similares a los nombres de las funciones ya existentes para los backends TLS en Qt).
Esta función se introdujo en Qt 6.1.
Véase también activeBackend().
[override virtual] qint64 QSslSocket::bytesAvailable() const
Reimplementa: ` QAbstractSocket::bytesAvailable()` const.
Devuelve el número de bytes descifrados que están disponibles inmediatamente para su lectura.
[override virtual] qint64 QSslSocket::bytesToWrite() const
Reimplementa: ` QAbstractSocket::bytesToWrite()` const.
Devuelve el número de bytes sin cifrar que están a la espera de ser cifrados y escritos en la red.
[override virtual] bool QSslSocket::canReadLine() const
Reimplementa: QIODevice::canReadLine() const.
Devuelve ` true ` si se puede leer una línea de texto (terminada por un único carácter ASCII «\n »); en caso contrario, se devuelve `false`.
[override virtual] void QSslSocket::close()
Reimplementa: QAbstractSocket::close().
[override virtual] void QSslSocket::connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)
Reimplementa: QAbstractSocket::connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol).
void QSslSocket::connectToHostEncrypted(const QString &hostName, quint16 port, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)
Inicia una conexión cifrada con el dispositivo hostName en port, utilizando mode como OpenMode. Esto equivale a llamar a connectToHost() para establecer la conexión, seguido de una llamada a startClientEncryption(). El parámetro protocol se puede utilizar para especificar qué protocolo de red se va a utilizar (por ejemplo, IPv4 o IPv6).
QSslSocket Entra primero en el estado `HostLookupState`. A continuación, tras entrar en el bucle de eventos o en una de las funciones `waitFor...()`, pasa al estado `ConnectingState`, emite ` connected()` y, a continuación, inicia el protocolo de enlace SSL del cliente. En cada cambio de estado, ` QSslSocket ` emite la señal ` stateChanged()`.
Tras iniciar el protocolo de enlace del cliente SSL, si no se puede establecer la identidad del interlocutor, se emite la señal sslErrors(). Si se desea ignorar los errores y continuar con la conexión, se debe llamar a ` ignoreSslErrors()`, ya sea desde el interior de una función de slot conectada a la señal ` sslErrors()`, o antes de entrar en modo cifrado. Si no se llama a ` ignoreSslErrors()`, la conexión se interrumpe, se emite la señal ` disconnected()` y ` QSslSocket ` vuelve al estado `UnconnectedState`.
Si el protocolo de enlace SSL se establece correctamente, QSslSocket emite la señal encrypted().
QSslSocket socket;
connect(&socket, &QSslSocket::encrypted, receiver, &Receiver::socketEncrypted);
socket.connectToHostEncrypted("imap", 993);
socket->write("1 CAPABILITY\r\n");Nota: El ejemplo anterior muestra que se puede escribir texto en el socket inmediatamente después de solicitar la conexión cifrada, antes de que se haya emitido la señal encrypted(). En tales casos, el texto se pone en cola en el objeto y se escribe en el socket una vez establecida la conexión y emitida la señal encrypted().
El valor por defecto de ` mode ` es ` ReadWrite`.
Si deseas crear un ` QSslSocket ` en el lado del servidor de una conexión, debes llamar a ` startServerEncryption()` al recibir la conexión entrante a través de ` QTcpServer`.
Véase también connectToHost(), startClientEncryption(), waitForConnected() y waitForEncrypted().
void QSslSocket::connectToHostEncrypted(const QString &hostName, quint16 port, const QString &sslPeerName, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)
Además del comportamiento original de `connectToHostEncrypted`, este método sobrecargado permite utilizar un nombre de host diferente (sslPeerName) para la validación del certificado, en lugar del que se utiliza para la conexión TCP (hostName).
Se trata de una función sobrecargada.
Véase también connectToHostEncrypted().
[since 6.0] void QSslSocket::continueInterruptedHandshake()
Si una aplicación desea finalizar un handshake incluso después de recibir una señal « handshakeInterruptedOnError()», debe llamar a esta función. Esta llamada debe realizarse desde una función de slot asociada a la señal. La conexión señal-slot debe ser directa.
Esta función se introdujo en Qt 6.0.
Véanse también ` handshakeInterruptedOnError()` y ` QSslConfiguration::setHandshakeMustInterruptOnError()`.
[override virtual] void QSslSocket::disconnectFromHost()
Reimplementa: QAbstractSocket::disconnectFromHost().
[signal] void QSslSocket::encrypted()
Esta señal se emite cuando QSslSocket entra en modo cifrado. Una vez emitida esta señal, QSslSocket::isEncrypted() devolverá «true», y todas las transmisiones posteriores a través del socket se cifrarán.
Véase también QSslSocket::connectToHostEncrypted() y QSslSocket::isEncrypted().
qint64 QSslSocket::encryptedBytesAvailable() const
Devuelve el número de bytes cifrados que están pendientes de descifrado. Normalmente, esta función devolverá 0, ya que QSslSocket descifra los datos que recibe tan pronto como puede.
qint64 QSslSocket::encryptedBytesToWrite() const
Devuelve el número de bytes cifrados que están a la espera de ser escritos en la red.
[signal] void QSslSocket::encryptedBytesWritten(qint64 written)
Esta señal se emite cuando QSslSocket escribe sus datos cifrados en la red. El parámetro written contiene el número de bytes que se han escrito correctamente.
Véase también QIODevice::bytesWritten().
[signal] void QSslSocket::handshakeInterruptedOnError(const QSslError &error)
QSslSocket Emite esta señal si se ha detectado un error en la verificación del certificado y si se ha habilitado la notificación temprana de errores en QSslConfiguration. Se espera que la aplicación compruebe el error y decida si desea continuar con el protocolo de enlace o interrumpirlo y enviar un mensaje de alerta al interlocutor. La conexión señal-ranura debe ser directa.
Véase también continueInterruptedHandshake(), sslErrors() y QSslConfiguration::setHandshakeMustInterruptOnError().
[slot] void QSslSocket::ignoreSslErrors()
Esta ranura indica a QSslSocket que ignore los errores durante la fase de establecimiento de conexión de QSslSocket y continúe con la conexión. Si deseas continuar con la conexión aunque se produzcan errores durante la fase de establecimiento de conexión, debes llamar a esta ranura, ya sea desde una ranura conectada a sslErrors(), o antes de la fase de establecimiento de conexión. Si no se llama a esta ranura, ya sea en respuesta a errores o antes del establecimiento de la conexión, la conexión se interrumpirá tras la emisión de la señal « sslErrors()».
Si no se producen errores durante la fase de establecimiento de conexión SSL (es decir, si la identidad del interlocutor se establece sin problemas), QSslSocket no emitirá la señal sslErrors() y no es necesario llamar a esta función.
Advertencia: Asegúrate de permitir siempre que el usuario revise los errores notificados por la señal sslErrors(), y solo llama a este método tras recibir la confirmación del usuario de que puede continuar. Si se producen errores inesperados, la conexión debe interrumpirse. Llamar a este método sin revisar los errores reales supondrá, con toda probabilidad, un riesgo de seguridad para tu aplicación. ¡Úsalo con mucho cuidado!
Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:
// Connect using qOverload:
connect(sender, &SenderClass::signal,
sslSocket, qOverload<>(&QSslSocket::ignoreSslErrors));
// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
sslSocket, [receiver = sslSocket]() { receiver->ignoreSslErrors(); });Véase también sslErrors().
void QSslSocket::ignoreSslErrors(const QList<QSslError> &errors)
Este método indica a QSslSocket que ignore únicamente los errores indicados en errors.
Nota: Dado que la mayoría de los errores SSL están relacionados con un certificado, para la mayoría de ellos debes configurar el certificado esperado al que se refiere dicho error SSL. Si, por ejemplo, deseas conectarte a un servidor que utiliza un certificado autofirmado, ten en cuenta el siguiente fragmento de código:
QList<QSslCertificate> cert = QSslCertificate::fromPath("server-certificate.pem"_L1);
QSslError error(QSslError::SelfSignedCertificate, cert.at(0));
QList<QSslError> expectedSslErrors;
expectedSslErrors.append(error);
QSslSocket socket;
socket.ignoreSslErrors(expectedSslErrors);
socket.connectToHostEncrypted("server.tld", 443);Las llamadas múltiples a esta función sustituirán la lista de errores que se haya pasado en llamadas anteriores. Puedes borrar la lista de errores que deseas ignorar llamando a esta función con una lista vacía.
Esta es una función sobrecargada.
Véase también sslErrors() y sslHandshakeErrors().
[static, since 6.1] QList<QSsl::ImplementedClass> QSslSocket::implementedClasses(const QString &backendName = {})
Esta función devuelve las clases específicas del backend implementadas por el backend denominado « backendName ». Si se proporciona un « backendName » vacío, se interpreta como una consulta sobre el backend actualmente activo.
Esta función se introdujo en Qt 6.1.
Véase también QSsl::ImplementedClass, activeBackend() y isClassImplemented().
[static, since 6.1] bool QSslSocket::isClassImplemented(QSsl::ImplementedClass cl, const QString &backendName = {})
Devuelve «true» si el backend denominado « backendName » implementa la clase « cl ». Si « backendName » está vacío, se interpreta como una consulta sobre el backend actualmente activo.
Esta función se introdujo en Qt 6.1.
Véase también implementedClasses().
bool QSslSocket::isEncrypted() const
Devuelve ` true ` si el socket está cifrado; en caso contrario, devuelve `false`.
Un socket cifrado cifra todos los datos que se escriben llamando a ` write()` o ` putChar()` antes de que los datos se envíen a la red, y descifra todos los datos entrantes a medida que se reciben de la red, antes de llamar a ` read()`, ` readLine()` o ` getChar()`.
QSslSocket Emite encrypted() cuando entra en modo cifrado.
Puedes llamar a sessionCipher() para averiguar qué algoritmo criptográfico se utiliza para cifrar y descifrar tus datos.
Véase también mode().
[static, since 6.1] bool QSslSocket::isFeatureSupported(QSsl::SupportedFeature ft, const QString &backendName = {})
Devuelve «true» si una función ft es compatible con un backend denominado backendName. Si backendName está vacío, se interpreta como una consulta sobre el backend actualmente activo.
Esta función se introdujo en Qt 6.1.
Véase también QSsl::SupportedFeature y supportedFeatures().
[static, since 6.1] bool QSslSocket::isProtocolSupported(QSsl::SslProtocol protocol, const QString &backendName = {})
Devuelve «true» si el backend denominado « backendName » admite « protocol ». Si « backendName » está vacío, se interpreta como una consulta sobre el backend actualmente activo.
Esta función se introdujo en Qt 6.1.
Véase también supportedProtocols().
QSslCertificate QSslSocket::localCertificate() const
Devuelve el certificado local del socket certificate, o un certificado vacío si no se ha asignado ningún certificado local.
Véase también setLocalCertificate() y privateKey().
QList<QSslCertificate> QSslSocket::localCertificateChain() const
Devuelve la cadena de certificados locales certificate del socket, o una lista vacía si no se ha asignado ningún certificado local.
Véase también ` setLocalCertificateChain()` ().
QSslSocket::SslMode QSslSocket::mode() const
Devuelve el modo actual del socket; puede ser « UnencryptedMode », en cuyo caso « QSslSocket » se comporta de forma idéntica a « QTcpSocket », o bien uno de los siguientes: « SslClientMode » o « SslServerMode », en los que el cliente se encuentra en modo de negociación o en modo cifrado.
Cuando cambia el modo, QSslSocket emite modeChanged()
Véase también SslMode.
[signal] void QSslSocket::modeChanged(QSslSocket::SslMode mode)
Esta señal se emite cuando QSslSocket cambia de QSslSocket::UnencryptedMode a QSslSocket::SslClientMode o QSslSocket::SslServerMode. mode es el nuevo modo.
Véase también QSslSocket::mode().
[signal] void QSslSocket::newSessionTicketReceived()
Si se ha negociado el protocolo TLS 1.3 durante un handshake, QSslSocket emite esta señal tras recibir el mensaje NewSessionTicket. La duración de la sesión y la indicación de la duración del ticket de sesión se actualizan en la configuración del socket. La sesión puede utilizarse para reanudar la sesión (y realizar un handshake abreviado) en futuras conexiones TLS.
Nota: Esta funcionalidad solo está habilitada con el backend de OpenSSL y requiere OpenSSL v 1.1.1 o superior.
Véase también QSslSocket::sslConfiguration(), QSslConfiguration::sessionTicket() y QSslConfiguration::sessionTicketLifeTimeHint().
QList<QOcspResponse> QSslSocket::ocspResponses() const
Esta función devuelve las respuestas del Protocolo de estado de certificados en línea (OCSP) que un servidor puede enviar durante un protocolo de enlace TLS utilizando OCSP stapling. La lista está vacía si no se ha recibido ninguna respuesta definitiva o si no se ha recibido respuesta alguna.
Véase también QSslConfiguration::setOcspStaplingEnabled().
QSslCertificate QSslSocket::peerCertificate() const
Devuelve el certificado digital del interlocutor (es decir, el certificado directo del host al que estás conectado) o un certificado nulo, si el interlocutor no ha asignado ningún certificado.
El certificado del par se comprueba automáticamente durante la fase de establecimiento de la conexión, por lo que esta función se utiliza normalmente para obtener el certificado con fines de visualización o de diagnóstico de la conexión. Contiene información sobre el par, incluyendo su nombre de host, el emisor del certificado y la clave pública del par.
Dado que el certificado del par se establece durante la fase de establecimiento de la conexión, es seguro acceder a él desde un canal conectado a la señal « sslErrors()» o a la señal « encrypted()».
Si se devuelve un certificado nulo, puede significar que el protocolo de enlace SSL ha fallado, que el host al que estás conectado no tiene certificado o que no hay conexión.
Si desea comprobar la cadena completa de certificados del par, utilice peerCertificateChain() para obtenerlos todos de una vez.
Véase también peerCertificateChain().
QList<QSslCertificate> QSslSocket::peerCertificateChain() const
Devuelve la cadena de certificados digitales del interlocutor o una lista vacía de certificados.
Los certificados del interlocutor se comprueban automáticamente durante la fase de establecimiento de la conexión. Esta función se utiliza normalmente para obtener certificados con el fin de mostrarlos o para realizar diagnósticos de la conexión. Los certificados contienen información sobre el interlocutor y los emisores de los certificados, incluyendo el nombre del host, los nombres de los emisores y las claves públicas de los emisores.
Los certificados del par se establecen en ` QSslSocket ` durante la fase de establecimiento de la conexión, por lo que es seguro llamar a esta función desde un slot conectado a la señal ` sslErrors()` o a la señal ` encrypted()`.
Si se devuelve una lista vacía, puede significar que el protocolo de enlace SSL ha fallado, que el host al que estás conectado no tiene certificado o que no hay conexión.
Si solo quieres obtener el certificado inmediato del par, utiliza peerCertificate().
Véase también ` peerCertificate()`.
int QSslSocket::peerVerifyDepth() const
Devuelve el número máximo de certificados de la cadena de certificados del interlocutor que se deben comprobar durante la fase de establecimiento de la conexión SSL, o 0 (el valor por defecto) si no se ha establecido ninguna profundidad máxima, lo que indica que se debe comprobar toda la cadena de certificados.
Los certificados se comprueban en el orden de emisión, empezando por el propio certificado del interlocutor, seguido del certificado de su emisor, y así sucesivamente.
Véase también setPeerVerifyDepth() y peerVerifyMode().
[signal] void QSslSocket::peerVerifyError(const QSslError &error)
QSslSocket Puede emitir esta señal varias veces durante el protocolo de enlace SSL, antes de que se haya establecido el cifrado, para indicar que se ha producido un error al verificar la identidad del interlocutor. La señal « error » suele indicar que QSslSocket no puede identificar de forma segura al interlocutor.
Esta señal te proporciona una indicación temprana de que algo va mal. Al conectarte a esta señal, puedes optar manualmente por interrumpir la conexión desde el interior del slot conectado antes de que se haya completado el protocolo de enlace. Si no se toma ninguna medida, ` QSslSocket ` procederá a emitir ` QSslSocket::sslErrors()` ().
Véase también sslErrors().
QSslSocket::PeerVerifyMode QSslSocket::peerVerifyMode() const
Devuelve el modo de verificación del socket. Este modo determina si QSslSocket debe solicitar un certificado al interlocutor (es decir, si el cliente solicita un certificado al servidor o si el servidor solicita un certificado al cliente) y si debe exigir que dicho certificado sea válido.
El modo predeterminado es « AutoVerifyPeer », que indica a « QSslSocket » que utilice « VerifyPeer » para los clientes y « QueryPeer » para los servidores.
Véanse también setPeerVerifyMode(), peerVerifyDepth() y mode().
QString QSslSocket::peerVerifyName() const
Devuelve el nombre de host diferente para la validación del certificado, tal y como se ha configurado en setPeerVerifyName o en connectToHostEncrypted.
Véase también setPeerVerifyName() y connectToHostEncrypted().
[signal] void QSslSocket::preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator)
QSslSocket emite esta señal cuando negocia un conjunto de cifrado PSK, por lo que a continuación se requiere una autenticación PSK.
Al utilizar PSK, el cliente debe enviar al servidor una identidad válida y una clave precompartida válida para que el protocolo de enlace SSL pueda continuar. Las aplicaciones pueden proporcionar esta información en un slot conectado a esta señal, rellenando el objeto ` authenticator ` pasado según sus necesidades.
Nota: Ignorar esta señal o no proporcionar las credenciales necesarias provocará que el protocolo de enlace falle y, por lo tanto, que la conexión se interrumpa.
Nota: El objeto ` authenticator ` es propiedad del socket y la aplicación no debe eliminarlo.
Véase también QSslPreSharedKeyAuthenticator.
QSslKey QSslSocket::privateKey() const
Devuelve la clave privada de este socket.
Véase también setPrivateKey() y localCertificate().
QSsl::SslProtocol QSslSocket::protocol() const
Devuelve el protocolo SSL del socket. Por defecto, se utiliza QSsl::SecureProtocols.
Véase también setProtocol().
[override virtual protected] qint64 QSslSocket::readData(char *data, qint64 maxlen)
Reimplementa: QAbstractSocket::readData(char *data, qint64 maxSize).
[override virtual] void QSslSocket::resume()
Reimplementa: ` QAbstractSocket::resume()`.
Reanuda la transferencia de datos en el socket después de que se haya pausado. Si se ha llamado a «setPauseMode(QAbstractSocket::PauseOnSslErrors);» en este socket y se recibe una señal de « sslErrors()», es necesario llamar a este método para que el socket continúe.
Véase también QAbstractSocket::pauseMode() y QAbstractSocket::setPauseMode().
QSslCipher QSslSocket::sessionCipher() const
Devuelve el algoritmo criptográfico ( cipher) del socket, o un valor nulo si la conexión no está cifrada. El algoritmo del socket para la sesión se establece durante la fase de establecimiento de la conexión. El algoritmo se utiliza para cifrar y descifrar los datos transmitidos a través del socket.
QSslSocket También proporciona funciones para establecer la lista ordenada de cifrados entre los que la fase de establecimiento de conexión seleccionará finalmente el cifrado de sesión. Esta lista ordenada debe estar definida antes de que comience la fase de establecimiento de conexión.
Véase también QSslConfiguration::ciphers(), QSslConfiguration::setCiphers() y QSslConfiguration::supportedCiphers().
QSsl::SslProtocol QSslSocket::sessionProtocol() const
Devuelve el protocolo SSL/TLS del socket o «UnknownProtocol» si la conexión no está cifrada. El protocolo del socket para la sesión se establece durante la fase de establecimiento de la conexión.
Véase también protocol() y setProtocol().
[static, since 6.1] bool QSslSocket::setActiveBackend(const QString &backendName)
Devuelve «true» si se ha establecido como backend activo uno con el nombre « backendName ». « backendName » debe ser uno de los nombres devueltos por la función « availableBackends()».
Nota: Una aplicación no puede mezclar diferentes backends simultáneamente. Esto implica que se debe seleccionar un backend distinto del predeterminado antes de utilizar QSslSocket o clases relacionadas, como QSslCertificate o QSslKey.
Esta función se introdujo en Qt 6.1.
Véase también activeBackend() y availableBackends().
void QSslSocket::setLocalCertificate(const QSslCertificate &certificate)
Establece el certificado local del socket en certificate. El certificado local es necesario si necesitas confirmar tu identidad ante el interlocutor. Se utiliza junto con la clave privada; si configuras el certificado local, también debes configurar la clave privada.
El certificado local y la clave privada son siempre necesarios para los sockets de servidor, pero también suelen utilizarse en los sockets de cliente si el servidor exige que el cliente se autentique.
Nota: El backend SSLde Secure Transport en macOS puede actualizar el llavero predeterminado (probablemente sea el llavero de inicio de sesión) al importar tus certificados y claves locales. Esto también puede provocar que aparezcan cuadros de diálogo del sistema solicitando permiso cuando tu aplicación utilice estas claves privadas. Si no deseas este comportamiento, establece la variable de entorno QT_SSL_USE_TEMPORARY_KEYCHAIN en un valor distinto de cero; esto hará que QSslSocket utilice su propio llavero temporal.
Véanse también localCertificate() y setPrivateKey().
void QSslSocket::setLocalCertificate(const QString &path, QSsl::EncodingFormat format = QSsl::Pem)
Establece el « certificate » local del socket como el primero que se encuentre en el archivo « path », que se analiza según el « format » especificado.
Esta es una función sobrecargada.
void QSslSocket::setLocalCertificateChain(const QList<QSslCertificate> &localChain)
Establece que la cadena de certificados que se presentará al interlocutor durante el protocolo de enlace SSL sea localChain.
Véase también localCertificateChain() y QSslConfiguration::setLocalCertificateChain().
void QSslSocket::setPeerVerifyDepth(int depth)
Establece el número máximo de certificados de la cadena de certificados del par que se comprobarán durante la fase de establecimiento de la conexión SSL, en depth. Establecer una profundidad de 0 significa que no se fija ninguna profundidad máxima, lo que indica que se debe comprobar toda la cadena de certificados.
Los certificados se comprueban en el orden de emisión, comenzando por el propio certificado del interlocutor, seguido del certificado de su emisor, y así sucesivamente.
Véanse también peerVerifyDepth() y setPeerVerifyMode().
void QSslSocket::setPeerVerifyMode(QSslSocket::PeerVerifyMode mode)
Establece el modo de verificación del socket en « mode ». Este modo determina si « QSslSocket » debe solicitar un certificado al interlocutor (es decir, si el cliente solicita un certificado al servidor o si el servidor solicita un certificado al cliente) y si debe exigir que dicho certificado sea válido.
El modo predeterminado es « AutoVerifyPeer », que indica a QSslSocket que utilice « VerifyPeer » para los clientes y « QueryPeer » para los servidores.
Establecer este modo una vez iniciado el cifrado no tiene ningún efecto sobre la conexión actual.
Véase también peerVerifyMode(), setPeerVerifyDepth() y mode().
void QSslSocket::setPeerVerifyName(const QString &hostName)
Establece un nombre de host diferente, indicado en hostName, para la validación del certificado, en lugar del que se utiliza para la conexión TCP.
Véase también peerVerifyName() y connectToHostEncrypted().
void QSslSocket::setPrivateKey(const QSslKey &key)
Establece el certificado privado del socket ( key ) en key. La clave privada y el certificado local ( certificate ) son utilizados por los clientes y servidores que deben demostrar su identidad ante sus pares SSL.
Tanto la clave como el certificado local son necesarios si se está creando un socket de servidor SSL. Si se está creando un socket de cliente SSL, la clave y el certificado local son necesarios si el cliente debe identificarse ante un servidor SSL.
Véase también privateKey() y setLocalCertificate().
void QSslSocket::setPrivateKey(const QString &fileName, QSsl::KeyAlgorithm algorithm = QSsl::Rsa, QSsl::EncodingFormat format = QSsl::Pem, const QByteArray &passPhrase = QByteArray())
Lee la cadena del archivo fileName y la decodifica utilizando un algorithm y una codificación format especificados para construir un SSL key. Si la clave codificada está cifrada, se utiliza passPhrase para descifrarla.
La clave privada del socket se establece como la clave generada. La clave privada y el certificate local son utilizados por los clientes y servidores que deben demostrar su identidad ante los pares SSL.
Tanto la clave como el certificado local son necesarios si se crea un socket de servidor SSL. Si se crea un socket de cliente SSL, la clave y el certificado local son necesarios si el cliente debe identificarse ante un servidor SSL.
Esta es una función sobrecargada.
Véase también privateKey() y setLocalCertificate().
void QSslSocket::setProtocol(QSsl::SslProtocol protocol)
Establece el protocolo SSL del socket en protocol. Esto afectará al siguiente proceso de establecimiento de conexión que se inicie; llamar a esta función en un socket que ya esté cifrado no afectará al protocolo del socket.
Véase también protocol().
[override virtual] void QSslSocket::setReadBufferSize(qint64 size)
Reimplementa: QAbstractSocket::setReadBufferSize(tamaño qint64).
Establece el tamaño del búfer de lectura interno de ` QSslSocket` en ` size ` bytes.
[override virtual] bool QSslSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState state = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)
Reimplementa: QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState socketState, QIODeviceBase::OpenMode openMode).
Inicializa ` QSslSocket ` con el descriptor de socket nativo ` socketDescriptor`. Devuelve ` true ` si ` socketDescriptor ` se acepta como un descriptor de socket válido; en caso contrario, devuelve ` false`. El socket se abre en el modo especificado por ` openMode` y pasa al estado de socket especificado por ` state`.
Nota: Noes posible inicializar dos sockets con el mismo descriptor de socket nativo.
Véase también socketDescriptor().
[override virtual] void QSslSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
Reimplementa: QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value).
Establece el ` option ` indicado en el valor descrito por ` value`.
Véase también socketOption().
void QSslSocket::setSslConfiguration(const QSslConfiguration &configuration)
Establece la configuración SSL del socket con el contenido de configuration. Esta función configura el certificado local, los algoritmos de cifrado, la clave privada y los certificados de la CA con los que se almacenan en configuration.
No es posible configurar los campos relacionados con el estado de SSL.
Véase también sslConfiguration(), setLocalCertificate(), setPrivateKey(), QSslConfiguration::setCaCertificates() y QSslConfiguration::setCiphers().
[override virtual protected] qint64 QSslSocket::skipData(qint64 maxSize)
Reimplementa: QAbstractSocket::skipData(qint64 maxSize).
[override virtual] QVariant QSslSocket::socketOption(QAbstractSocket::SocketOption option)
Reimplementa: ` QAbstractSocket::socketOption` (opción `QAbstractSocket::SocketOption`).
Devuelve el valor de la opción option.
Véase también setSocketOption().
QSslConfiguration QSslSocket::sslConfiguration() const
Devuelve el estado de la configuración SSL del socket. La configuración SSL predeterminada de un socket consiste en utilizar los cifrados predeterminados, los certificados CA predeterminados y no utilizar ninguna clave privada ni certificado local.
La configuración SSL también contiene campos que pueden cambiar con el tiempo sin previo aviso.
Véase también setSslConfiguration(), localCertificate(), peerCertificate(), peerCertificateChain(), sessionCipher(), privateKey(), QSslConfiguration::ciphers() y QSslConfiguration::caCertificates().
[signal] void QSslSocket::sslErrors(const QList<QSslError> &errors)
QSslSocket Emite esta señal tras el protocolo de enlace SSL para indicar que se han producido uno o más errores al establecer la identidad del interlocutor. Estos errores suelen indicar que ` QSslSocket ` no puede identificar de forma segura al interlocutor. A menos que se tome alguna medida, la conexión se interrumpirá tras la emisión de esta señal.
Si deseas continuar con la conexión a pesar de los errores que se han producido, debes llamar a ` QSslSocket::ignoreSslErrors()` desde dentro de una ranura conectada a esta señal. Si necesitas acceder a la lista de errores más adelante, puedes llamar a ` sslHandshakeErrors()`.
errors contiene uno o más errores que impiden que ` QSslSocket ` verifique la identidad del par.
Nota: Nose puede utilizar Qt::QueuedConnection al conectarse a esta señal; de lo contrario, llamar a QSslSocket::ignoreSslErrors() no tendrá ningún efecto.
Véase también peerVerifyError().
QList<QSslError> QSslSocket::sslHandshakeErrors() const
Devuelve una lista de los últimos errores SSL que se han producido. Se trata de la misma lista que QSslSocket transmite a través de la señal sslErrors(). Si la conexión se ha cifrado sin errores, esta función devolverá una lista vacía.
Véase también ` connectToHostEncrypted()`.
[static] long QSslSocket::sslLibraryBuildVersionNumber()
Devuelve el número de versión de la biblioteca SSL utilizada en el momento de la compilación. Si no hay compatibilidad con SSL disponible, devolverá -1.
Véase también sslLibraryVersionNumber().
[static] QString QSslSocket::sslLibraryBuildVersionString()
Devuelve la cadena de versión de la biblioteca SSL utilizada en el momento de la compilación. Si no hay compatibilidad con SSL disponible, devolverá un valor vacío.
Véase también sslLibraryVersionString().
[static] long QSslSocket::sslLibraryVersionNumber()
Devuelve el número de versión de la biblioteca SSL que se está utilizando. Ten en cuenta que se trata de la versión de la biblioteca que se utiliza en tiempo de ejecución, no en tiempo de compilación. Si no hay compatibilidad con SSL disponible, devolverá -1.
[static] QString QSslSocket::sslLibraryVersionString()
Devuelve la cadena de versión de la biblioteca SSL que se está utilizando. Ten en cuenta que se trata de la versión de la biblioteca en uso en tiempo de ejecución, no en tiempo de compilación. Si no hay compatibilidad con SSL disponible, se devolverá un valor vacío.
[slot] void QSslSocket::startClientEncryption()
Inicia un protocolo de enlace SSL diferido para una conexión de cliente. Esta función se puede invocar cuando el socket se encuentra en el estado « ConnectedState », pero aún en el estado « UnencryptedMode ». Si aún no está conectado, o si ya está cifrado, esta función no tiene ningún efecto.
Los clientes que implementan la funcionalidad STARTTLS suelen utilizar handshakes SSL diferidos. La mayoría de los demás clientes pueden evitar llamar directamente a esta función utilizando en su lugar connectToHostEncrypted(), que realiza automáticamente el handshake.
Véanse también connectToHostEncrypted() y startServerEncryption().
[slot] void QSslSocket::startServerEncryption()
Inicia un protocolo de enlace SSL diferido para una conexión al servidor. Esta función se puede invocar cuando el socket se encuentra en el estado « ConnectedState », pero aún en el estado « UnencryptedMode ». Si no está conectado o ya está cifrado, la función no tiene ningún efecto.
En el caso de los sockets de servidor, llamar a esta función es la única forma de iniciar el protocolo de enlace SSL. La mayoría de los servidores llamarán a esta función inmediatamente al recibir una conexión, o como resultado de haber recibido un comando específico del protocolo para entrar en modo SSL (por ejemplo, el servidor puede responder a la recepción de la cadena «STARTTLS\r\n » llamando a esta función).
La forma más habitual de implementar un servidor SSL es crear una subclase de ` QTcpServer ` y reimplementar ` QTcpServer::incomingConnection()`. A continuación, el descriptor de socket devuelto se pasa a ` QSslSocket::setSocketDescriptor()`.
Véase también connectToHostEncrypted() y startClientEncryption().
[static, since 6.1] QList<QSsl::SupportedFeature> QSslSocket::supportedFeatures(const QString &backendName = {})
Esta función devuelve las características compatibles con un backend denominado « backendName ». Si se proporciona un objeto « backendName » vacío, se interpreta como una consulta sobre el backend actualmente activo.
Esta función se introdujo en Qt 6.1.
Véase también QSsl::SupportedFeature y activeBackend().
[static, since 6.1] QList<QSsl::SslProtocol> QSslSocket::supportedProtocols(const QString &backendName = {})
Si hay disponible un backend con el nombre « backendName », esta función devuelve la lista de versiones del protocolo TLS compatibles con dicho backend. Si el nombre del backend (« backendName ») está vacío, se interpreta como una consulta sobre el backend actualmente activo. En caso contrario, esta función devuelve una lista vacía.
Esta función se introdujo en Qt 6.1.
Véanse también availableBackends(), activeBackend() y isProtocolSupported().
[static] bool QSslSocket::supportsSsl()
Devuelve ` true ` si esta plataforma es compatible con SSL; en caso contrario, devuelve `false`. Si la plataforma no es compatible con SSL, el socket fallará en la fase de conexión.
[override virtual] bool QSslSocket::waitForBytesWritten(int msecs = 30000)
Reimplementa: QAbstractSocket::waitForBytesWritten(int msecs).
[override virtual] bool QSslSocket::waitForConnected(int msecs = 30000)
Reimplementa: QAbstractSocket::waitForConnected(int msecs).
Espera hasta que el socket se conecte o hasta que transcurran msecs milisegundos, lo que ocurra primero. Si se ha establecido la conexión, esta función devuelve true; en caso contrario, devuelve false.
Véase también QAbstractSocket::waitForConnected().
[override virtual] bool QSslSocket::waitForDisconnected(int msecs = 30000)
Reimplementa: QAbstractSocket::waitForDisconnected(int msecs).
Espera hasta que el socket se haya desconectado o hasta que transcurran msecs milisegundos, lo que ocurra primero. Si la conexión se ha desconectado, esta función devuelve true; en caso contrario, devuelve false.
Véase también QAbstractSocket::waitForDisconnected().
bool QSslSocket::waitForEncrypted(int msecs = 30000)
Espera hasta que el socket haya completado el protocolo de enlace SSL y haya emitido ` encrypted()` o haya transcurrido ` msecs ` milisegundos, lo que ocurra primero. Si se ha emitido ` encrypted()`, esta función devuelve «true»; en caso contrario (por ejemplo, si el socket está desconectado o si falla el protocolo de enlace SSL), devuelve «false».
El siguiente ejemplo espera hasta un segundo a que el socket se cifre:
socket->connectToHostEncrypted("imap", 993);
if (socket->waitForEncrypted(1000))
qDebug("Encrypted!");Si «msecs» es -1, esta función no tendrá límite de tiempo.
Véanse también startClientEncryption(), startServerEncryption(), encrypted() y isEncrypted().
[override virtual] bool QSslSocket::waitForReadyRead(int msecs = 30000)
Reimplementa: QAbstractSocket::waitForReadyRead(int msecs).
[override virtual protected] qint64 QSslSocket::writeData(const char *data, qint64 len)
Reimplementa: QAbstractSocket::writeData(const char *data, qint64 size).
Elementos no miembros relacionados
[since 6.0] enum class AlertLevel
Describe el nivel de un mensaje de alerta
Esta enumeración describe el nivel de un mensaje de alerta que se ha enviado o recibido.
| Constante | Valor | Descripción |
|---|---|---|
QSslSocket::AlertLevel::Warning | 0 | Mensaje de alerta no crítico |
QSslSocket::AlertLevel::Fatal | 1 | Mensaje de alerta grave; el backend subyacente gestionará dicha alerta correctamente y cerrará la conexión. |
QSslSocket::AlertLevel::Unknown | 2 | Una alerta de nivel de gravedad desconocido. |
Esta enumeración se introdujo en Qt 6.0.
[since 6.0] enum class AlertType
Enumera los posibles códigos que puede tener un mensaje de alerta
Consulte la sección 6 del RFC 8446 para conocer los posibles valores y su significado.
| Constante | Valor | Descripción |
|---|---|---|
QSslSocket::AlertType::CloseNotify | 0 | , |
QSslSocket::AlertType::UnexpectedMessage | 10 | |
QSslSocket::AlertType::BadRecordMac | 20 | |
QSslSocket::AlertType::RecordOverflow | 22 | |
QSslSocket::AlertType::DecompressionFailure | 30 | |
QSslSocket::AlertType::HandshakeFailure | 40 | |
QSslSocket::AlertType::NoCertificate | 41 | |
QSslSocket::AlertType::BadCertificate | 42 | |
QSslSocket::AlertType::UnsupportedCertificate | 43 | |
QSslSocket::AlertType::CertificateRevoked | 44 | |
QSslSocket::AlertType::CertificateExpired | 45 | |
QSslSocket::AlertType::CertificateUnknown | 46 | |
QSslSocket::AlertType::IllegalParameter | 47 | |
QSslSocket::AlertType::UnknownCa | 48 | |
QSslSocket::AlertType::AccessDenied | 49 | |
QSslSocket::AlertType::DecodeError | 50 | |
QSslSocket::AlertType::DecryptError | 51 | |
QSslSocket::AlertType::ExportRestriction | 60 | |
QSslSocket::AlertType::ProtocolVersion | 70 | |
QSslSocket::AlertType::InsufficientSecurity | 71 | |
QSslSocket::AlertType::InternalError | 80 | |
QSslSocket::AlertType::InappropriateFallback | 86 | |
QSslSocket::AlertType::UserCancelled | 90 | |
QSslSocket::AlertType::NoRenegotiation | 100 | |
QSslSocket::AlertType::MissingExtension | 109 | |
QSslSocket::AlertType::UnsupportedExtension | 110 | |
QSslSocket::AlertType::CertificateUnobtainable | 111 | |
QSslSocket::AlertType::UnrecognizedName | 112 | |
QSslSocket::AlertType::BadCertificateStatusResponse | 113 | |
QSslSocket::AlertType::BadCertificateHashValue | 114 | |
QSslSocket::AlertType::UnknownPskIdentity | 115 | |
QSslSocket::AlertType::CertificateRequired | 116 | |
QSslSocket::AlertType::NoApplicationProtocol | 120 | |
QSslSocket::AlertType::UnknownAlertMessage | 255 |
Esta enumeración se introdujo en Qt 6.0.
[since 6.1] enum class ImplementedClass
Enumera las clases que implementa un backend de TLS
En QtNetwork, algunas clases tienen una implementación específica del backend y, por lo tanto, pueden dejarse sin implementar. Los elementos de esta enumeración indican qué clases cuentan con una implementación operativa en el backend.
| Constante | Valor | Descripción |
|---|---|---|
QSslSocket::ImplementedClass::Key | 0 | Clase ` QSslKey`. |
QSslSocket::ImplementedClass::Certificate | 1 | Clase QSslCertificate. |
QSslSocket::ImplementedClass::Socket | 2 | Clase « QSslSocket ». |
QSslSocket::ImplementedClass::DiffieHellman | 3 | Clase « QSslDiffieHellmanParameters ». |
QSslSocket::ImplementedClass::EllipticCurve | 4 | Clase « QSslEllipticCurve ». |
QSslSocket::ImplementedClass::Dtls | 5 | Clase « QDtls ». |
QSslSocket::ImplementedClass::DtlsCookie | 6 | Clase ` QDtlsClientVerifier`. |
Esta enumeración se introdujo en Qt 6.1.
[since 6.1] enum class SupportedFeature
Enumera las posibles características que admite un backend TLS
En QtNetwork, las clases relacionadas con TLS tienen una API pública que puede no estar implementada por algunos backends; por ejemplo, nuestro backend SecureTransport no admite ALPN del lado del servidor. Los elementos de la enumeración SupportedFeature indican que una característica concreta está soportada.
| Constante | Valor | Descripción |
|---|---|---|
QSslSocket::SupportedFeature::CertificateVerification | 0 | Indica que el backend implementa ` QSslCertificate::verify()`. |
QSslSocket::SupportedFeature::ClientSideAlpn | 1 | ALPN del lado del cliente (negociación del protocolo de la capa de aplicación). |
QSslSocket::SupportedFeature::ServerSideAlpn | 2 | ALPN del lado del servidor. |
QSslSocket::SupportedFeature::Ocsp | 3 | OCSP stapling (Protocolo de estado de certificados en línea). |
QSslSocket::SupportedFeature::Psk | 4 | Claves precompartidas. |
QSslSocket::SupportedFeature::SessionTicket | 5 | Tickets de sesión. |
QSslSocket::SupportedFeature::Alerts | 6 | Información sobre los mensajes de alerta enviados y recibidos. |
Esta enumeración se introdujo en Qt 6.1.
© 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.