QSslSocket Class

Documentation des fonctions membres

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

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

[virtual noexcept] QSslSocket::~QSslSocket()

Supprime l'QSslSocket.

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

Renvoie le nom du backend utilisé par ` QSslSocket ` et les classes associé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 parmi la liste des backends disponibles.

Cette fonction a été introduite dans Qt 6.1.

Voir également 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 pair. ` 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 également 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 pair. Le paramètre « level » indique s'il s'agissait d'un avertissement ou d'une erreur fatale. Le paramètre « type » fournit le code du message d'alerte. Lorsqu'une description textuelle du message d'alerte est disponible, elle est fournie dans le paramètre « description ».

Voir également 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 » (à l'instar des noms de fonctionnalités déjà existants pour les backends TLS dans Qt).

Cette fonction a été introduite dans Qt 6.1.

Voir également activeBackend().

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

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

Renvoie le nombre d’octets déchiffrés 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 en attente 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 « while » (terminée par un seul caractère ASCII «\n ») de caractères déchiffrés ; sinon, renvoie `false`.

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

Lance une connexion chiffrée vers le périphérique hostName sur port, en utilisant mode comme OpenMode. Cela équivaut à appeler connectToHost() pour établir la connexion, puis à appeler startClientEncryption(). Le paramètre protocol permet de spécifier le protocole réseau à utiliser (par exemple, IPv4 ou IPv6).

QSslSocket passe d’abord à l’état HostLookupState. Ensuite, après être entré soit dans la boucle d’événements, soit dans l’une des fonctions waitFor...(), il passe à l’état ConnectingState, émet connected(), puis lance la négociation client SSL. À chaque changement d’état, QSslSocket émet le signal stateChanged().

Une fois la négociation client SSL lancée, si l’identité du pair ne peut être établie, le signal sslErrors() est émis. Si vous souhaitez ignorer les erreurs et poursuivre la connexion, vous devez appeler ` ignoreSslErrors()`, soit depuis une fonction de slot connectée au signal ` sslErrors()`, soit avant de passer en mode chiffré. Si ` ignoreSslErrors()` n’est pas appelé, la connexion est interrompue, le signal ` disconnected()` est émis et ` QSslSocket ` revient à l’état `UnconnectedState`.

Si la négociation SSL aboutit, ` QSslSocket ` émet le signal ` 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 » côté serveur d’une connexion, vous devez plutôt appeler la fonction ` startServerEncryption()` dès la réception de la connexion entrante via ` QTcpServer`.

Voir également 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 d'origine de la méthode `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 également connectToHostEncrypted().

[since 6.0] void QSslSocket::continueInterruptedHandshake()

Si une application souhaite mener à bien une négociation de connexion même après avoir reçu le sign handshakeInterruptedOnError(), elle doit appeler cette fonction. Cet appel doit être effectué depuis une fonction de slot associée au signal. La connexion signal-slot doit être directe.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` handshakeInterruptedOnError()` et ` QSslConfiguration::setHandshakeMustInterruptOnError()`.

[override virtual] void QSslSocket::disconnectFromHost()

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

[signal] void QSslSocket::encrypted()

Ce signal est émis lorsque QSslSocket passe en mode crypté. Une fois ce signal émis, la fonction QSslSocket::isEncrypted() renverra la valeur « true », et toutes les transmissions ultérieures sur le socket seront cryptées.

Voir également QSslSocket::connectToHostEncrypted() et QSslSocket::isEncrypted().

qint64 QSslSocket::encryptedBytesAvailable() const

Renvoie le nombre d'octets chiffrés en attente de déchiffrement. En règle générale, cette fonction renvoie 0, car QSslSocket déchiffre les données qu'il reçoit dès que possible.

qint64 QSslSocket::encryptedBytesToWrite() const

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

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

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

Voir également QIODevice::bytesWritten().

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

QSslSocket émet ce signal si une erreur de vérification de certificat a été détectée et si la notification précoce des erreurs a été activée dans QSslConfiguration. Une application doit analyser l’ error et décider si elle souhaite poursuivre la négociation de connexion ou l’interrompre et envoyer un message d’alerte au pair. 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 survenant pendant la phase d'établissement de la connexion de QSslSocket et de poursuivre la connexion. Si vous souhaitez poursuivre la connexion même en cas d'erreurs pendant la phase d'établissement, vous devez appeler ce slot, soit depuis un slot lié à sslErrors(), soit avant la phase d'établissement. Si vous n’appelez pas ce slot, que ce soit en réponse à des erreurs ou avant l’établissement de la connexion, la connexion sera interrompue après l’émission du signal ` sslErrors()`.

