QSslSocket Class

Documentation des fonctions membres

[explicit] QSslSocket::QSslSocket(QObject *parent = nullptr)

Construit un objet QSslSocket. parent est transmis au constructeur de QObject. La suite cipher de la nouvelle socket est définie sur celle renvoyée par la méthode statique defaultCiphers().

[virtual noexcept] QSslSocket::~QSslSocket()

Détruit le site QSslSocket.

[static, since 6.1] QString QSslSocket::activeBackend()

Renvoie le nom du backend utilisé par QSslSocket et les classes apparentées. Si le backend actif n'a pas été défini explicitement, cette fonction renvoie le nom d'un backend par défaut que QSslSocket sélectionne implicitement dans la liste des backends disponibles.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi setActiveBackend() et availableBackends().

[signal] void QSslSocket::alertReceived(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)

QSslSocket émet ce signal si un message d'alerte a été reçu d'un homologue. level indique si l'alerte était fatale ou s'il s'agissait d'un avertissement. type est le code expliquant pourquoi l'alerte a été envoyée. Lorsqu'une description textuelle du message d'alerte est disponible, elle est fournie dans description.

Voir aussi alertSent(), QSsl::AlertLevel, et QSsl::AlertType.

[signal] void QSslSocket::alertSent(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)

QSslSocket émet ce signal si un message d'alerte a été envoyé à un homologue. level indique s'il s'agit d'un avertissement ou d'une erreur fatale. type donne le code du message d'alerte. Lorsqu'une description textuelle du message d'alerte est disponible, elle est fournie dans description.

Voir aussi alertReceived(), QSsl::AlertLevel, et QSsl::AlertType.

[override virtual] bool QSslSocket::atEnd() const

Réimplémente : QIODevice::atEnd() const.

[static, since 6.1] QList<QString> QSslSocket::availableBackends()

Renvoie les noms des backends actuellement disponibles. Ces noms sont en minuscules, par exemple "openssl", "securetransport", "schannel" (similaires aux noms des fonctionnalités déjà existantes pour les backends TLS dans Qt).

Cette fonction a été introduite dans Qt 6.1.

Voir aussi activeBackend().

[override virtual] qint64 QSslSocket::bytesAvailable() const

Réimplémente : QAbstractSocket::bytesAvailable() const.

Renvoie le nombre d'octets décryptés qui sont immédiatement disponibles pour la lecture.

[override virtual] qint64 QSslSocket::bytesToWrite() const

Réimplémente : QAbstractSocket::bytesToWrite() const.

Renvoie le nombre d'octets non chiffrés qui attendent d'être chiffrés et écrits sur le réseau.

[override virtual] bool QSslSocket::canReadLine() const

Réimplémente : QIODevice::canReadLine() const.

Renvoie true si vous pouvez lire une ligne (terminée par un seul caractère ASCII '\n') de caractères déchiffrés ; sinon, false est renvoyé.

[override virtual] void QSslSocket::close()

Réimplémente : QAbstractSocket::close().

[override virtual] void QSslSocket::connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

Réimplémente : 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)

Démarre une connexion cryptée avec le dispositif hostName sur port, en utilisant mode comme OpenMode. Cela équivaut à appeler connectToHost() pour établir la connexion, suivi d'un appel à startClientEncryption(). Le paramètre protocol peut être utilisé pour spécifier le protocole réseau à utiliser (par exemple, IPv4 ou IPv6).

QSslSocket entre d'abord dans l'état HostLookupState. Ensuite, après être entré dans la boucle d'événements ou dans l'une des fonctions waitFor...(), il entre dans l'état ConnectingState, émet connected(), puis initie la poignée de main du client SSL. À chaque changement d'état, QSslSocket émet le signal stateChanged().

Après avoir initié la poignée de main du client SSL, si l'identité de l'homologue ne peut pas être établie, le signal sslErrors() est émis. Si vous souhaitez ignorer les erreurs et continuer à vous connecter, vous devez appeler ignoreSslErrors(), soit à l'intérieur d'une fonction slot connectée au signal sslErrors(), soit avant d'entrer en mode crypté. Si ignoreSslErrors() n'est pas appelé, la connexion est abandonnée, le signal disconnected() est émis et QSslSocket retourne à l'état UnconnectedState.

