QSslSocket Class

Dokumentation der Mitgliedsfunktionen

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

Konstruiert ein QSslSocket-Objekt. parent wird an den Konstruktor von QObject übergeben. Die cipher Suite des neuen Sockets wird auf die von der statischen Methode defaultCiphers() zurückgegebene gesetzt.

[virtual noexcept] QSslSocket::~QSslSocket()

Zerstört die QSslSocket.

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

Gibt den Namen des Backends zurück, das QSslSocket und verwandte Klassen verwenden. Wenn das aktive Backend nicht explizit festgelegt wurde, gibt diese Funktion den Namen eines Standard-Backends zurück, den QSslSocket implizit aus der Liste der verfügbaren Backends auswählt.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch setActiveBackend() und availableBackends().

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

QSslSocket sendet dieses Signal, wenn eine Warnmeldung von einer Gegenstelle eingegangen ist. level gibt an, ob es sich um eine schwerwiegende oder um eine Warnung handelt. type ist der Code, der erklärt, warum die Warnmeldung gesendet wurde. Wenn eine textuelle Beschreibung der Warnmeldung verfügbar ist, wird sie in description angegeben.

Siehe auch alertSent(), QSsl::AlertLevel, und QSsl::AlertType.

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

QSslSocket gibt dieses Signal aus, wenn eine Warnmeldung an einen Peer gesendet wurde. level beschreibt, ob es sich um eine Warnung oder einen schwerwiegenden Fehler handelt. type gibt den Code der Warnmeldung an. Wenn eine textuelle Beschreibung der Warnmeldung verfügbar ist, wird sie in description angegeben.

Siehe auch alertReceived(), QSsl::AlertLevel, und QSsl::AlertType.

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

Reimplements: QIODevice::atEnd() const.

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

Gibt die Namen der aktuell verfügbaren Backends zurück. Diese Namen sind in Kleinbuchstaben, z.B. "openssl", "securetransport", "schannel" (ähnlich den bereits existierenden Funktionsnamen für TLS-Backends in Qt).

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch activeBackend().

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

Reimplements: QAbstractSocket::bytesAvailable() const.

Gibt die Anzahl der entschlüsselten Bytes zurück, die sofort zum Lesen verfügbar sind.

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

Reimplements: QAbstractSocket::bytesToWrite() const.

Gibt die Anzahl der unverschlüsselten Bytes zurück, die darauf warten, verschlüsselt und in das Netzwerk geschrieben zu werden.

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

Reimplements: QIODevice::canReadLine() const.

Gibt true zurück, wenn Sie eine Zeile (abgeschlossen durch ein einzelnes ASCII-Zeichen) mit entschlüsselten Zeichen lesen können; andernfalls wird false zurückgegeben.

[override virtual] void QSslSocket::close()

Reimplements: QAbstractSocket::close().

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

Startet eine verschlüsselte Verbindung zum Gerät hostName auf port, wobei mode als OpenMode verwendet wird. Dies entspricht einem Aufruf von connectToHost() zum Aufbau der Verbindung, gefolgt von einem Aufruf von startClientEncryption(). Der Parameter protocol kann verwendet werden, um das zu verwendende Netzwerkprotokoll anzugeben (z. B. IPv4 oder IPv6).

QSslSocket tritt zunächst in den HostLookupState ein. Dann, nach dem Eintritt in die Ereignisschleife oder in eine der waitFor...()-Funktionen, tritt es in den ConnectingState ein, sendet connected() und initiiert dann den SSL-Client-Handshake. Bei jedem Zustandswechsel sendet QSslSocket das Signal stateChanged().

Wenn nach der Initiierung des SSL-Client-Handshake die Identität der Gegenstelle nicht festgestellt werden kann, wird das Signal sslErrors() ausgegeben. Wenn Sie die Fehler ignorieren und die Verbindung fortsetzen wollen, müssen Sie ignoreSslErrors() aufrufen, entweder von einer Slot-Funktion aus, die mit dem Signal sslErrors() verbunden ist, oder vor dem Eintritt in den verschlüsselten Modus. Wenn ignoreSslErrors() nicht aufgerufen wird, wird die Verbindung abgebrochen, das Signal disconnected() wird ausgegeben und QSslSocket kehrt in den UnconnectedState zurück.

Wenn der SSL-Handshake erfolgreich ist, sendet QSslSocket das Signal encrypted().

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

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

Der Standardwert für mode ist ReadWrite.

Wenn Sie auf der Serverseite einer Verbindung ein QSslSocket erstellen wollen, sollten Sie stattdessen startServerEncryption() aufrufen, wenn Sie die eingehende Verbindung über QTcpServer empfangen.

