QSslSocket Class

Dokumentation der Member-Funktionen

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

Erstellt ein QSslSocket-Objekt. „ parent “ wird an den Konstruktor von „ QObject “ übergeben. Die „ cipher “-Suite des neuen Sockets wird auf diejenige gesetzt, die von der statischen Methode „defaultCiphers()“ zurückgegeben wird.

[virtual noexcept] QSslSocket::~QSslSocket()

Zerstört die „ QSslSocket “.

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

Gibt den Namen des Backends zurück, das von ` QSslSocket ` und den zugehörigen Klassen verwendet wird. Wenn das aktive Backend nicht explizit festgelegt wurde, gibt diese Funktion den Namen eines Standard-Backends zurück, das ` 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 Gibt dieses Signal aus, wenn eine Warnmeldung von einem Peer empfangen wurde. „ level “ gibt an, ob es sich bei der Warnung um einen schwerwiegenden Fehler oder um eine Warnung handelte. „ type “ ist der Code, der erklärt, warum die Warnung gesendet wurde. Wenn eine textuelle Beschreibung der Warnmeldung verfügbar ist, wird diese unter „ description “ bereitgestellt.

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 “ gibt an, ob es sich um eine Warnung oder einen schwerwiegenden Fehler handelte. „ type “ liefert den Code der Warnmeldung. Ist eine textuelle Beschreibung der Warnmeldung verfügbar, wird diese unter „ description “ bereitgestellt.

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

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

Implementiert neu: QIODevice::atEnd() const.

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

Gibt die Namen der derzeit verfügbaren Backends zurück. Diese Namen sind in Kleinbuchstaben geschrieben, z. B. „openssl“, „securetransport“, „schannel“ (ähnlich wie die bereits vorhandenen 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

Implementiert: ` 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

Implementiert neu: ` QAbstractSocket::bytesToWrite()` const.

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

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

Implementiert: ` QIODevice::canReadLine()` const.

Gibt ` true ` zurück, wenn eine Zeile (die durch ein einzelnes ASCII-Zeichen „\n “ beendet wird) mit entschlüsselten Zeichen gelesen werden kann; andernfalls wird `false` zurückgegeben.

[override virtual] void QSslSocket::close()

Implementiert: QAbstractSocket::close().

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