Si la poignée de main SSL est réussie, QSslSocket émet encrypted().

QSslSocket socket;
connect(&socket, &QSslSocket::encrypted, receiver, &Receiver::socketEncrypted);

socket.connectToHostEncrypted("imap", 993);
socket->write("1 CAPABILITY\r\n");

La valeur par défaut de mode est ReadWrite.

Si vous souhaitez créer un QSslSocket du côté serveur d'une connexion, vous devez plutôt appeler startServerEncryption() après avoir reçu la connexion entrante via QTcpServer.

Voir aussi connectToHost(), startClientEncryption(), waitForConnected() et waitForEncrypted().

void QSslSocket::connectToHostEncrypted(const QString &hostName, quint16 port, const QString &sslPeerName, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

En plus du comportement original de connectToHostEncrypted, cette méthode surchargée permet d'utiliser un nom d'hôte différent (sslPeerName) pour la validation du certificat au lieu de celui utilisé pour la connexion TCP (hostName).

Voir aussi connectToHostEncrypted().

[since 6.0] void QSslSocket::continueInterruptedHandshake()

Si une application souhaite conclure une poignée de main même après avoir reçu le signal handshakeInterruptedOnError(), elle doit appeler cette fonction. Cet appel doit être fait à partir d'une fonction slot attachée au signal. La connexion signal-fente doit être directe.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi handshakeInterruptedOnError() et QSslConfiguration::setHandshakeMustInterruptOnError().

[override virtual] void QSslSocket::disconnectFromHost()

Réimplémente : QAbstractSocket::disconnectFromHost().

[signal] void QSslSocket::encrypted()

Ce signal est émis lorsque QSslSocket entre en mode crypté. Après l'émission de ce signal, QSslSocket::isEncrypted() retournera vrai, et toutes les transmissions ultérieures sur la socket seront cryptées.

Voir aussi QSslSocket::connectToHostEncrypted() et QSslSocket::isEncrypted().

qint64 QSslSocket::encryptedBytesAvailable() const

Renvoie le nombre d'octets cryptés en attente de décryptage. Normalement, cette fonction renvoie 0 car QSslSocket déchiffre les données entrantes dès qu'il le peut.

qint64 QSslSocket::encryptedBytesToWrite() const

Renvoie le nombre d'octets cryptés en attente d'écriture sur le réseau.

[signal] void QSslSocket::encryptedBytesWritten(qint64 written)

Ce signal est émis lorsque QSslSocket écrit ses données cryptées sur le réseau. Le paramètre written contient le nombre d'octets qui ont été écrits avec succès.

Voir aussi QIODevice::bytesWritten().

[signal] void QSslSocket::handshakeInterruptedOnError(const QSslError &error)

QSslSocket émet ce signal si une erreur de vérification de certificat a été trouvée et si le rapport d'erreur précoce a été activé dans QSslConfiguration. Une application est censée inspecter le site error et décider si elle souhaite poursuivre la poignée de main ou l'interrompre et envoyer un message d'alerte à l'homologue. La connexion signal-slot doit être directe.

Voir également continueInterruptedHandshake(), sslErrors() et QSslConfiguration::setHandshakeMustInterruptOnError().

[slot] void QSslSocket::ignoreSslErrors()

Ce slot indique à QSslSocket d'ignorer les erreurs pendant la phase de poignée de main de QSslSocket et de poursuivre la connexion. Si vous souhaitez poursuivre la connexion même si des erreurs surviennent pendant la phase de poignée de main, vous devez appeler ce slot, soit à partir d'un slot connecté à sslErrors(), soit avant la phase de poignée de main. Si vous n'appelez pas ce slot, que ce soit en réponse à des erreurs ou avant la poignée de main, la connexion sera interrompue après l'émission du signal sslErrors().

S'il n'y a pas d'erreurs pendant la phase de poignée de main SSL (c'est-à-dire que l'identité de l'homologue est établie sans problème), QSslSocket n'émettra pas le signal sslErrors(), et il n'est pas nécessaire d'appeler cette fonction.

// 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(); });

Voir aussi sslErrors().

void QSslSocket::ignoreSslErrors(const QList<QSslError> &errors)

Cette méthode indique à QSslSocket d'ignorer uniquement les erreurs indiquées dans errors.

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);