Siehe auch connectToHost(), startClientEncryption(), waitForConnected(), und waitForEncrypted().

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

Dies ist eine überladene Funktion.

Zusätzlich zum ursprünglichen Verhalten von connectToHostEncrypted ermöglicht diese überladene Methode die Verwendung eines anderen Hostnamens (sslPeerName) für die Zertifikatsvalidierung anstelle desjenigen, der für die TCP-Verbindung verwendet wird (hostName).

Siehe auch connectToHostEncrypted().

[since 6.0] void QSslSocket::continueInterruptedHandshake()

Wenn eine Anwendung einen Handshake auch nach Erhalt des Signals handshakeInterruptedOnError() abschließen möchte, muss sie diese Funktion aufrufen. Dieser Aufruf muss von einer Slot-Funktion aus erfolgen, die mit dem Signal verbunden ist. Die Signal-Slot-Verbindung muss direkt sein.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch handshakeInterruptedOnError() und QSslConfiguration::setHandshakeMustInterruptOnError().

[signal] void QSslSocket::encrypted()

Dieses Signal wird ausgesendet, wenn QSslSocket in den verschlüsselten Modus wechselt. Nachdem dieses Signal ausgegeben wurde, gibt QSslSocket::isEncrypted() den Wert true zurück, und alle weiteren Übertragungen auf dem Socket werden verschlüsselt.

Siehe auch QSslSocket::connectToHostEncrypted() und QSslSocket::isEncrypted().

qint64 QSslSocket::encryptedBytesAvailable() const

Gibt die Anzahl der verschlüsselten Bytes zurück, die auf die Entschlüsselung warten. Normalerweise gibt diese Funktion 0 zurück, da QSslSocket die eingehenden Daten so schnell wie möglich entschlüsselt.

qint64 QSslSocket::encryptedBytesToWrite() const

Gibt die Anzahl der verschlüsselten Bytes zurück, die darauf warten, in das Netzwerk geschrieben zu werden.

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

Dieses Signal wird ausgegeben, wenn QSslSocket seine verschlüsselten Daten in das Netzwerk schreibt. Der Parameter written enthält die Anzahl der Bytes, die erfolgreich geschrieben wurden.

Siehe auch QIODevice::bytesWritten().

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

QSslSocket gibt dieses Signal aus, wenn ein Fehler bei der Zertifikatsüberprüfung gefunden wurde und wenn die frühzeitige Fehlerberichterstattung in QSslConfiguration aktiviert wurde. Von einer Anwendung wird erwartet, dass sie die error überprüft und entscheidet, ob sie den Handshake fortsetzen oder abbrechen und eine Warnmeldung an die Gegenstelle senden will. Die Signal-Slot-Verbindung muss direkt sein.

Siehe auch continueInterruptedHandshake(), sslErrors(), und QSslConfiguration::setHandshakeMustInterruptOnError().

[slot] void QSslSocket::ignoreSslErrors()

Dieser Slot weist QSslSocket an, Fehler während der Handshake-Phase von QSslSocket zu ignorieren und die Verbindung fortzusetzen. Wenn Sie die Verbindung auch dann fortsetzen wollen, wenn während der Handshake-Phase Fehler auftreten, müssen Sie diesen Slot entweder von einem Slot aus aufrufen, der mit sslErrors() verbunden ist, oder vor der Handshake-Phase. Wenn Sie diesen Slot nicht aufrufen, entweder als Reaktion auf Fehler oder vor dem Handshake, wird die Verbindung nach dem Aussenden des Signals sslErrors() abgebrochen.

Treten während der SSL-Handshake-Phase keine Fehler auf (d. h. die Identität der Gegenstelle wird ohne Probleme festgestellt), sendet QSslSocket das Signal sslErrors() nicht aus, und es ist nicht notwendig, diese Funktion aufzurufen.

Siehe auch sslErrors().

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

Dies ist eine überladene Funktion.

Mit dieser Methode wird QSslSocket angewiesen, nur die in errors angegebenen Fehler zu ignorieren.

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

Bei mehreren Aufrufen dieser Funktion wird die Liste der Fehler, die bei früheren Aufrufen übergeben wurden, ersetzt. Sie können die Liste der Fehler, die Sie ignorieren möchten, löschen, indem Sie diese Funktion mit einer leeren Liste aufrufen.

Siehe auch sslErrors() und sslHandshakeErrors().

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