S’il n’y a pas d’erreurs pendant la phase d’établissement de la connexion SSL (c’est-à-dire que l’identité du pair 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 également sslErrors().

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

Cette méthode indique à QSslSocket de ne prendre en compte que les erreurs répertoriées à l'adresse 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);

Les appels multiples à 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 également sslErrors() et sslHandshakeErrors().

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

Cette fonction renvoie les classes spécifiques au backend implémentées par le backend nommé « backendName ». Un argument « backendName » vide est interprété comme une requête concernant le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir également QSsl::ImplementedClass, activeBackend() et isClassImplemented().

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

Renvoie « true » si une classe cl est implémentée par le backend nommé backendName. Un backendName vide est interprété comme une requête concernant le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir également implementedClasses().

bool QSslSocket::isEncrypted() const

Renvoie ` true ` si le socket est chiffré ; sinon, renvoie `false`.

Un socket chiffré chiffre toutes les données écrites à l’aide des fonctions ` write()` ou ` putChar()` avant que celles-ci ne soient transmises sur le réseau, et déchiffre toutes les données entrantes au fur et à mesure de leur réception depuis le réseau, avant que vous n’appeliez les fonctions ` read()`, ` readLine()` ou ` getChar()`.

QSslSocket émet encrypted() lorsqu’il passe en mode chiffré.

Vous pouvez appeler sessionCipher() pour déterminer 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 « true » si une fonctionnalité ft est prise en charge par un backend nommé backendName. Un backendName vide est interprété comme une requête concernant le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir également QSsl::SupportedFeature et supportedFeatures().

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

Renvoie « true » si la méthode « protocol » est prise en charge par un backend nommé « backendName ». Une chaîne vide (« backendName ») est interprétée comme une requête concernant le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir également 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 également setLocalCertificate() et privateKey().

QList<QSslCertificate> QSslSocket::localCertificateChain() const

Renvoie la chaîne d'certificate s locaux du 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 la même manière que « QTcpSocket », soit l’un des modes suivants : « SslClientMode » ou « SslServerMode », où le client est soit en phase de négociation, soit en mode chiffré.

Lorsque le mode change, QSslSocket émet modeChanged()

Voir également SslMode.

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

Ce signal est émis lorsque la valeur de « QSslSocket » passe de « QSslSocket::UnencryptedMode » à « QSslSocket::SslClientMode » ou « QSslSocket::SslServerMode ». « mode » correspond au nouveau mode.

Voir également QSslSocket::mode().

[signal] void QSslSocket::newSessionTicketReceived()

Si le protocole TLS 1.3 a été négocié lors d’une poignée de main, la fonction ` QSslSocket ` émet ce signal après avoir reçu le message `NewSessionTicket`. La durée de vie de la session et celle du ticket de session sont mises à 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) lors de futures connexions TLS.

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

QList<QOcspResponse> QSslSocket::ocspResponses() const

Cette fonction renvoie les réponses du protocole OCSP (Online Certificate Status Protocol) qu'un serveur peut envoyer au cours d'une négociation TLS utilisant l'OCSP stapling. La liste est vide si aucune réponse définitive ou aucune réponse n'a été reçue.

Voir également ` QSslConfiguration::setOcspStaplingEnabled()`.

QSslCertificate QSslSocket::peerCertificate() const

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

Le certificat du pair est vérifié automatiquement pendant la phase d'établissement de la connexion ; cette fonction est donc généralement utilisée pour récupérer le certificat à des fins d'affichage ou de diagnostic de la connexion. Il contient des informations sur le pair, notamment son nom d'hôte, l'émetteur du certificat et la clé publique du pair.

Le certificat du pair étant défini pendant la phase d'établissement de la connexion, il est possible d'y accéder en toute sécurité à partir d'un slot connecté au signal ` sslErrors()` ou au signal ` encrypted()`.

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

Si vous souhaitez vérifier la chaîne complète de certificats du pair, utilisez la fonction peerCertificateChain() pour les récupérer tous en une seule fois.

Voir également peerCertificateChain().

QList<QSslCertificate> QSslSocket::peerCertificateChain() const

Renvoie la chaîne de certificats numériques du pair, ou une liste vide de certificats.

Les certificats des pairs sont vérifiés automatiquement pendant la phase d'établissement de la connexion. Cette fonction est généralement 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 le pair et les émetteurs de certificats, notamment le nom d'hôte, les noms des émetteurs et leurs clés publiques.

Les certificats du pair sont définis dans ` QSslSocket ` pendant la phase d'établissement de la connexion ; il est donc sans risque 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 la négociation SSL a échoué, que l’hôte auquel vous êtes connecté ne dispose pas de certificat, ou qu’il n’y a pas de connexion.