Plusieurs appels à cette fonction remplaceront la liste des erreurs transmises lors des appels précédents. Vous pouvez effacer la liste des erreurs que vous souhaitez ignorer en appelant cette fonction avec une liste vide.

Voir aussi sslErrors() et sslHandshakeErrors().

[static, since 6.1] QList<QSsl::ImplementedClass> QSslSocket::implementedClasses(const QString &backendName = {})

Cette fonction renvoie les classes spécifiques au backend mises en œuvre par le backend nommé backendName. Un backendName vide est compris comme une requête sur le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi QSsl::ImplementedClass, activeBackend(), et isClassImplemented().

[static, since 6.1] bool QSslSocket::isClassImplemented(QSsl::ImplementedClass cl, const QString &backendName = {})

Retourne vrai si une classe cl est implémentée par le backend nommé backendName. Un backendName vide est compris comme une requête sur le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi implementedClasses().

bool QSslSocket::isEncrypted() const

Renvoie true si la socket est cryptée ; sinon, false est renvoyé.

Une socket cryptée crypte toutes les données écrites en appelant write() ou putChar() avant que les données ne soient écrites sur le réseau, et décrypte toutes les données entrantes lorsque les données sont reçues du réseau, avant que vous n'appeliez read(), readLine() ou getChar().

QSslSocket émet encrypted() lorsqu'il passe en mode crypté.

Vous pouvez appeler sessionCipher() pour savoir quel algorithme de chiffrement est utilisé pour chiffrer et déchiffrer vos données.

Voir également mode().

[static, since 6.1] bool QSslSocket::isFeatureSupported(QSsl::SupportedFeature ft, const QString &backendName = {})

Renvoie un résultat positif si la fonctionnalité ft est prise en charge par un backend nommé backendName. Un backendName vide est compris comme une requête sur le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi QSsl::SupportedFeature et supportedFeatures().

[static, since 6.1] bool QSslSocket::isProtocolSupported(QSsl::SslProtocol protocol, const QString &backendName = {})

Retourne vrai si protocol est supporté par un backend nommé backendName. Un backendName vide est compris comme une requête sur le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi supportedProtocols().

QSslCertificate QSslSocket::localCertificate() const

Renvoie le certificat local de la socket certificate, ou un certificat vide si aucun certificat local n'a été attribué.

Voir aussi setLocalCertificate() et privateKey().

QList<QSslCertificate> QSslSocket::localCertificateChain() const

Renvoie la chaîne locale certificate de la socket, ou une liste vide si aucun certificat local n'a été attribué.

Voir aussi setLocalCertificateChain().

QSslSocket::SslMode QSslSocket::mode() const

Renvoie le mode actuel de la socket ; soit UnencryptedMode, où QSslSocket se comporte de manière identique à QTcpSocket, soit SslClientMode ou SslServerMode, où le client est soit en négociation, soit en mode crypté.

Lorsque le mode change, QSslSocket émet modeChanged()

Voir aussi SslMode.

[signal] void QSslSocket::modeChanged(QSslSocket::SslMode mode)

Ce signal est émis lorsque QSslSocket passe de QSslSocket::UnencryptedMode à QSslSocket::SslClientMode ou QSslSocket::SslServerMode. mode est le nouveau mode.

Voir aussi QSslSocket::mode().

[signal] void QSslSocket::newSessionTicketReceived()

Si le protocole TLS 1.3 a été négocié lors d'une poignée de main, QSslSocket émet ce signal après avoir reçu le message NewSessionTicket. La session et l'indice de durée de vie du ticket de session sont mis à jour dans la configuration de la socket. La session peut être utilisée pour la reprise de session (et une poignée de main raccourcie) dans les futures connexions TLS.

Voir aussi QSslSocket::sslConfiguration(), QSslConfiguration::sessionTicket(), et QSslConfiguration::sessionTicketLifeTimeHint().

QList<QOcspResponse> QSslSocket::ocspResponses() const

Cette fonction renvoie les réponses du protocole d'état des certificats en ligne qu'un serveur peut envoyer lors d'une poignée de main TLS utilisant l'agrafage OCSP. La liste est vide si aucune réponse définitive ou aucune réponse n'a été reçue.

Voir aussi QSslConfiguration::setOcspStaplingEnabled().

QSslCertificate QSslSocket::peerCertificate() const