Diese Funktion gibt Backend-spezifische Klassen zurück, die von dem Backend mit dem Namen backendName implementiert werden. Ein leeres backendName wird als eine Abfrage über das derzeit aktive Backend verstanden.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch QSsl::ImplementedClass, activeBackend(), und isClassImplemented().

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

Gibt true zurück, wenn eine Klasse cl von dem Backend mit dem Namen backendName implementiert ist. Ein leeres backendName wird als eine Abfrage über das derzeit aktive Backend verstanden.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch implementedClasses().

bool QSslSocket::isEncrypted() const

Gibt true zurück, wenn der Socket verschlüsselt ist; andernfalls wird false zurückgegeben.

Ein verschlüsselter Socket verschlüsselt alle Daten, die durch den Aufruf von write() oder putChar() geschrieben werden, bevor die Daten in das Netzwerk geschrieben werden, und entschlüsselt alle eingehenden Daten, wenn die Daten vom Netzwerk empfangen werden, bevor Sie read(), readLine() oder getChar() aufrufen.

QSslSocket sendet encrypted(), wenn es in den verschlüsselten Modus wechselt.

Sie können sessionCipher() aufrufen, um herauszufinden, welche kryptografische Chiffre zum Ver- und Entschlüsseln Ihrer Daten verwendet wird.

Siehe auch mode().

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

Gibt true zurück, wenn ein Merkmal ft von einem Backend namens backendName unterstützt wird. Ein leeres backendName wird als eine Abfrage über das derzeit aktive Backend verstanden.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch QSsl::SupportedFeature und supportedFeatures().

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

Gibt true zurück, wenn protocol von einem Backend namens backendName unterstützt wird. Ein leeres backendName wird als eine Abfrage über das derzeit aktive Backend verstanden.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch supportedProtocols().

QSslCertificate QSslSocket::localCertificate() const

Gibt das lokale Zertifikat des Sockets certificate zurück, oder ein leeres Zertifikat, wenn kein lokales Zertifikat zugewiesen wurde.

Siehe auch setLocalCertificate() und privateKey().

QList<QSslCertificate> QSslSocket::localCertificateChain() const

Gibt die lokale certificate -Kette des Sockets zurück oder eine leere Liste, wenn keine lokalen Zertifikate zugewiesen wurden.

Siehe auch setLocalCertificateChain().

QSslSocket::SslMode QSslSocket::mode() const

Gibt den aktuellen Modus für den Socket zurück; entweder UnencryptedMode, wobei sich QSslSocket identisch zu QTcpSocket verhält, oder einen von SslClientMode oder SslServerMode, wobei der Client entweder verhandelt oder im verschlüsselten Modus ist.

Wenn sich der Modus ändert, gibt QSslSocket modeChanged () aus.

Siehe auch SslMode.

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

Dieses Signal wird ausgegeben, wenn QSslSocket von QSslSocket::UnencryptedMode zu entweder QSslSocket::SslClientMode oder QSslSocket::SslServerMode wechselt. mode ist der neue Modus.

Siehe auch QSslSocket::mode().

[signal] void QSslSocket::newSessionTicketReceived()

Wenn das TLS 1.3 Protokoll während eines Handshakes ausgehandelt wurde, sendet QSslSocket dieses Signal nach dem Empfang der NewSessionTicket Nachricht. Die Sitzung und der Hinweis auf die Lebensdauer des Sitzungstickets werden in der Socket-Konfiguration aktualisiert. Die Sitzung kann für die Wiederaufnahme der Sitzung (und einen verkürzten Handshake) in zukünftigen TLS-Verbindungen verwendet werden.

Siehe auch QSslSocket::sslConfiguration(), QSslConfiguration::sessionTicket(), und QSslConfiguration::sessionTicketLifeTimeHint().

QList<QOcspResponse> QSslSocket::ocspResponses() const

Diese Funktion gibt die Antworten des Online Certificate Status Protocol zurück, die ein Server während eines TLS-Handshake mit OCSP-Stapling senden kann. Die Liste ist leer, wenn keine definitive Antwort oder gar keine Antwort empfangen wurde.

Siehe auch QSslConfiguration::setOcspStaplingEnabled().

QSslCertificate QSslSocket::peerCertificate() const

Gibt das digitale Zertifikat der Gegenstelle zurück (d. h. das unmittelbare Zertifikat des Hosts, mit dem Sie verbunden sind) oder ein Null-Zertifikat, wenn die Gegenstelle kein Zertifikat zugewiesen hat.