Si vous souhaitez obtenir uniquement le certificat immédiat du pair, utilisez ` peerCertificate()`.

Voir également peerCertificate().

int QSslSocket::peerVerifyDepth() const

Renvoie le nombre maximal de certificats de la chaîne de certificats du pair à vérifier pendant la phase de négociation SSL, ou 0 (valeur par défaut) si aucune profondeur maximale n’a été définie, ce qui indique que la chaîne de certificats doit être vérifiée dans son intégralité.

Les certificats sont vérifiés dans l'ordre d'émission, en commençant par le certificat du pair lui-même, puis celui 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 reprises au cours de la négociation SSL, avant que le chiffrement ne soit établi, pour signaler qu’une erreur s’est produite lors de la vérification de l’identité du pair. Le signal « error » indique généralement que QSslSocket n’est pas en mesure d’identifier le pair de manière sécurisée.

Ce signal vous alerte rapidement en cas de problème. En vous connectant à ce signal, vous pouvez choisir manuellement de rompre la connexion depuis l’intérieur du slot connecté avant la fin de la négociation. Si aucune action n’est entreprise, ` QSslSocket ` émettra alors ` QSslSocket::sslErrors()`.

Voir également sslErrors().

QSslSocket::PeerVerifyMode QSslSocket::peerVerifyMode() const