Renvoie le certificat numérique de l'homologue (c'est-à-dire le certificat immédiat de l'hôte auquel vous êtes connecté) ou un certificat nul si l'homologue n'a pas attribué de certificat.

Le certificat de l'homologue est vérifié automatiquement au cours de la phase d'échange, de sorte que cette fonction est normalement utilisée pour récupérer le certificat à des fins d'affichage ou de diagnostic de la connexion. Il contient des informations sur l'homologue, notamment son nom d'hôte, l'émetteur du certificat et la clé publique de l'homologue.

Étant donné que le certificat de l'homologue est défini au cours de la phase d'échange, il n'y a aucun risque à accéder au certificat de l'homologue à partir d'un slot connecté au signal sslErrors() ou au signal encrypted().

Si un certificat nul est renvoyé, cela peut signifier que la poignée de main SSL a échoué, que l'hôte auquel vous êtes connecté n'a pas de certificat ou qu'il n'y a pas de connexion.

Si vous souhaitez vérifier la chaîne complète de certificats de l'homologue, utilisez peerCertificateChain() pour les obtenir tous en même temps.

Voir également peerCertificateChain().

QList<QSslCertificate> QSslSocket::peerCertificateChain() const

Renvoie la chaîne de certificats numériques de l'homologue ou une liste vide de certificats.

Les certificats de l'homologue sont vérifiés automatiquement pendant la phase d'échange. Cette fonction est normalement utilisée pour récupérer des certificats à des fins d'affichage ou pour effectuer des diagnostics de connexion. Les certificats contiennent des informations sur l'homologue et les émetteurs de certificats, notamment le nom de l'hôte, les noms des émetteurs et les clés publiques des émetteurs.

Les certificats de l'homologue sont définis dans QSslSocket pendant la phase d'échange, il est donc prudent d'appeler cette fonction à partir d'un slot connecté au signal sslErrors() ou au signal encrypted().

Si une liste vide est renvoyée, cela peut signifier que l'échange SSL a échoué, que l'hôte auquel vous êtes connecté n'a pas de certificat ou qu'il n'y a pas de connexion.

Si vous souhaitez obtenir uniquement le certificat immédiat de l'homologue, utilisez peerCertificate().

Voir également peerCertificate().

int QSslSocket::peerVerifyDepth() const

Renvoie le nombre maximal de certificats de la chaîne de certificats de l'homologue à vérifier lors de la phase d'échange SSL, ou 0 (par défaut) si aucune profondeur maximale n'a été définie, ce qui indique que l'ensemble de la chaîne de certificats doit être vérifié.

Les certificats sont vérifiés dans l'ordre d'émission, en commençant par le certificat de l'homologue, puis le certificat de son émetteur, et ainsi de suite.

Voir également setPeerVerifyDepth() et peerVerifyMode().

[signal] void QSslSocket::peerVerifyError(const QSslError &error)

QSslSocket peut émettre ce signal plusieurs fois au cours de la poignée de main SSL, avant que le cryptage n'ait été établi, pour indiquer qu'une erreur s'est produite lors de l'établissement de l'identité de l'homologue. Le signal error indique généralement que QSslSocket n'est pas en mesure d'identifier l'homologue de manière sécurisée.

Ce signal vous permet de savoir rapidement si quelque chose ne va pas. En vous connectant à ce signal, vous pouvez choisir manuellement de couper la connexion à partir du slot connecté avant que la poignée de main ne soit terminée. Si aucune action n'est entreprise, QSslSocket émettra QSslSocket::sslErrors().

Voir aussi sslErrors().

QSslSocket::PeerVerifyMode QSslSocket::peerVerifyMode() const

Renvoie le mode de vérification de la socket. Ce mode détermine si QSslSocket doit demander un certificat à l'homologue (c'est-à-dire si le client demande un certificat au serveur ou si le serveur demande un certificat au client) et s'il doit exiger que ce certificat soit valide.

Le mode par défaut est AutoVerifyPeer, qui indique à QSslSocket d'utiliser VerifyPeer pour les clients et QueryPeer pour les serveurs.

Voir aussi setPeerVerifyMode(), peerVerifyDepth() et mode().

QString QSslSocket::peerVerifyName() const

Renvoie le nom d'hôte différent pour la validation du certificat, tel que défini par setPeerVerifyName ou par connectToHostEncrypted.