Das Peer-Zertifikat wird während der Handshake-Phase automatisch überprüft, so dass diese Funktion normalerweise verwendet wird, um das Zertifikat zur Anzeige oder zu Verbindungsdiagnosezwecken zu holen. Es enthält Informationen über die Gegenstelle, einschließlich ihres Hostnamens, des Zertifikatsausstellers und des öffentlichen Schlüssels der Gegenstelle.

Da das Peer-Zertifikat während der Handshake-Phase gesetzt wird, ist es sicher, auf das Peer-Zertifikat von einem Slot aus zuzugreifen, der mit dem sslErrors()-Signal oder dem encrypted()-Signal verbunden ist.

Wenn ein Null-Zertifikat zurückgegeben wird, kann dies bedeuten, dass der SSL-Handshake fehlgeschlagen ist, dass der Host, mit dem Sie verbunden sind, kein Zertifikat hat oder dass keine Verbindung besteht.

Wenn Sie die komplette Zertifikatskette der Gegenstelle überprüfen wollen, verwenden Sie peerCertificateChain(), um sie alle auf einmal zu erhalten.

Siehe auch peerCertificateChain().

QList<QSslCertificate> QSslSocket::peerCertificateChain() const

Gibt die Kette der digitalen Zertifikate der Gegenstelle oder eine leere Liste von Zertifikaten zurück.

Die Peer-Zertifikate werden während der Handshake-Phase automatisch überprüft. Diese Funktion wird normalerweise verwendet, um Zertifikate zur Anzeige oder zur Verbindungsdiagnose abzurufen. Zertifikate enthalten Informationen über die Gegenstelle und die Zertifikatsaussteller, einschließlich des Host-Namens, der Ausstellernamen und der öffentlichen Schlüssel der Aussteller.

Die Peer-Zertifikate werden in QSslSocket während der Handshake-Phase gesetzt, so dass es sicher ist, diese Funktion von einem Slot aus aufzurufen, der mit dem sslErrors()-Signal oder dem encrypted()-Signal verbunden ist.

Wenn eine leere Liste zurückgegeben wird, kann dies bedeuten, dass der SSL-Handshake fehlgeschlagen ist, oder dass der Host, mit dem Sie verbunden sind, kein Zertifikat hat, oder dass keine Verbindung besteht.

Wenn Sie nur das unmittelbare Zertifikat der Gegenstelle erhalten möchten, verwenden Sie peerCertificate().

Siehe auch peerCertificate().

int QSslSocket::peerVerifyDepth() const

Gibt die maximale Anzahl der Zertifikate in der Zertifikatskette der Gegenstelle zurück, die während der SSL-Handshake-Phase geprüft werden sollen, oder 0 (Standard), wenn keine maximale Tiefe festgelegt wurde, was bedeutet, dass die gesamte Zertifikatskette geprüft werden soll.

Die Zertifikate werden in der Ausgabereihenfolge geprüft, beginnend mit dem eigenen Zertifikat der Gegenstelle, dann das Zertifikat des Ausstellers und so weiter.

Siehe auch setPeerVerifyDepth() und peerVerifyMode().

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

QSslSocket kann dieses Signal mehrmals während des SSL-Handshakes aussenden, bevor die Verschlüsselung aufgebaut ist, um anzuzeigen, dass bei der Feststellung der Identität der Gegenstelle ein Fehler aufgetreten ist. Die error ist in der Regel ein Hinweis darauf, dass QSslSocket nicht in der Lage ist, die Gegenstelle sicher zu identifizieren.

Dieses Signal gibt Ihnen einen frühen Hinweis darauf, dass etwas nicht in Ordnung ist. Wenn Sie eine Verbindung zu diesem Signal herstellen, können Sie manuell entscheiden, ob Sie die Verbindung innerhalb des angeschlossenen Slots abbauen wollen, bevor der Handshake abgeschlossen ist. Wird nichts unternommen, fährt QSslSocket mit der Ausgabe von QSslSocket::sslErrors() fort.

Siehe auch sslErrors().

QSslSocket::PeerVerifyMode QSslSocket::peerVerifyMode() const

Gibt den Verifizierungsmodus des Sockets zurück. Dieser Modus entscheidet, ob QSslSocket ein Zertifikat von der Gegenstelle anfordern soll (d.h. der Client fordert ein Zertifikat vom Server an, oder der Server fordert ein Zertifikat vom Client an) und ob er voraussetzen soll, dass dieses Zertifikat gültig ist.

Der Standardmodus ist AutoVerifyPeer, was QSslSocket anweist, VerifyPeer für Clients und QueryPeer für Server zu verwenden.