Implementiert: ` 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)

Stellt eine verschlüsselte Verbindung zum Gerät „ hostName “ unter „ port “ her, wobei „ mode “ als „ OpenMode “ verwendet wird. Dies entspricht dem Aufruf von „ connectToHost()“ zum Aufbau der Verbindung, gefolgt von einem Aufruf von „ startClientEncryption()“. Mit dem Parameter „ protocol “ kann festgelegt werden, welches Netzwerkprotokoll verwendet werden soll (z. B. IPv4 oder IPv6).

QSslSocket Wechselt zunächst in den Zustand `HostLookupState`. Nach dem Eintritt in die Ereignisschleife oder in eine der `waitFor...()`-Funktionen wechselt es in den Zustand `ConnectingState`, sendet das Signal ` connected()` aus und initiiert anschließend den SSL-Client-Handshake. Bei jedem Zustandswechsel sendet ` QSslSocket ` das Signal ` stateChanged()` aus.

Kann nach dem Start des SSL-Client-Handshakes die Identität des Gegenübers nicht festgestellt werden, wird das Signal „ sslErrors()“ ausgesendet. Wenn Sie die Fehler ignorieren und die Verbindung fortsetzen möchten, müssen Sie „ ignoreSslErrors()“ aufrufen – entweder innerhalb einer Slot-Funktion, die mit dem Signal „ sslErrors()“ verbunden ist, oder vor dem Wechsel in den verschlüsselten Modus. Wird „ ignoreSslErrors()“ nicht aufgerufen, wird die Verbindung getrennt, das Signal „ disconnected()“ wird ausgelöst und „ QSslSocket “ kehrt in den „UnconnectedState“ zurück.

Ist der SSL-Handshake erfolgreich, löst ` QSslSocket ` das Signal ` encrypted()` aus.

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

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

Die Standardeinstellung für ` mode ` ist ` ReadWrite`.

Wenn Sie einen ` QSslSocket ` auf der Serverseite einer Verbindung erstellen möchten, sollten Sie stattdessen ` startServerEncryption()` aufrufen, sobald die eingehende Verbindung über ` QTcpServer` empfangen wurde.

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)

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

Siehe auch ` connectToHostEncrypted()`.

[since 6.0] void QSslSocket::continueInterruptedHandshake()

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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

[override virtual] void QSslSocket::disconnectFromHost()

Implementiert: QAbstractSocket::disconnectFromHost().

[signal] void QSslSocket::encrypted()

Dieses Signal wird ausgegeben, wenn „ QSslSocket “ in den verschlüsselten Modus wechselt. Nach Ausgabe dieses Signals gibt „ QSslSocket::isEncrypted()“ den Wert „true“ zurück, und alle weiteren Übertragungen über den 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 ihre Entschlüsselung warten. Normalerweise gibt diese Funktion den Wert 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, ins Netzwerk geschrieben zu werden.

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

Dieses Signal wird ausgelöst, wenn „ QSslSocket “ seine verschlüsselten Daten ins 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 festgestellt wurde und wenn die frühzeitige Fehlermeldung unter QSslConfiguration aktiviert wurde. Von einer Anwendung wird erwartet, dass sie den error überprüft und entscheidet, ob sie den Handshake fortsetzen oder abbrechen und eine Warnmeldung an den Gegenpart senden möchte. 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 möchten, wenn während der Handshake-Phase Fehler auftreten, müssen Sie diesen Slot entweder aus einem mit „ sslErrors()“ verbundenen Slot heraus oder vor der Handshake-Phase aufrufen. Wenn Sie diesen Slot weder als Reaktion auf Fehler noch vor dem Handshake aufrufen, wird die Verbindung nach dem Auslösen des Signals „ sslErrors()“ getrennt.

Treten während der SSL-Handshake-Phase keine Fehler auf (d. h., die Identität des Gegenübers wird problemlos festgestellt), sendet „ QSslSocket “ das Signal „ sslErrors( )“ nicht aus, und es ist nicht erforderlich, diese Funktion aufzurufen.

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

Siehe auch ` sslErrors()`.

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

Diese Methode weist „ QSslSocket “ an, ausschließlich die unter errors aufgeführten 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);

Mehrere Aufrufe dieser Funktion überschreiben die Liste der Fehler, die bei früheren Aufrufen übergeben wurden. Sie können die Liste der zu ignorierenden Fehler 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 vom Backend mit dem Namen „ backendName “ implementiert werden. Ein leeres „ backendName “ wird als Abfrage nach dem derzeit aktiven Backend interpretiert.

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 vom Backend mit dem Namen backendName implementiert wird. Ein leeres backendName wird als Abfrage nach dem aktuell aktiven Backend interpretiert.

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 ins Netzwerk geschrieben werden, und entschlüsselt alle eingehenden Daten beim Empfang aus dem Netzwerk, bevor Sie ` read()`, ` readLine()` oder ` getChar()` aufrufen.

QSslSocket Gibt „ encrypted()“ aus, wenn der verschlüsselte Modus aktiviert wird.

Sie können ` sessionCipher()` aufrufen, um herauszufinden, welche kryptografische Verschlüsselungsmethode 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 eine Funktion ft von einem Backend namens backendName unterstützt wird. Ein leeres backendName wird als Abfrage bezüglich des derzeit aktiven Backends interpretiert.

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 Abfrage zum aktuell aktiven Backend interpretiert.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch supportedProtocols().

QSslCertificate QSslSocket::localCertificate() const

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

Siehe auch ` setLocalCertificate()` und ` privateKey()`.

QList<QSslCertificate> QSslSocket::localCertificateChain() const

Gibt die lokale Zertifikatskette ( certificate ) des Sockets zurück oder eine leere Liste, falls keine lokalen Zertifikate zugewiesen wurden.

Siehe auch ` setLocalCertificateChain()` .

QSslSocket::SslMode QSslSocket::mode() const

Gibt den aktuellen Modus des Sockets zurück; entweder „ UnencryptedMode “, wobei sich „ QSslSocket “ genauso verhält wie „ QTcpSocket “, oder einen der Modi „ SslClientMode “ oder „ SslServerMode “, wobei sich der Client entweder im Verhandlungsmodus oder im verschlüsselten Modus befindet.

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

Siehe auch SslMode.

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

Dieses Signal wird ausgegeben, wenn sich „ QSslSocket “ von „ QSslSocket::UnencryptedMode “ auf entweder „ QSslSocket::SslClientMode “ oder „ QSslSocket::SslServerMode “ ändert. „ mode “ ist der neue Modus.

Siehe auch QSslSocket::mode().

[signal] void QSslSocket::newSessionTicketReceived()

Wenn während eines Handshakes das TLS-1.3-Protokoll ausgehandelt wurde, gibt „ QSslSocket “ dieses Signal nach dem Empfang der „NewSessionTicket“-Nachricht aus. Die Lebensdauer der Sitzung und des Sitzungstickets werden in der Konfiguration des Sockets aktualisiert. Die Sitzung kann für die Wiederaufnahme der Sitzung (und einen verkürzten Handshake) bei 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 (OCSP) zurück, die ein Server während eines TLS-Handshakes unter Verwendung von OCSP-Stapling senden kann. Die Liste ist leer, wenn keine endgültige Antwort oder überhaupt keine Antwort empfangen wurde.

Siehe auch ` QSslConfiguration::setOcspStaplingEnabled()`.

QSslCertificate QSslSocket::peerCertificate() const

Gibt das digitale Zertifikat des Gegenübers (d. h. das unmittelbare Zertifikat des Hosts, mit dem eine Verbindung besteht) zurück oder ein Null-Zertifikat, falls das Gegenüber kein Zertifikat zugewiesen hat.

Das Peer-Zertifikat wird während der Handshake-Phase automatisch überprüft, daher wird diese Funktion normalerweise verwendet, um das Zertifikat zur Anzeige oder für Verbindungsdiagnosezwecke abzurufen. Es enthält Informationen über den Peer, darunter dessen Hostnamen, den Zertifikatsaussteller und den öffentlichen Schlüssel des Peers.

Da das Peer-Zertifikat während der Handshake-Phase festgelegt wird, ist es sicher, über einen Slot, der mit dem Signal „ sslErrors()“ oder dem Signal „ encrypted()“ verbunden ist, auf das Peer-Zertifikat zuzugreifen.

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

Wenn Sie die vollständige Zertifikatskette des Gegenübers überprüfen möchten, verwenden Sie ` peerCertificateChain()` (), um alle Zertifikate auf einmal abzurufen.

Siehe auch ` peerCertificateChain()`.

QList<QSslCertificate> QSslSocket::peerCertificateChain() const

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

Peer-Zertifikate werden während der Handshake-Phase automatisch überprüft. Diese Funktion wird normalerweise verwendet, um Zertifikate zur Anzeige abzurufen oder um eine Verbindungsdiagnose durchzuführen. Zertifikate enthalten Informationen über den Peer und die Zertifikatsaussteller, darunter Hostname, Namen der Aussteller und öffentliche Schlüssel der Aussteller.

Die Peer-Zertifikate werden während der Handshake-Phase in ` QSslSocket ` gesetzt, sodass diese Funktion sicher aus einem Slot aufgerufen werden kann, der mit dem Signal ` sslErrors()` oder dem Signal ` encrypted()` verbunden ist.

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

Wenn Sie nur das unmittelbare Zertifikat des Gegenübers abrufen möchten, verwenden Sie ` peerCertificate()`.

Siehe auch ` peerCertificate()`.

int QSslSocket::peerVerifyDepth() const

Gibt die maximale Anzahl von Zertifikaten in der Zertifikatskette des Peers zurück, die während der SSL-Handshake-Phase überprüft werden sollen, oder 0 (Standardwert), wenn keine maximale Tiefe festgelegt wurde, was bedeutet, dass die gesamte Zertifikatskette überprüft werden soll.

Die Zertifikate werden in der Reihenfolge ihrer Ausstellung geprüft, beginnend mit dem eigenen Zertifikat des Peers, gefolgt vom Zertifikat seines Ausstellers und so weiter.

Siehe auch setPeerVerifyDepth() und peerVerifyMode().

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

QSslSocket kann dieses Signal während des SSL-Handshakes mehrmals ausgeben, bevor die Verschlüsselung hergestellt wurde, um anzuzeigen, dass beim Feststellen der Identität des Gegenübers ein Fehler aufgetreten ist. Das Signal „ error “ ist in der Regel ein Hinweis darauf, dass „ QSslSocket “ den Gegenüber nicht sicher identifizieren kann.

Dieses Signal liefert Ihnen einen frühzeitigen Hinweis darauf, dass etwas nicht stimmt. Indem Sie sich an dieses Signal anbinden, können Sie manuell entscheiden, die Verbindung aus dem verbundenen Slot heraus abzubrechen, bevor der Handshake abgeschlossen ist. Wenn keine Maßnahmen ergriffen werden, sendet „ QSslSocket “ anschließend „ QSslSocket::sslErrors “ ().

Siehe auch sslErrors().

QSslSocket::PeerVerifyMode QSslSocket::peerVerifyMode() const

Gibt den Verifizierungsmodus des Sockets zurück. Dieser Modus legt fest, ob QSslSocket ein Zertifikat vom Gegenüber anfordern soll (d. h., ob der Client ein Zertifikat vom Server anfordert oder der Server ein Zertifikat vom Client) und ob das Zertifikat gültig sein muss.

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

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

QString QSslSocket::peerVerifyName() const

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

Siehe auch setPeerVerifyName() und connectToHostEncrypted().

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

QSslSocket gibt dieses Signal aus, wenn es eine PSK-Verschlüsselungssuite aushandelt; daher ist anschließend eine PSK-Authentifizierung erforderlich.

Bei Verwendung von PSK muss der Client eine gültige Identität und einen gültigen vorab geteilten Schlüssel an den Server 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 Anforderungen 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)

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

[override virtual] void QSslSocket::resume()

Implementiert: ` QAbstractSocket::resume()`.

Setzt die Datenübertragung über den Socket fort, nachdem diese unterbrochen wurde. Wenn für diesen Socket „setPauseMode(QAbstractSocket::PauseOnSslErrors);“ aufgerufen wurde und ein Signal vom Typ „ sslErrors()“ empfangen wird, muss diese Methode aufgerufen werden, damit der Socket die Übertragung fortsetzen kann.

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

QSslCipher QSslSocket::sessionCipher() const

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

QSslSocket Bietet außerdem Funktionen zum Festlegen der geordneten Liste von Verschlüsselungsalgorithmen, aus der die Handshake-Phase schließlich den Sitzungsverschlüsselungsalgorithmus auswählt. Diese geordnete Liste muss vor Beginn der Handshake-Phase vorhanden sein.

Siehe auch QSslConfiguration::ciphers(), QSslConfiguration::setCiphers() 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 Namen sein, die von „ availableBackends()“ zurückgegeben werden.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch ` activeBackend()` und ` availableBackends()`.

void QSslSocket::setLocalCertificate(const QSslCertificate &certificate)

Legt das lokale Zertifikat des Sockets auf „ certificate “ fest. Das lokale Zertifikat ist erforderlich, wenn Sie Ihre Identität gegenüber dem Gegenüber bestätigen müssen. Es wird zusammen mit dem privaten Schlüssel verwendet; wenn Sie das lokale Zertifikat festlegen, müssen Sie auch den privaten Schlüssel festlegen.

Das lokale Zertifikat und der private Schlüssel sind für Server-Sockets immer 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)

Setzt die lokale Konfiguration des Sockets „ certificate “ auf die erste Eintragung, die in der Datei „ path “ gefunden wird, wobei diese gemäß der angegebenen Option „ format “ geparst wird.

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

Legt fest, dass die Zertifikatskette, die dem Gegenüber während des SSL-Handshakes vorgelegt wird, „ localChain “ lauten soll.

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

void QSslSocket::setPeerVerifyDepth(int depth)

Legt die maximale Anzahl der Zertifikate in der Zertifikatskette des Peers fest, die während der SSL-Handshake-Phase überprüft werden sollen, und zwar auf „ depth “. Die Einstellung „0“ bedeutet, dass keine maximale Tiefe festgelegt ist, was darauf hinweist, dass die gesamte Zertifikatskette überprüft werden soll.

Die Zertifikate werden in der Reihenfolge ihrer Ausstellung geprüft, beginnend mit dem eigenen Zertifikat des Peers, gefolgt vom Zertifikat seines Ausstellers und so weiter.

Siehe auch peerVerifyDepth() und setPeerVerifyMode().

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

Setzt den Verifizierungsmodus des Sockets auf „ mode “. Dieser Modus legt fest, ob „ QSslSocket “ ein Zertifikat vom Gegenüber anfordern soll (d. h., ob der Client ein Zertifikat vom Server anfordert oder der Server ein Zertifikat vom Client) 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)

Legt für die Zertifikatsüberprüfung einen anderen Hostnamen fest, der unter hostName angegeben ist, anstelle des für die TCP-Verbindung verwendeten.

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 Zertifikat 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, falls 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())

Liest die Zeichenkette aus der Datei „ fileName “ ein und dekodiert sie unter Verwendung eines angegebenen „ algorithm “ und einer Codierung „ format “, um ein „ SSL key “ zu erstellen. Falls der kodierte Schlüssel verschlüsselt ist, wird „ passPhrase “ verwendet, um ihn zu entschlüsseln.

Der private Schlüssel des Sockets wird auf den erstellten 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 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, falls 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)

Implementiert neu: QAbstractSocket::setReadBufferSize(Größe in qint64).

Legt die Größe des internen Lesepuffers von ` QSslSocket` auf ` size ` Bytes fest.

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

Implementiert neu: 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 wechselt in den durch ` state` angegebenen Socket-Zustand.

Siehe auch ` socketDescriptor()`.

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

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

Setzt die angegebene ` option ` auf den Wert, der durch ` value` beschrieben wird.

Siehe auch socketOption().

void QSslSocket::setSslConfiguration(const QSslConfiguration &configuration)

Setzt die SSL-Konfiguration des Sockets auf den Inhalt von configuration. Diese Funktion legt das lokale Zertifikat, die Verschlüsselungsalgorithmen, den privaten Schlüssel und die CA-Zertifikate so fest, wie sie unter configuration gespeichert sind.

Es ist nicht möglich, die Felder zum SSL-Status festzulegen.

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

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

Implementiert: QAbstractSocket::skipData(qint64 maxSize).

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

Implementiert: ` 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 sieht die Verwendung der Standard-Verschlüsselungsalgorithmen und Standard-CA-Zertifikate vor, ohne lokalen privaten Schlüssel oder Zertifikat.