Voir aussi setPeerVerifyName() et connectToHostEncrypted().

[signal] void QSslSocket::preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator)

QSslSocket émet ce signal lorsqu'il négocie une suite de chiffrement PSK, et une authentification PSK est donc nécessaire.

Lors de l'utilisation de la PSK, le client doit envoyer au serveur une identité valide et une clé prépartagée valide, afin que la poignée de main SSL puisse se poursuivre. Les applications peuvent fournir ces informations dans un slot connecté à ce signal, en remplissant l'objet authenticator en fonction de leurs besoins.

Voir aussi QSslPreSharedKeyAuthenticator.

QSslKey QSslSocket::privateKey() const

Renvoie la clé privée de cette socket.

Voir aussi setPrivateKey() et localCertificate().

QSsl::SslProtocol QSslSocket::protocol() const

Renvoie le protocole SSL de la socket. Par défaut, QSsl::SecureProtocols est utilisé.

Voir aussi setProtocol().

[override virtual protected] qint64 QSslSocket::readData(char *data, qint64 maxlen)

Réimplémente : QAbstractSocket::readData(char *data, qint64 maxSize).

[override virtual] void QSslSocket::resume()

Réimplémente : QAbstractSocket::resume().

Poursuit le transfert de données sur la socket après qu'elle ait été mise en pause. Si "setPauseMode(QAbstractSocket::PauseOnSslErrors) ;" a été appelé sur cette socket et qu'un signal sslErrors() est reçu, il est nécessaire d'appeler cette méthode pour que la socket continue.

Voir aussi QAbstractSocket::pauseMode() et QAbstractSocket::setPauseMode().

QSslCipher QSslSocket::sessionCipher() const

Renvoie le code cryptographique de la socket cipher, ou un code cryptographique nul si la connexion n'est pas cryptée. Le chiffrement de la socket pour la session est défini lors de la phase d'échange de données. Le chiffrement est utilisé pour chiffrer et déchiffrer les données transmises par la socket.

QSslSocket fournit également des fonctions permettant de définir la liste ordonnée de chiffrements à partir de laquelle la phase de poignée de main sélectionnera finalement le chiffrement de la session. Cette liste ordonnée doit être en place avant le début de la phase d'échange.

Voir aussi QSslConfiguration::ciphers(), QSslConfiguration::setCiphers() et QSslConfiguration::supportedCiphers().

QSsl::SslProtocol QSslSocket::sessionProtocol() const

Renvoie le protocole SSL/TLS de la socket ou UnknownProtocol si la connexion n'est pas cryptée. Le protocole de la socket pour la session est défini lors de la phase d'échange.

Voir aussi protocol() et setProtocol().

[static, since 6.1] bool QSslSocket::setActiveBackend(const QString &backendName)

Renvoie un résultat positif si un backend portant le nom backendName a été défini comme backend actif. backendName doit être l'un des noms renvoyés par availableBackends().

Cette fonction a été introduite dans Qt 6.1.

Voir aussi activeBackend() et availableBackends().

void QSslSocket::setLocalCertificate(const QSslCertificate &certificate)

Définit le certificat local de la socket à certificate. Le certificat local est nécessaire si vous devez confirmer votre identité à l'homologue. Il est utilisé avec la clé privée ; si vous définissez le certificat local, vous devez également définir la clé privée.

Le certificat local et la clé privée sont toujours nécessaires pour les sockets du serveur, mais ils sont aussi rarement utilisés par les sockets du client si le serveur exige que le client s'authentifie.

Voir aussi localCertificate() et setPrivateKey().

void QSslSocket::setLocalCertificate(const QString &path, QSsl::EncodingFormat format = QSsl::Pem)

Fixe la valeur locale de la socket certificate à la première trouvée dans le fichier path, qui est analysé en fonction de la valeur spécifiée format.

void QSslSocket::setLocalCertificateChain(const QList<QSslCertificate> &localChain)

Définit la chaîne de certificats à présenter à l'homologue au cours de la poignée de main SSL comme étant localChain.

Voir également localCertificateChain() et QSslConfiguration::setLocalCertificateChain().

void QSslSocket::setPeerVerifyDepth(int depth)