Siehe auch setPeerVerifyMode(), peerVerifyDepth(), und mode().

QString QSslSocket::peerVerifyName() const

Gibt den abweichenden Hostnamen für die Zertifikatsvalidierung zurück, wie er von setPeerVerifyName oder von connectToHostEncrypted festgelegt wurde.

Siehe auch setPeerVerifyName() und connectToHostEncrypted().

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

QSslSocket sendet dieses Signal, wenn er eine PSK-Ciphersuite aushandelt, so dass eine PSK-Authentifizierung erforderlich ist.

Bei der Verwendung von PSK muss der Client dem Server eine gültige Identität und einen gültigen Pre-Shared Key senden, damit der SSL-Handshake fortgesetzt werden kann. Anwendungen können diese Informationen in einem mit diesem Signal verbundenen Slot bereitstellen, indem sie das übergebene authenticator Objekt entsprechend ihren Bedürfnissen ausfüllen.

Siehe auch QSslPreSharedKeyAuthenticator.

QSslKey QSslSocket::privateKey() const

Gibt den privaten Schlüssel dieses Sockets zurück.

Siehe auch setPrivateKey() und localCertificate().

QSsl::SslProtocol QSslSocket::protocol() const

Gibt das SSL-Protokoll des Sockets zurück. Standardmäßig wird QSsl::SecureProtocols verwendet.

Siehe auch setProtocol().

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

Reimplements: QAbstractSocket::readData(char *data, qint64 maxSize).

[override virtual] void QSslSocket::resume()

Reimplements: QAbstractSocket::resume().

Setzt die Datenübertragung auf dem Socket fort, nachdem sie angehalten wurde. Wenn "setPauseMode(QAbstractSocket::PauseOnSslErrors);" auf diesem Socket aufgerufen wurde und ein sslErrors() Signal empfangen wird, ist der Aufruf dieser Methode notwendig, damit der Socket fortgesetzt werden kann.

Siehe auch QAbstractSocket::pauseMode() und QAbstractSocket::setPauseMode().

QSslCipher QSslSocket::sessionCipher() const

Gibt die kryptografische Chiffre des Sockets cipher zurück, oder eine Null-Chiffre, wenn die Verbindung nicht verschlüsselt ist. Die Chiffre des Sockets für die Sitzung wird während der Handshake-Phase festgelegt. Die Chiffre wird zum Ver- und Entschlüsseln von Daten verwendet, die über den Socket übertragen werden.

QSslSocket bietet auch Funktionen zum Setzen der geordneten Liste von Chiffren, aus der die Handshake-Phase schließlich die Sitzungs-Chiffre auswählt. Diese geordnete Liste muss vorhanden sein, bevor die Handshake-Phase beginnt.

Siehe auch QSslConfiguration::ciphers(), QSslConfiguration::setCiphers(), QSslConfiguration::setCiphers(), QSslConfiguration::ciphers(), und QSslConfiguration::supportedCiphers().

QSsl::SslProtocol QSslSocket::sessionProtocol() const

Gibt das SSL/TLS-Protokoll des Sockets zurück oder UnknownProtocol, wenn die Verbindung nicht verschlüsselt ist. Das Protokoll des Sockets für die Sitzung wird während der Handshake-Phase festgelegt.

Siehe auch protocol() und setProtocol().

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

Gibt true zurück, wenn ein Backend mit dem Namen backendName als aktives Backend festgelegt wurde. backendName muss einer der von availableBackends() zurückgegebenen Namen sein.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch activeBackend() und availableBackends().

void QSslSocket::setLocalCertificate(const QSslCertificate &certificate)

Setzt das lokale Zertifikat des Sockets auf certificate. Das lokale Zertifikat ist erforderlich, wenn Sie Ihre Identität gegenüber der Gegenstelle bestätigen müssen. Es wird zusammen mit dem privaten Schlüssel verwendet; wenn Sie das lokale Zertifikat setzen, müssen Sie auch den privaten Schlüssel setzen.

Das lokale Zertifikat und der private Schlüssel sind immer für Server-Sockets erforderlich, werden aber auch selten von Client-Sockets verwendet, wenn der Server vom Client eine Authentifizierung verlangt.

Siehe auch localCertificate() und setPrivateKey().

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

Dies ist eine überladene Funktion.

Setzt die lokale certificate des Sockets auf die erste in der Datei path gefundene Datei, die gemäß der angegebenen format geparst wird.

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

Stellt die Zertifikatskette, die der Gegenstelle während des SSL-Handshakes vorgelegt wird, auf localChain ein.