Die SSL-Konfiguration enthält außerdem Felder, die sich im Laufe der Zeit ohne Vorankü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 beim Feststellen der Identität des Gegenübers ein oder mehrere Fehler aufgetreten sind. Die Fehler deuten in der Regel darauf hin, dass QSslSocket den Gegenüber nicht sicher identifizieren kann. Sofern keine Maßnahmen ergriffen werden, wird die Verbindung nach Ausgabe dieses Signals getrennt.

Wenn Sie die Verbindung trotz der aufgetretenen Fehler fortsetzen möchten, müssen Sie ` QSslSocket::ignoreSslErrors()` innerhalb eines Slots aufrufen, der mit diesem Signal verbunden ist. 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 des Peers zu überprüfen.

Siehe auch „ peerVerifyError()“.

QList<QSslError> QSslSocket::sslHandshakeErrors() const

Gibt eine Liste der zuletzt aufgetretenen SSL-Fehler zurück. Es handelt sich um dieselbe Liste, die „ QSslSocket “ über das Signal „ sslErrors()“ übergibt. Wenn die Verbindung fehlerfrei verschlüsselt wurde, gibt diese Funktion eine leere Liste zurück.

Siehe auch ` connectToHostEncrypted()`.

[static] long QSslSocket::sslLibraryBuildVersionNumber()