Définit le nombre maximum de certificats de la chaîne de certificats de l'homologue à vérifier pendant la phase de poignée de main SSL, à depth. La définition d'une profondeur de 0 signifie qu'aucune profondeur maximale n'est définie, ce qui indique que toute la chaîne de certificats doit être vérifiée.

Les certificats sont vérifiés dans l'ordre d'émission, en commençant par le certificat de l'homologue, puis le certificat de son émetteur, et ainsi de suite.

Voir également peerVerifyDepth() et setPeerVerifyMode().

void QSslSocket::setPeerVerifyMode(QSslSocket::PeerVerifyMode mode)

Définit le mode de vérification de la socket à mode. Ce mode détermine si QSslSocket doit demander un certificat à l'homologue (c'est-à-dire si le client demande un certificat au serveur ou si le serveur demande un certificat au client) et s'il doit exiger que ce certificat soit valide.

Le mode par défaut est AutoVerifyPeer, ce qui indique à QSslSocket d'utiliser VerifyPeer pour les clients et QueryPeer pour les serveurs.

La définition de ce mode après le début du chiffrement n'a aucun effet sur la connexion en cours.

Voir également peerVerifyMode(), setPeerVerifyDepth() et mode().

void QSslSocket::setPeerVerifyName(const QString &hostName)

Définit un nom d'hôte différent, donné par hostName, pour la validation du certificat au lieu de celui utilisé pour la connexion TCP.

Voir aussi peerVerifyName() et connectToHostEncrypted().

void QSslSocket::setPrivateKey(const QSslKey &key)

Définit la clé privée de la socket key à key. La clé privée et le certificat local certificate sont utilisés par les clients et les serveurs qui doivent prouver leur identité à leurs homologues SSL.

La clé et le certificat local sont nécessaires si vous créez une socket de serveur SSL. Si vous créez une socket client SSL, la clé et le certificat local sont nécessaires si votre client doit s'identifier auprès d'un serveur SSL.

Voir aussi privateKey() et setLocalCertificate().

void QSslSocket::setPrivateKey(const QString &fileName, QSsl::KeyAlgorithm algorithm = QSsl::Rsa, QSsl::EncodingFormat format = QSsl::Pem, const QByteArray &passPhrase = QByteArray())

Lit la chaîne contenue dans le fichier fileName et la décode en utilisant une clé spécifiée algorithm et un encodage format pour construire une clé SSL key. Si la clé encodée est cryptée, passPhrase est utilisé pour la décrypter.

La clé privée de la socket est définie sur la clé construite. La clé privée et le certificat local certificate sont utilisés par les clients et les serveurs qui doivent prouver leur identité à leurs homologues SSL.

La clé et le certificat local sont nécessaires si vous créez une socket serveur SSL. Si vous créez une socket client SSL, la clé et le certificat local sont nécessaires si votre client doit s'identifier auprès d'un serveur SSL.

Voir aussi privateKey() et setLocalCertificate().

void QSslSocket::setProtocol(QSsl::SslProtocol protocol)

Définit le protocole SSL de la socket à protocol. Cela affectera la prochaine poignée de main initiée ; appeler cette fonction sur une socket déjà cryptée n'affectera pas le protocole de la socket.

Voir aussi protocol().

[override virtual] void QSslSocket::setReadBufferSize(qint64 size)

Réimplémente : QAbstractSocket::setReadBufferSize(qint64 size).

Fixe la taille du tampon de lecture interne de QSslSocket à size bytes.

[override virtual] bool QSslSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState state = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)

Réimplémente : QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState socketState, QIODeviceBase::OpenMode openMode).

Initialise QSslSocket avec le descripteur de socket natif socketDescriptor. Renvoie true si socketDescriptor est accepté comme descripteur de socket valide ; sinon, renvoie false. La socket est ouverte dans le mode spécifié par openMode, et entre dans l'état de la socket spécifié par state.

Voir aussi socketDescriptor().

[override virtual] void QSslSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)

Réimplémente : QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value).

Définit la valeur donnée par option à la valeur décrite par value.

Voir aussi socketOption().

void QSslSocket::setSslConfiguration(const QSslConfiguration &configuration)

Définit la configuration SSL de la socket comme étant le contenu de configuration. Cette fonction définit le certificat local, les algorithmes de chiffrement, la clé privée et les certificats de l'autorité de certification comme étant ceux stockés dans configuration.