Siehe auch localCertificateChain() und QSslConfiguration::setLocalCertificateChain().

void QSslSocket::setPeerVerifyDepth(int depth)

Legt die maximale Anzahl der Zertifikate in der Zertifikatskette der Gegenstelle fest, die während der SSL-Handshake-Phase geprüft werden sollen, und zwar auf depth. Die Einstellung einer Tiefe von 0 bedeutet, dass keine maximale Tiefe festgelegt wird, was bedeutet, dass die gesamte Zertifikatskette geprüft werden soll.

Die Zertifikate werden in der Reihenfolge der Ausstellung geprüft, beginnend mit dem eigenen Zertifikat der Gegenstelle, dann das Zertifikat des Ausstellers und so weiter.

Siehe auch peerVerifyDepth() und setPeerVerifyMode().

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

Setzt den Verifizierungsmodus des Sockets auf mode. Dieser Modus entscheidet, ob QSslSocket ein Zertifikat von der Gegenstelle anfordert (d.h. der Client fordert ein Zertifikat vom Server an, oder der Server fordert ein Zertifikat vom Client an) und ob dieses Zertifikat gültig sein muss.

Der Standardmodus ist AutoVerifyPeer, wodurch QSslSocket angewiesen wird, VerifyPeer für Clients und QueryPeer für Server zu verwenden.

Das Setzen dieses Modus nach Beginn der Verschlüsselung hat keine Auswirkungen auf die aktuelle Verbindung.

Siehe auch peerVerifyMode(), setPeerVerifyDepth(), und mode().

void QSslSocket::setPeerVerifyName(const QString &hostName)

Setzt einen anderen Hostnamen, der durch hostName angegeben wird, für die Zertifikatsüberprüfung anstelle desjenigen, der für die TCP-Verbindung verwendet wird.

Siehe auch peerVerifyName() und connectToHostEncrypted().

void QSslSocket::setPrivateKey(const QSslKey &key)

Setzt den privaten Schlüssel des Sockets key auf key. Der private Schlüssel und das lokale certificate werden von Clients und Servern verwendet, die ihre Identität gegenüber SSL-Peers nachweisen müssen.

Sowohl der Schlüssel als auch das lokale Zertifikat sind erforderlich, wenn Sie einen SSL-Server-Socket erstellen. Wenn Sie einen SSL-Client-Socket erstellen, sind der Schlüssel und das lokale Zertifikat erforderlich, wenn sich Ihr Client gegenüber einem SSL-Server identifizieren muss.

Siehe auch privateKey() und setLocalCertificate().

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

Dies ist eine überladene Funktion.

Liest die Zeichenkette in der Datei fileName und dekodiert sie unter Verwendung eines angegebenen algorithm und der Kodierung format, um einen SSL key zu erstellen. Wenn der kodierte Schlüssel verschlüsselt ist, wird passPhrase verwendet, um ihn zu entschlüsseln.

Der private Schlüssel des Sockets wird auf den konstruierten Schlüssel gesetzt. Der private Schlüssel und das lokale certificate werden von Clients und Servern verwendet, die ihre Identität gegenüber SSL-Peers nachweisen müssen.

Sowohl der Schlüssel als auch das lokale Zertifikat werden benötigt, wenn Sie einen SSL-Server-Socket erstellen. Wenn Sie einen SSL-Client-Socket erstellen, sind der Schlüssel und das lokale Zertifikat erforderlich, wenn sich Ihr Client gegenüber einem SSL-Server identifizieren muss.

Siehe auch privateKey() und setLocalCertificate().

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

Setzt das SSL-Protokoll des Sockets auf protocol. Dies wirkt sich auf den nächsten initiierten Handshake aus; der Aufruf dieser Funktion bei einem bereits verschlüsselten Socket hat keine Auswirkungen auf das Protokoll des Sockets.

Siehe auch protocol().

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

Reimplements: QAbstractSocket::setReadBufferSize(qint64 size).

Setzt die Größe des internen Lesepuffers von QSslSocket auf size Bytes.

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

Reimplements: QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState socketState, QIODeviceBase::OpenMode openMode).

Initialisiert QSslSocket mit dem nativen Socket-Deskriptor socketDescriptor. Gibt true zurück, wenn socketDescriptor als gültiger Socket-Deskriptor akzeptiert wird; andernfalls wird false zurückgegeben. Der Socket wird in dem durch openMode angegebenen Modus geöffnet und geht in den durch state angegebenen Socket-Status über.

Siehe auch socketDescriptor().

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

Reimplements: QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value).

Setzt die angegebene option auf den durch value beschriebenen Wert.