Gibt die Versionsnummer der zum Zeitpunkt der Kompilierung verwendeten SSL-Bibliothek zurück. Ist keine SSL-Unterstützung verfügbar, wird der Wert -1 zurückgegeben.

Siehe auch ` sslLibraryVersionNumber()`.

[static] QString QSslSocket::sslLibraryBuildVersionString()

Gibt die Versionszeichenfolge der zum Zeitpunkt der Kompilierung verwendeten SSL-Bibliothek zurück. Ist keine SSL-Unterstützung verfügbar, 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 es sich hierbei um die Version der Bibliothek handelt, die zur Laufzeit verwendet wird, nicht zur Kompilierungszeit. Wenn keine SSL-Unterstützung verfügbar ist, wird der Wert -1 zurückgegeben.

[static] QString QSslSocket::sslLibraryVersionString()

Gibt die Versionszeichenfolge der verwendeten SSL-Bibliothek zurück. Beachten Sie, dass es sich hierbei um die Version der Bibliothek handelt, die zur Laufzeit und nicht zur Kompilierungszeit verwendet wird. Ist keine SSL-Unterstützung verfügbar, 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 Status „ ConnectedState “ befindet, aber noch im Status „ UnencryptedMode “ ist. Wenn noch keine Verbindung besteht oder diese bereits verschlüsselt ist, hat diese Funktion keine Auswirkung.

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

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 Status „ ConnectedState “ befindet, aber noch im Status „ UnencryptedMode “ ist. Ist keine Verbindung hergestellt oder ist die Verbindung bereits verschlüsselt, hat die Funktion keine Wirkung.