Il n'est pas possible de définir les champs liés à l'état SSL.

Voir aussi sslConfiguration(), setLocalCertificate(), setPrivateKey(), QSslConfiguration::setCaCertificates() et QSslConfiguration::setCiphers().

[override virtual protected] qint64 QSslSocket::skipData(qint64 maxSize)

Réimplémente : QAbstractSocket::skipData(qint64 maxSize).

[override virtual] QVariant QSslSocket::socketOption(QAbstractSocket::SocketOption option)

Réimplémente : QAbstractSocket::socketOption(QAbstractSocket::SocketOption option).

Renvoie la valeur de l'option option.

Voir aussi setSocketOption().

QSslConfiguration QSslSocket::sslConfiguration() const

Renvoie l'état de la configuration SSL de la socket. La configuration SSL par défaut d'une socket consiste à utiliser les algorithmes de chiffrement par défaut, les certificats d'autorité de certification par défaut, aucune clé privée locale ni aucun certificat.

La configuration SSL contient également des champs qui peuvent changer avec le temps sans préavis.

Voir aussi setSslConfiguration(), localCertificate(), peerCertificate(), peerCertificateChain(), sessionCipher(), privateKey(), QSslConfiguration::ciphers() et QSslConfiguration::caCertificates().

[signal] void QSslSocket::sslErrors(const QList<QSslError> &errors)

QSslSocket émet ce signal après la poignée de main SSL pour indiquer qu'une ou plusieurs erreurs se sont produites lors de l'établissement de l'identité de l'homologue. Ces erreurs indiquent généralement que QSslSocket n'est pas en mesure d'identifier l'homologue de manière sécurisée. Si aucune mesure n'est prise, la connexion sera interrompue après l'émission de ce signal.

Si vous voulez continuer à vous connecter malgré les erreurs qui se sont produites, vous devez appeler QSslSocket::ignoreSslErrors() à partir d'un slot connecté à ce signal. Si vous devez accéder à la liste des erreurs ultérieurement, vous pouvez appeler sslHandshakeErrors().

errors contient une ou plusieurs erreurs qui empêchent QSslSocket de vérifier l'identité de l'homologue.

Voir également peerVerifyError().

QList<QSslError> QSslSocket::sslHandshakeErrors() const

Renvoie une liste des dernières erreurs SSL qui se sont produites. Il s'agit de la même liste que celle transmise par QSslSocket via le signal sslErrors(). Si la connexion a été chiffrée sans erreur, cette fonction renvoie une liste vide.

Voir aussi connectToHostEncrypted().

[static] long QSslSocket::sslLibraryBuildVersionNumber()

Renvoie le numéro de version de la bibliothèque SSL utilisée au moment de la compilation. Si aucun support SSL n'est disponible, cela renvoie -1.

Voir aussi sslLibraryVersionNumber().

[static] QString QSslSocket::sslLibraryBuildVersionString()

Renvoie la chaîne de version de la bibliothèque SSL utilisée au moment de la compilation. Si aucun support SSL n'est disponible, la valeur renvoyée sera vide.

Voir aussi sslLibraryVersionString().

[static] long QSslSocket::sslLibraryVersionNumber()

Renvoie le numéro de version de la bibliothèque SSL utilisée. Notez qu'il s'agit de la version de la bibliothèque utilisée au moment de l'exécution et non au moment de la compilation. Si aucun support SSL n'est disponible, la valeur retournée est -1.

[static] QString QSslSocket::sslLibraryVersionString()

Renvoie la chaîne de version de la bibliothèque SSL utilisée. Notez qu'il s'agit de la version de la bibliothèque utilisée au moment de l'exécution et non au moment de la compilation. Si aucun support SSL n'est disponible, la valeur renvoyée sera vide.

[slot] void QSslSocket::startClientEncryption()

Démarre un handshake SSL retardé pour une connexion client. Cette fonction peut être appelée lorsque la socket est dans ConnectedState mais toujours dans UnencryptedMode. Si elle n'est pas encore connectée, ou si elle est déjà cryptée, cette fonction n'a aucun effet.

Les clients qui implémentent la fonctionnalité STARTTLS utilisent souvent des handshakes SSL retardés. La plupart des autres clients peuvent éviter d'appeler directement cette fonction en utilisant plutôt connectToHostEncrypted(), qui effectue automatiquement la poignée de main.