Siehe auch socketOption().

void QSslSocket::setSslConfiguration(const QSslConfiguration &configuration)

Setzt die SSL-Konfiguration des Sockets auf den Inhalt von configuration. Diese Funktion setzt das lokale Zertifikat, die Chiffren, den privaten Schlüssel und die CA-Zertifikate auf die in configuration gespeicherten.

Es ist nicht möglich, die SSL-Status-bezogenen Felder zu setzen.

Siehe auch sslConfiguration(), setLocalCertificate(), setPrivateKey(), QSslConfiguration::setCaCertificates(), und QSslConfiguration::setCiphers().

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

Reimplements: QAbstractSocket::skipData(qint64 maxSize).

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

Reimplements: QAbstractSocket::socketOption(QAbstractSocket::SocketOption option).

Gibt den Wert der Option option zurück.

Siehe auch setSocketOption().

QSslConfiguration QSslSocket::sslConfiguration() const

Gibt den SSL-Konfigurationsstatus des Sockets zurück. Die Standard-SSL-Konfiguration eines Sockets ist die Verwendung der Standard-Chiffren, Standard-CA-Zertifikate, kein lokaler privater Schlüssel oder Zertifikat.

Die SSL-Konfiguration enthält auch Felder, die sich mit der Zeit ohne Ankündigung ändern können.

Siehe auch setSslConfiguration(), localCertificate(), peerCertificate(), peerCertificateChain(), sessionCipher(), privateKey(), QSslConfiguration::ciphers(), und QSslConfiguration::caCertificates().

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

QSslSocket gibt dieses Signal nach dem SSL-Handshake aus, um anzuzeigen, dass ein oder mehrere Fehler bei der Feststellung der Identität der Gegenstelle aufgetreten sind. Die Fehler sind in der Regel ein Hinweis darauf, dass QSslSocket nicht in der Lage ist, die Gegenstelle sicher zu identifizieren. Wenn keine Maßnahmen ergriffen werden, wird die Verbindung nach dem Ausgeben dieses Signals abgebrochen.

Wenn Sie die Verbindung trotz der aufgetretenen Fehler fortsetzen wollen, müssen Sie QSslSocket::ignoreSslErrors() innerhalb eines mit diesem Signal verbundenen Slots aufrufen. Wenn Sie zu einem späteren Zeitpunkt auf die Fehlerliste zugreifen müssen, können Sie sslHandshakeErrors() aufrufen.

errors enthält einen oder mehrere Fehler, die QSslSocket daran hindern, die Identität der Gegenstelle zu überprüfen.

Siehe auch peerVerifyError().

QList<QSslError> QSslSocket::sslHandshakeErrors() const

Gibt eine Liste der zuletzt aufgetretenen SSL-Fehler zurück. Dies ist dieselbe Liste, die QSslSocket über das Signal sslErrors() übergibt. Wenn die Verbindung ohne Fehler verschlüsselt wurde, gibt diese Funktion eine leere Liste zurück.

Siehe auch connectToHostEncrypted().

[static] long QSslSocket::sslLibraryBuildVersionNumber()

Gibt die Versionsnummer der SSL-Bibliothek zurück, die zur Kompilierungszeit verwendet wird. Wenn keine SSL-Unterstützung verfügbar ist, wird -1 zurückgegeben.

Siehe auch sslLibraryVersionNumber().

[static] QString QSslSocket::sslLibraryBuildVersionString()

Gibt die Versionszeichenfolge der SSL-Bibliothek zurück, die zur Kompilierungszeit verwendet wird. Wenn keine SSL-Unterstützung verfügbar ist, wird ein leerer Wert zurückgegeben.

Siehe auch sslLibraryVersionString().

[static] long QSslSocket::sslLibraryVersionNumber()

Gibt die Versionsnummer der verwendeten SSL-Bibliothek zurück. Beachten Sie, dass dies die Version der Bibliothek ist, die zur Laufzeit und nicht zur Kompilierzeit verwendet wird. Wenn keine SSL-Unterstützung verfügbar ist, wird -1 zurückgegeben.

[static] QString QSslSocket::sslLibraryVersionString()

Gibt die Versionszeichenfolge der verwendeten SSL-Bibliothek zurück. Beachten Sie, dass dies die Version der Bibliothek ist, die zur Laufzeit und nicht zur Kompilierzeit verwendet wird. Wenn keine SSL-Unterstützung verfügbar ist, wird ein leerer Wert zurückgegeben.

[slot] void QSslSocket::startClientEncryption()