Bei Server-Sockets ist der Aufruf dieser Funktion die einzige Möglichkeit, den SSL-Handshake zu initiieren. Die meisten Server rufen diese Funktion unmittelbar nach dem Empfang einer Verbindung auf oder als Reaktion auf den Empfang eines protokollspezifischen Befehls zum Wechsel 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 Methode zur Implementierung eines SSL-Servers besteht darin, eine Unterklasse von ` QTcpServer ` zu erstellen und ` QTcpServer::incomingConnection()` neu zu implementieren. Der zurückgegebene Socket-Deskriptor wird anschließend an ` QSslSocket::setSocketDescriptor()` übergeben.

Siehe auch ` connectToHostEncrypted()` und ` startClientEncryption()`.

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

Diese Funktion gibt die Funktionen zurück, die von einem Backend namens „ backendName “ unterstützt werden. Ein leeres „ backendName “ wird als Abfrage zum aktuell aktiven Backend interpretiert.

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 Abfrage nach dem derzeit aktiven Backend interpretiert. 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)

Implementiert: QAbstractSocket::waitForBytesWritten(int msecs).

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

Implementiert: QAbstractSocket::waitForConnected(int msecs).

Wartet, bis die Verbindung zum Socket hergestellt ist oder bis msecs Millisekunden verstrichen sind – je nachdem, was zuerst eintritt. Wenn die Verbindung hergestellt wurde, gibt diese Funktion „ true “ zurück; andernfalls gibt sie „ false “ zurück.

Siehe auch ` QAbstractSocket::waitForConnected()`.

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

Implementiert: QAbstractSocket::waitForDisconnected(int msecs).

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

Siehe auch ` QAbstractSocket::waitForDisconnected()`.

bool QSslSocket::waitForEncrypted(int msecs = 30000)

Wartet, bis der Socket den SSL-Handshake abgeschlossen und ` encrypted()` ausgegeben hat, oder bis msecs Millisekunden verstrichen sind – je nachdem, was zuerst eintritt. Wenn ` encrypted()` ausgegeben wurde, gibt diese Funktion `true` zurück; andernfalls (z. B. wenn die Verbindung zum Socket unterbrochen wurde oder der SSL-Handshake fehlgeschlagen ist) wird `false` zurückgegeben.

Das folgende Beispiel wartet bis zu einer Sekunde, bis der Socket verschlüsselt ist:

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

Wenn „msecs“ den Wert -1 hat, läuft diese Funktion ohne Zeitlimit ab.

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

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

Implementiert: QAbstractSocket::waitForReadyRead(int msecs).

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

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