Renvoie le mode de vérification du socket. Ce mode détermine si QSslSocket doit demander un certificat au pair (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.

Voir également setPeerVerifyMode(), peerVerifyDepth() et mode().

QString QSslSocket::peerVerifyName() const

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

Voir également setPeerVerifyName() et connectToHostEncrypted().

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

QSslSocket émet ce signal lorsqu'il négocie un ensemble de chiffrement PSK ; une authentification PSK est alors requise.

Lorsqu’il utilise la PSK, le client doit envoyer au serveur une identité valide et une clé pré-partagée valide pour que la négociation SSL puisse se poursuivre. Les applications peuvent fournir ces informations dans un slot connecté à ce signal, en remplissant l’objet ` authenticator ` transmis en fonction de leurs besoins.

Voir également QSslPreSharedKeyAuthenticator.

QSslKey QSslSocket::privateKey() const

Renvoie la clé privée de ce socket.

Voir également setPrivateKey() et localCertificate().

QSsl::SslProtocol QSslSocket::protocol() const

Renvoie le protocole SSL de la socket. Par défaut, c'est le protocole « QSsl::SecureProtocols » qui est utilisé.

Voir aussi setProtocol().

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

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

[override virtual] void QSslSocket::resume()

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

Reprend le transfert de données sur le socket après une pause. Si la méthode « setPauseMode(QAbstractSocket::PauseOnSslErrors); » a été appelée sur ce socket et qu'un signal « sslErrors() » est reçu, il est nécessaire d'appeler cette méthode pour que le socket reprenne son fonctionnement.

Voir également QAbstractSocket::pauseMode() et QAbstractSocket::setPauseMode().

QSslCipher QSslSocket::sessionCipher() const

Renvoie l'cipher cryptographique de la socket, ou un chiffrement nul si la connexion n'est pas chiffrée. Le chiffrement de la socket pour la session est défini pendant la phase d'établissement de la connexion. Ce chiffrement est utilisé pour chiffrer et déchiffrer les données transmises via la socket.

QSslSocket Fournit également des fonctions permettant de définir la liste ordonnée des algorithmes de chiffrement parmi lesquels la phase d’établissement de la connexion sélectionnera finalement l’algorithme de chiffrement de la session. Cette liste ordonnée doit être en place avant le début de la phase d’établissement de la connexion.

Voir également QSslConfiguration::ciphers(), QSslConfiguration::setCiphers() et QSslConfiguration::supportedCiphers().

QSsl::SslProtocol QSslSocket::sessionProtocol() const

Renvoie le protocole SSL/TLS du socket ou « UnknownProtocol » si la connexion n'est pas chiffrée. Le protocole du socket pour la session est défini pendant la phase d'établissement de la connexion.

Voir également protocol() et setProtocol().

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

Renvoie « true » si un backend nommé « backendName » a été défini comme backend actif. « backendName » doit figurer parmi les noms renvoyés par la fonction availableBackends().

Cette fonction a été introduite dans Qt 6.1.

Voir également ` activeBackend()` et ` availableBackends()`.

void QSslSocket::setLocalCertificate(const QSslCertificate &certificate)

Définit le certificat local du socket sur certificate. Le certificat local est nécessaire si vous devez confirmer votre identité auprès du pair. Il est utilisé conjointement 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 serveur, mais sont également rarement utilisés par les sockets client si le serveur exige que le client s'authentifie.

Voir également localCertificate() et setPrivateKey().

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

Définit l'certificate locale du socket sur la première trouvée dans le fichier path, qui est analysée conformément à la spécification format.

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

Définit la chaîne de certificats à présenter au pair lors de la négociation SSL sur localChain.

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

void QSslSocket::setPeerVerifyDepth(int depth)

Définit le nombre maximal de certificats de la chaîne de certificats du pair à vérifier pendant la phase de négociation SSL, à depth. Une valeur de 0 signifie qu'aucune profondeur maximale n'est définie, ce qui indique que la chaîne de certificats doit être vérifiée dans son intégralité.

Les certificats sont vérifiés dans l'ordre d'émission, en commençant par le certificat du pair lui-même, puis celui 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 du socket sur « mode ». Ce mode détermine si QSslSocket doit demander un certificat au pair (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 configuration 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, fourni par hostName, pour la validation du certificat, à la place de celui utilisé pour la connexion TCP.

Voir également peerVerifyName() et connectToHostEncrypted().

void QSslSocket::setPrivateKey(const QSslKey &key)

Définit l'key privée du socket sur key. La clé privée et l'certificate locale sont utilisées par les clients et les serveurs qui doivent prouver leur identité à leurs pairs SSL.

La clé et le certificat local sont tous deux obligatoires si vous créez un socket serveur SSL. Si vous créez un socket client SSL, la clé et le certificat local sont obligatoires si votre client doit s’identifier auprès d’un serveur SSL.

Voir également 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 à l'aide d'un algorithm et d'un encoding format spécifiés afin de construire une SSL key. Si la clé encodée est chiffrée, passPhrase est utilisé pour la déchiffrer.

La clé privée du socket est définie sur la clé ainsi créée. La clé privée et l'certificate t local sont utilisés par les clients et les serveurs qui doivent prouver leur identité à leurs pairs SSL.

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

Voir également ` privateKey()` et ` setLocalCertificate()`.

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

Définit le protocole SSL du socket sur protocol. Cela affectera la prochaine négociation de connexion ; l'appel de cette fonction sur un socket déjà chiffré n'aura aucune incidence sur le protocole du socket.

Voir également protocol().

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

Réimplémente : QAbstractSocket::setReadBufferSize(taille en qint64).

Définit la taille du tampon de lecture interne de ` QSslSocket` à size octets.

[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 passe à l’état de socket spécifié par ` state`.

Voir également socketDescriptor().

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

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

Définit l'option « option » donnée sur la valeur décrite par value.

Voir aussi socketOption().

void QSslSocket::setSslConfiguration(const QSslConfiguration &configuration)

Définit la configuration SSL du socket en utilisant le contenu du fichier configuration. Cette fonction définit le certificat local, les algorithmes de chiffrement, la clé privée et les certificats d'autorité de certification (CA) en utilisant ceux stockés dans le fichier configuration.

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

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

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

Réimplémentation de : QAbstractSocket::skipData(qint64 maxSize).

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

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

Renvoie la valeur de l'option option.

Voir aussi setSocketOption().

QSslConfiguration QSslSocket::sslConfiguration() const

Renvoie l'état de la configuration SSL du socket. Par défaut, la configuration SSL d'un socket consiste à utiliser les algorithmes de chiffrement par défaut, les certificats d'autorité de certification (CA) par défaut, sans clé privée ni certificat local.

La configuration SSL contient également des champs susceptibles d’évoluer au fil du temps sans préavis.

Voir également 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 négociation SSL pour indiquer qu’une ou plusieurs erreurs se sont produites lors de la vérification de l’identité du pair. Ces erreurs indiquent généralement que ` QSslSocket ` est incapable d’identifier le pair de manière sécurisée. À moins qu’une action ne soit entreprise, la connexion sera interrompue après l’émission de ce signal.

Si vous souhaitez poursuivre la connexion malgré les erreurs survenues, vous devez appeler la fonction ` QSslSocket::ignoreSslErrors()` depuis un slot connecté à ce signal. Si vous avez besoin d’accéder à la liste des erreurs ultérieurement, vous pouvez appeler la fonction ` sslHandshakeErrors()`.

errors contient une ou plusieurs erreurs qui empêchent ` QSslSocket ` de vérifier l’identité du pair.

Voir également peerVerifyError().

QList<QSslError> QSslSocket::sslHandshakeErrors() const

Renvoie une liste des dernières erreurs SSL survenues. 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 également ` connectToHostEncrypted()`.

[static] long QSslSocket::sslLibraryBuildVersionNumber()

Renvoie le numéro de version de la bibliothèque SSL utilisée au moment de la compilation. Si la prise en charge SSL n'est pas disponible, cette fonction renvoie -1.

Voir également sslLibraryVersionNumber().

[static] QString QSslSocket::sslLibraryBuildVersionString()

Renvoie la chaîne de version de la bibliothèque SSL utilisée au moment de la compilation. Si la prise en charge SSL n'est pas disponible, cette fonction renvoie une valeur vide.

Voir également 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 la prise en charge SSL n'est pas disponible, cette fonction renvoie -1.

[static] QString QSslSocket::sslLibraryVersionString()

Renvoie la chaîne de caractères correspondant à la 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 la prise en charge SSL n'est pas disponible, cette fonction renverra une valeur vide.

[slot] void QSslSocket::startClientEncryption()

Lance une négociation SSL différée pour une connexion client. Cette fonction peut être appelée lorsque le socket se trouve dans l'état « ConnectedState » mais est encore en phase d'« UnencryptedMode ». S'il n'est pas encore connecté, ou s'il est déjà chiffré, cette fonction n'a aucun effet.

Les clients qui implémentent la fonctionnalité STARTTLS ont souvent recours aux poignées de main SSL différées. 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 également connectToHostEncrypted() et startServerEncryption().

[slot] void QSslSocket::startServerEncryption()

Lance une négociation SSL différée pour une connexion au serveur. Cette fonction peut être appelée lorsque le socket est en mode « ConnectedState » mais toujours en état « UnencryptedMode ». S'il n'est pas connecté ou s'il est déjà chiffré, la fonction n'a aucun effet.

Pour les sockets serveur, l'appel de cette fonction est le seul moyen de lancer la négociation SSL. La plupart des serveurs appellent cette fonction dès qu’ils reçoivent une connexion, ou après avoir reçu une commande spécifique au protocole leur demandant de 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 méthode la plus courante pour implémenter un serveur SSL consiste à créer une sous-classe de ` QTcpServer ` et à réimplémenter la fonction ` QTcpServer::incomingConnection()`. Le descripteur de socket renvoyé est ensuite transmis à la fonction ` QSslSocket::setSocketDescriptor()`.

Voir également 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 argument « backendName » vide est interprété comme une requête concernant le backend actuellement actif.

Cette fonction a été introduite dans Qt 6.1.

Voir également QSsl::SupportedFeature et activeBackend().

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

Si un backend nommé « backendName » est disponible, cette fonction renvoie la liste des versions du protocole TLS prises en charge par ce backend. Un backendName vide est interprété comme une requête concernant le backend actuellement actif. Dans le cas contraire, cette fonction renvoie une liste vide.

Cette fonction a été introduite dans Qt 6.1.

Voir également availableBackends(), activeBackend() et isProtocolSupported().

[static] bool QSslSocket::supportsSsl()

Renvoie ` true ` si cette plateforme prend en charge le protocole SSL ; sinon, renvoie `false`. Si la plateforme ne prend pas en charge le protocole SSL, la connexion via le socket échouera lors de la phase de connexion.

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

Réimplémentation de : QAbstractSocket::waitForBytesWritten(int msecs).

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

Réimplémentation de : QAbstractSocket::waitForConnected(int msecs).

Attend que le socket soit connecté, ou pendant msecs millisecondes, selon la première éventualité. Si la connexion a été établie, cette fonction renvoie true; sinon, elle renvoie false.

Voir également QAbstractSocket::waitForConnected().

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

Réimplémentation de : QAbstractSocket::waitForDisconnected(int msecs).

Attend que la connexion soit interrompue ou que msecs millisecondes se soient écoulées, selon la première éventualité. Si la connexion a été interrompue, cette fonction renvoie true; sinon, elle renvoie false.

Voir également QAbstractSocket::waitForDisconnected().

bool QSslSocket::waitForEncrypted(int msecs = 30000)

Attend que le socket ait terminé la négociation SSL et ait émis la fonction ` encrypted()` ou que msecs millisecondes se soient écoulées, selon la première éventualité. Si la fonction ` encrypted()` a été émise, cette fonction renvoie `true` ; dans le cas contraire (par exemple, si le socket est déconnecté ou si la négociation SSL échoue), elle renvoie `false`.

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

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

Si « msecs » vaut -1, cette fonction n'aura pas de délai d'expiration.

Voir également startClientEncryption(), startServerEncryption(), encrypted() et isEncrypted().

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

Réimplémentation de : QAbstractSocket::waitForReadyRead(int msecs).

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

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