Startet einen verzögerten SSL-Handshake für eine Client-Verbindung. Diese Funktion kann aufgerufen werden, wenn sich der Socket im ConnectedState, aber noch im UnencryptedMode befindet. Wenn er noch nicht verbunden oder bereits verschlüsselt ist, hat diese Funktion keine Wirkung.

Clients, die die STARTTLS-Funktionalität implementieren, verwenden häufig verzögerte SSL-Handshakes. Die meisten anderen Clients können den direkten Aufruf dieser Funktion vermeiden, indem sie stattdessen connectToHostEncrypted() verwenden, die den Handshake automatisch durchführt.

Siehe auch connectToHostEncrypted() und startServerEncryption().

[slot] void QSslSocket::startServerEncryption()

Startet einen verzögerten SSL-Handshake für eine Serververbindung. Diese Funktion kann aufgerufen werden, wenn sich der Socket im ConnectedState, aber noch im UnencryptedMode befindet. Wenn er nicht verbunden oder bereits verschlüsselt ist, hat die Funktion keine Wirkung.

Für Server-Sockets ist der Aufruf dieser Funktion die einzige Möglichkeit, den SSL-Handshake zu initiieren. Die meisten Server rufen diese Funktion sofort auf, wenn sie eine Verbindung erhalten, oder als Ergebnis eines protokollspezifischen Befehls zum Eintritt in den SSL-Modus (z. B. kann der Server auf den Empfang der Zeichenkette "STARTTLS\r\n" mit dem Aufruf dieser Funktion reagieren).

Die gängigste Art, einen SSL-Server zu implementieren, besteht darin, eine Unterklasse von QTcpServer zu erstellen und QTcpServer::incomingConnection() neu zu implementieren. Der zurückgegebene Socket-Deskriptor wird dann an QSslSocket::setSocketDescriptor() übergeben.

Siehe auch connectToHostEncrypted() und startClientEncryption().

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

Diese Funktion gibt Merkmale zurück, die von einem Backend namens backendName unterstützt werden. Ein leeres backendName wird als eine Abfrage über das derzeit aktive Backend verstanden.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch QSsl::SupportedFeature und activeBackend().

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

Wenn ein Backend mit dem Namen backendName verfügbar ist, gibt diese Funktion die Liste der von diesem Backend unterstützten TLS-Protokollversionen zurück. Ein leeres backendName wird als eine Abfrage über das derzeit aktive Backend verstanden. Andernfalls gibt diese Funktion eine leere Liste zurück.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch availableBackends(), activeBackend(), und isProtocolSupported().

[static] bool QSslSocket::supportsSsl()

Gibt true zurück, wenn diese Plattform SSL unterstützt; andernfalls wird false zurückgegeben. Wenn die Plattform SSL nicht unterstützt, schlägt der Socket in der Verbindungsphase fehl.

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

Reimplements: QAbstractSocket::waitForBytesWritten(int msecs).

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

Reimplements: QAbstractSocket::waitForConnected(int msecs).

Wartet, bis der Socket verbunden ist, oder msecs Millisekunden, je nachdem, was zuerst eintritt. Wenn die Verbindung hergestellt wurde, gibt diese Funktion true zurück, andernfalls false.

Siehe auch QAbstractSocket::waitForConnected().

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

Reimplements: QAbstractSocket::waitForDisconnected(int msecs).

Wartet, bis die Verbindung zum Socket getrennt wurde oder msecs Millisekunden, je nachdem, was zuerst eintritt. Wenn die Verbindung getrennt wurde, gibt diese Funktion true zurück, andernfalls false.

Siehe auch QAbstractSocket::waitForDisconnected().

bool QSslSocket::waitForEncrypted(int msecs = 30000)

Wartet, bis der Socket den SSL-Handshake abgeschlossen hat und encrypted() gesendet hat, oder msecs Millisekunden, je nachdem, was zuerst eintritt. Wenn encrypted() gesendet wurde, gibt diese Funktion true zurück; andernfalls (z. B. wenn die Verbindung zum Socket getrennt wurde oder der SSL-Handshake fehlschlägt) wird false zurückgegeben.

Im folgenden Beispiel wird bis zu einer Sekunde gewartet, bis der Socket verschlüsselt ist:

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

Wenn msecs -1 ist, wird diese Funktion nicht abgebrochen.

Siehe auch startClientEncryption(), startServerEncryption(), encrypted(), und isEncrypted().

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

Reimplements: QAbstractSocket::waitForReadyRead(int msecs).

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

Reimplements: QAbstractSocket::writeData(const char *data, qint64 size).