Voir aussi connectToHostEncrypted() et startServerEncryption().

[slot] void QSslSocket::startServerEncryption()

Démarre un handshake SSL retardé pour une connexion au serveur. Cette fonction peut être appelée lorsque la socket est dans ConnectedState mais toujours dans UnencryptedMode. Si elle n'est pas connectée ou si elle est déjà cryptée, la fonction n'a aucun effet.

Pour les sockets de serveur, l'appel de cette fonction est le seul moyen d'initier la poignée de main SSL. La plupart des serveurs appellent cette fonction immédiatement après avoir reçu une connexion, ou après avoir reçu une commande spécifique au protocole pour passer en mode SSL (par exemple, le serveur peut répondre à la réception de la chaîne "STARTTLS\r\n " en appelant cette fonction).

La manière la plus courante d'implémenter un serveur SSL est de créer une sous-classe de QTcpServer et de réimplémenter QTcpServer::incomingConnection(). Le descripteur de socket renvoyé est alors transmis à QSslSocket::setSocketDescriptor().

Voir aussi connectToHostEncrypted() et startClientEncryption().

[static, since 6.1] QList<QSsl::SupportedFeature> QSslSocket::supportedFeatures(const QString &backendName = {})

Cette fonction renvoie les fonctionnalités prises en charge par un backend nommé backendName. Un backendName vide est compris comme une requête sur le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi QSsl::SupportedFeature et activeBackend().

[static, since 6.1] QList<QSsl::SslProtocol> QSslSocket::supportedProtocols(const QString &backendName = {})

Si un backend portant le nom backendName est disponible, cette fonction renvoie la liste des versions du protocole TLS prises en charge par ce backend. Si backendName est vide, il s'agit d'une interrogation sur le backend actuellement actif. Sinon, cette fonction renvoie une liste vide.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi availableBackends(), activeBackend(), et isProtocolSupported().

[static] bool QSslSocket::supportsSsl()

Renvoie true si cette plate-forme prend en charge SSL ; sinon, renvoie false. Si la plateforme ne supporte pas SSL, la socket échouera dans la phase de connexion.

[override virtual] bool QSslSocket::waitForBytesWritten(int msecs = 30000)

Réimplémente : QAbstractSocket::waitForBytesWritten(int msecs).

[override virtual] bool QSslSocket::waitForConnected(int msecs = 30000)

Réimplémente : QAbstractSocket::waitForConnected(int msecs).

Attend que la socket soit connectée, ou msecs millisecondes, selon ce qui se produit en premier. Si la connexion a été établie, cette fonction renvoie true; sinon, elle renvoie false.

Voir aussi QAbstractSocket::waitForConnected().

[override virtual] bool QSslSocket::waitForDisconnected(int msecs = 30000)

Réimplémente : QAbstractSocket::waitForDisconnected(int msecs).

Attend la déconnexion de la socket ou msecs millisecondes, selon ce qui se produit en premier. Si la connexion a été déconnectée, cette fonction renvoie true; sinon, elle renvoie false.

Voir également QAbstractSocket::waitForDisconnected().

bool QSslSocket::waitForEncrypted(int msecs = 30000)

Attend que la socket ait terminé la poignée de main SSL et ait émis encrypted(), ou msecs millisecondes, selon ce qui se produit en premier. Si encrypted() a été émis, cette fonction renvoie true ; sinon (par exemple, la socket est déconnectée, ou la poignée de main SSL échoue), false est renvoyé.

L'exemple suivant attend jusqu'à une seconde que la socket soit cryptée :

socket->connectToHostEncrypted("imap", 993) ;if (socket->waitForEncrypted(1000))    qDebug("Encrypted!");

Si msecs est égal à -1, cette fonction n'est pas interrompue.

Voir aussi startClientEncryption(), startServerEncryption(), encrypted() et isEncrypted().

[override virtual] bool QSslSocket::waitForReadyRead(int msecs = 30000)

Réimplémente : QAbstractSocket::waitForReadyRead(int msecs).

[override virtual protected] qint64 QSslSocket::writeData(const char *data, qint64 len)

Réimplémente : QAbstractSocket::writeData(const char *data, qint64 size).