Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

SslStream-Klasse

 

Veröffentlicht: Oktober 2016

Stellt einen für die Client/Server-Kommunikation verwendeten Datenstrom bereit, der das Sicherheitsprotokoll Secure Socket Layer (SSL) zur Authentifizierung des Servers und optional des Clients verwendet.

Namespace:   System.Net.Security
Assembly:  System (in System.dll)

System.Object
  System.MarshalByRefObject
    System.IO.Stream
      System.Net.Security.AuthenticatedStream
        System.Net.Security.SslStream

public class SslStream : AuthenticatedStream

NameBeschreibung
System_CAPS_pubmethodSslStream(Stream)

Initialisiert eine neue Instanz der SslStream-Klasse mit dem angegebenen Stream.

System_CAPS_pubmethodSslStream(Stream, Boolean)

Initialisiert eine neue Instanz von der SslStream -Klasse mit dem angegebenen Stream und streamen Closure-Verhalten.

System_CAPS_pubmethodSslStream(Stream, Boolean, RemoteCertificateValidationCallback)

Initialisiert eine neue Instanz von der SslStream -Klasse mit dem angegebenen Stream, SSL-Delegat und streamen Closure-Verhalten.

System_CAPS_pubmethodSslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

Initialisiert eine neue Instanz von der SslStream -Klasse mit dem angegebenen Stream, Closure-Verhalten, Zertifikat-Delegat und Zertifikatsauswahldelegaten streamen.

System_CAPS_pubmethodSslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)

Initialisiert eine neue Instanz der SslStream -Klasse mit dem angegebenen Stream

NameBeschreibung
System_CAPS_pubpropertyCanRead

Ruft einen Boolean -Wert, der angibt, ob der zugrunde liegende Stream gelesen werden kann.(Überschreibt Stream.CanRead.)

System_CAPS_pubpropertyCanSeek

Ruft einen Boolean -Wert, der angibt, ob der zugrunde liegende Stream durchsucht werden.(Überschreibt Stream.CanSeek.)

System_CAPS_pubpropertyCanTimeout

Ruft ein Boolean Wert, der angibt, ob der zugrunde liegende Stream Timeouts unterstützt.(Überschreibt Stream.CanTimeout.)

System_CAPS_pubpropertyCanWrite

Ruft einen Boolean -Wert, der angibt, ob der zugrunde liegende Stream geschrieben werden kann.(Überschreibt Stream.CanWrite.)

System_CAPS_pubpropertyCheckCertRevocationStatus

Ruft ein Boolean Wert, der angibt, ob die Zertifikatsperrliste, während der Überprüfung des Zertifikats überprüft wird.

System_CAPS_pubpropertyCipherAlgorithm

Ruft einen Wert, der von diesem Bulk-Verschlüsselungsalgorithmus identifiziert SslStream.

System_CAPS_pubpropertyCipherStrength

Ruft einen Wert, der die Stärke des von diesem verwendeten Verschlüsselungsalgorithmus identifiziert SslStream.

System_CAPS_pubpropertyHashAlgorithm

Ruft den Algorithmus zum Generieren von Nachrichtenauthentifizierungscodes (MACs).

System_CAPS_pubpropertyHashStrength

Ruft einen Wert, der die Stärke des von dieser Instanz verwendeten Hashalgorithmus angibt.

System_CAPS_protpropertyInnerStream

Ruft den Stream verwendete AuthenticatedStream für das Senden und Empfangen von Daten.(Geerbt von „AuthenticatedStream“.)

System_CAPS_pubpropertyIsAuthenticated

Ruft einen Boolean -Wert, der angibt, ob die Authentifizierung erfolgreich war.(Überschreibt AuthenticatedStream.IsAuthenticated.)

System_CAPS_pubpropertyIsEncrypted

Ruft ein Boolean Wert, der angibt, ob dies SslStream verschlüsselte Daten verwendet.(Überschreibt AuthenticatedStream.IsEncrypted.)

System_CAPS_pubpropertyIsMutuallyAuthenticated

Ruft einen Boolean -Wert, der angibt, ob sowohl Client als auch Server authentifiziert wurden.(Überschreibt AuthenticatedStream.IsMutuallyAuthenticated.)

System_CAPS_pubpropertyIsServer

Ruft einen Boolean -Wert, der angibt, ob die lokale Seite der Verbindung von diesem verwendet SslStream wie der Server authentifiziert wurde.(Überschreibt AuthenticatedStream.IsServer.)

System_CAPS_pubpropertyIsSigned

Ruft einen Boolean -Wert, der angibt, ob die mit diesem Stream gesendeten Daten signiert sind.(Überschreibt AuthenticatedStream.IsSigned.)

System_CAPS_pubpropertyKeyExchangeAlgorithm

Ruft die von diesem verwendeten Schlüsselaustauschalgorithmus SslStream.

System_CAPS_pubpropertyKeyExchangeStrength

Ruft einen Wert, der die Stärke des von dieser Instanz verwendeten Schlüsselaustauschalgorithmus angibt.

System_CAPS_pubpropertyLeaveInnerStreamOpen

Ruft ab, ob der Stream von diesem verwendet AuthenticatedStream für senden und Empfangen von Daten weiterhin geöffnet ist.(Geerbt von „AuthenticatedStream“.)

System_CAPS_pubpropertyLength

Ruft die Länge des zugrunde liegenden Streams.(Überschreibt Stream.Length.)

System_CAPS_pubpropertyLocalCertificate

Ruft das Zertifikat zur Authentifizierung des lokalen Endpunkts.

System_CAPS_pubpropertyPosition

Ruft ab oder legt die aktuelle Position in den zugrunde liegenden Stream.(Überschreibt Stream.Position.)

System_CAPS_pubpropertyReadTimeout

Ruft ab oder legt die Zeitspanne, die ein Lesevorgang Wartens auf Daten blockiert.(Überschreibt Stream.ReadTimeout.)

System_CAPS_pubpropertyRemoteCertificate

Ruft das Zertifikat zur Authentifizierung des Remoteendpunkts ab.

System_CAPS_pubpropertySslProtocol

Ruft einen Wert, der das zum Authentifizieren dieser Verbindung verwendete Sicherheitsprotokoll angibt.

System_CAPS_pubpropertyTransportContext

Ruft die TransportContext für die Authentifizierung mit erweitertem Schutz verwendet.

System_CAPS_pubpropertyWriteTimeout

Ruft ab oder legt die Zeitspanne, die ein Schreibvorgang Wartens auf Daten blockiert.(Überschreibt Stream.WriteTimeout.)

NameBeschreibung
System_CAPS_pubmethodAuthenticateAsClient(String)

Wird von Clients zur Authentifizierung des Servers und optional den Client in einer Client / Server-Verbindung.

System_CAPS_pubmethodAuthenticateAsClient(String, X509CertificateCollection, Boolean)

Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Der Authentifizierungsprozess verwendet die angegebene Zertifikatsammlung und das SSL-Standardprotokoll des Systems.

System_CAPS_pubmethodAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

Wird von Clients zur Authentifizierung des Servers und optional den Client in einer Client / Server-Verbindung. Der Authentifizierungsprozess verwendet die angegebene Auflistung und die SSL-Protokoll.

System_CAPS_pubmethodAuthenticateAsClientAsync(String)

Wird von Clients zur Authentifizierung des Servers und optional den Client in einer Client / Server-Verbindung als einen asynchronen Vorgang.

System_CAPS_pubmethodAuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Der Authentifizierungsprozess verwendet die angegebene Zertifikatsammlung und das SSL-Standardprotokoll des Systems.

System_CAPS_pubmethodAuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

Wird von Clients zur Authentifizierung des Servers und optional den Client in einer Client / Server-Verbindung als einen asynchronen Vorgang. Der Authentifizierungsprozess verwendet die angegebene Auflistung und die SSL-Protokoll.

System_CAPS_pubmethodAuthenticateAsServer(X509Certificate)

Aufgerufen von Servern zur Authentifizierung des Servers und optional auch den Client in einer Client / Server-Verbindung mit dem angegebenen Zertifikat.

System_CAPS_pubmethodAuthenticateAsServer(X509Certificate, Boolean, Boolean)

Wird von Servern aufgerufen, um den Server und optional den Client in einer Client-Server-Verbindung mithilfe der angegebenen Zertifikate, Anforderungen und des Standardsicherheitsprotokolls des Systems zu authentifizieren.

System_CAPS_pubmethodAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)

Wird von Servern aufgerufen, um den Server und optional den Client in einer Client/Server-Verbindung mithilfe der angegebenen Zertifikate, Anforderungen und des Sicherheitsprotokolls zu authentifizieren.

System_CAPS_pubmethodAuthenticateAsServerAsync(X509Certificate)

Wird vom Server zum Authentifizieren des Servers und optional den Client in einer Client / Server-Verbindung mit dem angegebenen Zertifikat als asynchronen Vorgang aufgerufen.

System_CAPS_pubmethodAuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)

Wird von Servern aufgerufen, um den Server und optional den Client in einer Client/Server-Verbindung mithilfe der angegebenen Zertifikate, Anforderungen und des Sicherheitsprotokolls als asynchronen Vorgang zu authentifizieren.

System_CAPS_pubmethodAuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)

Wird von Servern aufgerufen, um den Server und optional den Client in einer Client/Server-Verbindung mithilfe der angegebenen Zertifikate, Anforderungen und des Sicherheitsprotokolls als asynchronen Vorgang zu authentifizieren.

System_CAPS_pubmethodBeginAuthenticateAsClient(String, AsyncCallback, Object)

Wird von Clients mit dem beginnen eines asynchronen Vorgangs zur Authentifizierung des Servers und optional des Clients aufgerufen.

System_CAPS_pubmethodBeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)

Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Servers und optional des Clients mithilfe der angegebenen Zertifikate und des Standardsicherheitsprotokolls des Systems zu beginnen.

System_CAPS_pubmethodBeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)

Wird von Clients beginnen einen asynchronen Vorgang zur Authentifizierung des Servers und optional des Clients mit den angegebenen Zertifikaten und Sicherheitsprotokoll.

System_CAPS_pubmethodBeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)

Wird von Servern, um einen asynchronen Vorgang zum Authentifizieren des Clients zu beginnen und optional die Server in einer Client / Server-Verbindung.

System_CAPS_pubmethodBeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)

Wird von Servern aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Servers und optional des Clients mithilfe der angegebenen Zertifikate, Anforderungen und des Standardsicherheitsprotokolls des Systems zu beginnen.

System_CAPS_pubmethodBeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)

Wird von Servern aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Servers und optional des Clients mithilfe der angegebenen Zertifikate, Anforderungen und des Sicherheitsprotokolls zu beginnen.

System_CAPS_pubmethodBeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Lesevorgang, der Daten aus dem Stream gelesen und im angegebenen Array speichert.(Überschreibt Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).)

System_CAPS_pubmethodBeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Schreibvorgang, der schreibt Bytes vom angegebenen Puffer in den Stream.(Überschreibt Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).)

System_CAPS_pubmethodClose()

Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles). Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyTo(Stream)

Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyTo(Stream, Int32)

Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyToAsync(Stream)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyToAsync(Stream, Int32)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyToAsync(Stream, Int32, CancellationToken)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream.(Geerbt von „Stream“.)

System_CAPS_pubmethodCreateObjRef(Type)

Erstellt ein Objekt, das alle relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt verwendet die enthält.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodCreateWaitHandle()

Veraltet. Reserviert ein WaitHandle-Objekt.(Geerbt von „Stream“.)

System_CAPS_pubmethodDispose()

Gibt alle vom Stream verwendeten Ressourcen frei.(Geerbt von „Stream“.)

System_CAPS_protmethodDispose(Boolean)

Gibt die von SslStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.(Überschreibt AuthenticatedStream.Dispose(Boolean).)

System_CAPS_pubmethodEndAuthenticateAsClient(IAsyncResult)

Beendet ein ausstehenden asynchronen Server-Authentifizierung-Vorgang, mit einem vorherigen Aufruf von gestartet BeginAuthenticateAsServer.

System_CAPS_pubmethodEndAuthenticateAsServer(IAsyncResult)

Beendet ein ausstehende asynchrone Client-Authentifizierung-Vorgang gestartet wird, mit einem vorherigen Aufruf von BeginAuthenticateAsClient.

System_CAPS_pubmethodEndRead(IAsyncResult)

Beendet ein asynchroner Lesevorgang, mit einem vorherigen Aufruf von gestartet BeginRead.(Überschreibt Stream.EndRead(IAsyncResult).)

System_CAPS_pubmethodEndWrite(IAsyncResult)

Beendet ein asynchronen Schreibvorgang, mit einem vorherigen Aufruf von gestartet BeginWrite.(Überschreibt Stream.EndWrite(IAsyncResult).)

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird.(Geerbt von „Object“.)

System_CAPS_pubmethodFlush()

Bewirkt, dass alle gepufferten Daten an das zugrunde liegende Gerät geschrieben werden.(Überschreibt Stream.Flush().)

System_CAPS_pubmethodFlushAsync()

Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät.(Geerbt von „Stream“.)

System_CAPS_pubmethodFlushAsync(CancellationToken)

Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen.(Geerbt von „Stream“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetLifetimeService()

Ruft das Dienstobjekt für aktuellen Lebensdauer, das steuert, die lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodInitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject Objekt.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodObjectInvariant()

Veraltet. Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Bietet Unterstützung für einen Contract.(Geerbt von „Stream“.)

System_CAPS_pubmethodRead(Byte[], Int32, Int32)

Liest Daten aus diesem Stream und speichert ihn im angegebenen Array.(Überschreibt Stream.Read(Byte[], Int32, Int32).)

System_CAPS_pubmethodReadAsync(Byte[], Int32, Int32)

Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn.(Geerbt von „Stream“.)

System_CAPS_pubmethodReadAsync(Byte[], Int32, Int32, CancellationToken)

Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen.(Geerbt von „Stream“.)

System_CAPS_pubmethodReadByte()

Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist.(Geerbt von „Stream“.)

System_CAPS_pubmethodSeek(Int64, SeekOrigin)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Löst eine NotSupportedException aus.(Überschreibt Stream.Seek(Int64, SeekOrigin).)

System_CAPS_pubmethodSetLength(Int64)

Legt die Länge des zugrunde liegenden Streams fest.(Überschreibt Stream.SetLength(Int64).)

System_CAPS_pubmethodShutdownAsync()

Fährt diesen SslStream herunter.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodWrite(Byte[])

Schreibt die angegebenen Daten in diesen Stream.

System_CAPS_pubmethodWrite(Byte[], Int32, Int32)

Schreiben Sie die angegebene Anzahl von Bytein den zugrunde liegenden Stream mit dem angegebenen Puffer und Offset.(Überschreibt Stream.Write(Byte[], Int32, Int32).)

System_CAPS_pubmethodWriteAsync(Byte[], Int32, Int32)

Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn.(Geerbt von „Stream“.)

System_CAPS_pubmethodWriteAsync(Byte[], Int32, Int32, CancellationToken)

Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.(Geerbt von „Stream“.)

System_CAPS_pubmethodWriteByte(Byte)

Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte.(Geerbt von „Stream“.)

Bei der SSL-Protokolle Vertraulichkeit und Integrität, die Meldungen mit übertragen geprüft bieten eine SslStream. Eine SSL-Verbindung, z. B. von SslStream, sollten werden verwendet, wenn Kommunikation vertraulichen Informationen zwischen einem Client und einem Server. Mithilfe einer SslStream hilft zu verhindern, dass Benutzer lesen und manipulieren Informationen, während es bei der Übertragung im Netzwerk befindet.

Ein SslStream Instanz überträgt Daten mit einem Stream, den Sie angeben, für die Erstellung der SslStream. Wenn Sie diese zugrunde liegenden Stream bereitstellen, haben Sie die Option zur Angabe, ob das Schließen der SslStream schließt auch die zugrunde liegenden Stream. In der Regel die SslStream Klasse wird verwendet, mit der TcpClient und TcpListener Klassen. Die GetStream Methode bietet eine NetworkStream geeignet für die Verwendung mit der SslStream Klasse.

Nach dem Erstellen einer SslStream, den Server und optional der Client authentifiziert werden müssen. Der Server muss ein X509 bereitgestellt, Zertifikat, stellt seine Identitätsnachweis her und kann anfordern, dass der Client dies auch tun. Authentifizierung muss erfolgen, bevor übertragen Informationen mithilfe einer SslStream. Clients initiieren die Authentifizierung mit den synchronen AuthenticateAsClient -Methoden, die blockiert werden, bis die Authentifizierung abgeschlossen wurde, oder den asynchronen BeginAuthenticateAsClient -Methoden, die Wartezeit für die Authentifizierung abgeschlossen nicht blockieren. Server initiieren die Authentifizierung mit den synchronen AuthenticateAsServer oder asynchrone BeginAuthenticateAsServer Methoden. Sowohl Client als auch Server müssen die Authentifizierung initiiert werden.

Die Authentifizierung erfolgt über die Security Support Provider (SSPI)-Channel-Anbieters. Der Client erhält die Gelegenheit zur Validierung des Serverzertifikats durch Angabe steuern eine RemoteCertificateValidationCallback delegate beim Erstellen einer SslStream. Der Server kann auch steuern Überprüfung durch Angabe einer RemoteCertificateValidationCallback delegieren. Die Methode, die der Delegat verweist umfasst der Remoteanbieter Zertifikat und ggf. aufgetretenen Fehlern SSPI, die bei der Überprüfung des Zertifikats. Beachten Sie, dass der Server über einen Delegaten an, der Delegat-Methode so aufgerufen wird, unabhängig davon, ob der Server die Clientauthentifizierung angefordert. Wenn der Server nicht die Clientauthentifizierung angefordert hat, empfängt Delegatmethode des Servers ein null-Zertifikat und ein leeres Array vom Zertifikatfehler.

Wenn der Server die Clientauthentifizierung erforderlich ist, muss der Client eine oder mehrere Zertifikate für die Authentifizierung angeben. Wenn der Client mehr als ein Zertifikat verfügt, kann der Client Bereitstellen einer LocalCertificateSelectionCallback Delegat, der das richtige Zertifikat für den Server auswählen. Die Zertifikate des Clients müssen in der aktuellen Zertifikatspeicher des Benutzers "My" befinden. Die Clientauthentifizierung über Zertifikate wird nicht unterstützt, für die Ssl2 -Protokoll (SSL-Version 2).

Wenn die Authentifizierung ein Fehler auftritt, erhalten Sie eine AuthenticationException, und die SslStream ist nicht mehr funktionsfähig. Sie sollten dieses Objekt schließen und entfernen alle Verweise darauf, damit sie vom Garbage Collector erfasst werden kann.

Bei der Authentifizierung benötigt, auch bekannt als SSL-Handshake, erfolgreich ist, ist die Identität des Servers (und optional den Client) hergestellt und die SslStream vom Client und Server für den Austausch von Nachrichten verwendet werden können. Vor dem Senden oder Empfangen von Informationen, Client und Server sollte überprüfen Sie die Sicherheitsdienste und gebotenen Ebenen der SslStream zu bestimmen, ob die Anforderungen für die Integrität und Vertraulichkeit Protokoll, Algorithmen und Stärken ausgewählt zu erfüllen. Wenn die aktuellen Einstellungen nicht ausreichen, sollte der Stream geschlossen werden. Sehen Sie sich die Sicherheitsdienste gebotenen der SslStream mithilfe der IsEncrypted und IsSigned Eigenschaften. Die folgende Tabelle zeigt die Elemente, die die kryptografischen zurückgegeben, für die Authentifizierung, Verschlüsselung und Signierung von Daten verwendet.

Element

Mitglieder

Das Sicherheitsprotokoll verwendet, um den Server und optional den Client zu authentifizieren.

Die SslProtocol Eigenschaft und den zugehörigen SslProtocols Enumeration.

Der Algorithmus für den Schlüsselaustausch.

Die KeyExchangeAlgorithm Eigenschaft und den zugehörigen ExchangeAlgorithmType Enumeration.

Algorithmus für die Integrität.

Die HashAlgorithm Eigenschaft und den zugehörigen HashAlgorithmType Enumeration.

Algorithmus für die Vertraulichkeit.

Die CipherAlgorithm Eigenschaft und den zugehörigen CipherAlgorithmType Enumeration.

Die Stärken der ausgewählten Algorithmen.

Die KeyExchangeStrength, HashStrength, und CipherStrength Eigenschaften.

Nach einer erfolgreichen Authentifizierung können Sie Daten mithilfe von synchronen senden Write oder asynchrone BeginWrite Methoden. Möglicherweise erhalten Sie Daten mithilfe von synchronen Read oder asynchrone BeginRead Methoden.

Wenn Sie angegeben haben, um die SslStream , dass der zugrunde liegende Stream geöffnet bleiben werden sollte, Sie sind verantwortlich für Stream schließen, wenn Sie fertig sind verwenden.

System_CAPS_noteHinweis

Wenn die Anwendung erstellt wird, die die SslStream -Objekt mit den Anmeldeinformationen eines Standardbenutzers ausgeführt wird, die Anwendung Zertifikate im Speicher lokalen Computers installiert werden, es sei denn, die Berechtigung wurde dem Benutzer explizit erteilt Zugriff auf nicht möglich.

SslStreamsetzt voraus, dass ein Timeout sowie alle anderen IOException bei einer ausgelöst wird, vom inneren Datenstrom wird als schwerwiegend behandelt durch den Aufrufer. Wiederverwenden von einem SslStream -Instanz nach ein Timeout Garbage zurückgegeben wird. Eine Anwendung sollte Close die SslStream und löst eine Ausnahme in diesen Fällen.

.NET Framework 4.6 umfasst eine neue Sicherheitsfunktion, die unsichere Verschlüsselungssammlungen und Hashalgorithmen für Verbindungen blockiert. Anwendungen verwenden TLS/SSL über APIs wie z. B. "HttpClient", HttpWebRequest-Anforderung, FTPClient, SmtpClient, SslStream usw. und .NET Framework 4.6 abzielt erhalten die sicherere Verhalten in der Standardeinstellung.

Möglicherweise möchten Entwickler dieses Verhalten abzuwählen, um die Interoperabilität mit ihrer vorhandenen SSL3-Diensten oder TLS mit RC4-Dienste zu verwalten. This articleErläutert, wie Sie Ihren Code ändern, damit das neue Verhalten deaktiviert ist.

.NET Framework 4.6.3 fügt neue Überladungen für die Methoden, die SslStreams zu, die die TLS-Protokollversion, die als Systemstandard im definierte verwenden authentifizieren, sondern geben Sie eine TLS-Version nicht SCHANNEL. Verwenden Sie diese Methoden in Ihrer app als eine Möglichkeit, die Standardwerte später als TLS Version best-Practice-Änderungen im Laufe der Zeit ändern können ohne die Notwendigkeit zum Erstellen und bereitzustellen, die app.

Das folgende Codebeispiel veranschaulicht das Erstellen einer TcpListener , verwendet die SslStream Klasse für die Kommunikation mit Clients.

using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public sealed class SslTcpServer 
    {
        static X509Certificate serverCertificate = null;
        // The certificate parameter specifies the name of the file 
        // containing the machine certificate.
        public static void RunServer(string certificate) 
        {
            serverCertificate = X509Certificate.CreateFromCertFile(certificate);
            // Create a TCP/IP (IPv4) socket and listen for incoming connections.
            TcpListener listener = new TcpListener(IPAddress.Any, 8080);    
            listener.Start();
            while (true) 
            {
                Console.WriteLine("Waiting for a client to connect...");
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                TcpClient client = listener.AcceptTcpClient();
                ProcessClient(client);
            }
        }
        static void ProcessClient (TcpClient client)
        {
            // A client has connected. Create the 
            // SslStream using the client's network stream.
            SslStream sslStream = new SslStream(
                client.GetStream(), false);
            // Authenticate the server but don't require the client to authenticate.
            try 
            {
                sslStream.AuthenticateAsServer(serverCertificate, 
                    false, SslProtocols.Tls, true);
                // Display the properties and settings for the authenticated stream.
                DisplaySecurityLevel(sslStream);
                DisplaySecurityServices(sslStream);
                DisplayCertificateInformation(sslStream);
                DisplayStreamProperties(sslStream);

                // Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000;
                sslStream.WriteTimeout = 5000;
                // Read a message from the client.   
                Console.WriteLine("Waiting for client message...");
                string messageData = ReadMessage(sslStream);
                Console.WriteLine("Received: {0}", messageData);

                // Write a message to the client.
                byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
                Console.WriteLine("Sending hello message.");
                sslStream.Write(message);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                sslStream.Close();
                client.Close();
                return;
            }
            finally
            {
                // The client stream will be closed with the sslStream
                // because we specified this behavior when creating
                // the sslStream.
                sslStream.Close();
                client.Close();
            }
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the client.
            // The client signals the end of the message using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF or an empty message.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes !=0); 

            return messageData.ToString();
        }
         static void DisplaySecurityLevel(SslStream stream)
         {
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength);
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength);
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength);
            Console.WriteLine("Protocol: {0}", stream.SslProtocol);
         }
         static void DisplaySecurityServices(SslStream stream)
         {
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted);
         }
         static void DisplayStreamProperties(SslStream stream)
         {
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite);
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout);
         }
        static void DisplayCertificateInformation(SslStream stream)
        {
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus);

            X509Certificate localCertificate = stream.LocalCertificate;
            if (stream.LocalCertificate != null)
            {
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.",
                    localCertificate.Subject,
                    localCertificate.GetEffectiveDateString(),
                    localCertificate.GetExpirationDateString());
             } else
            {
                Console.WriteLine("Local certificate is null.");
            }
            // Display the properties of the client's certificate.
            X509Certificate remoteCertificate = stream.RemoteCertificate;
            if (stream.RemoteCertificate != null)
            {
            Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.",
                remoteCertificate.Subject,
                remoteCertificate.GetEffectiveDateString(),
                remoteCertificate.GetExpirationDateString());
            } else
            {
                Console.WriteLine("Remote certificate is null.");
            }
        }
        private static void DisplayUsage()
        { 
            Console.WriteLine("To start the server specify:");
            Console.WriteLine("serverSync certificateFile.cer");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string certificate = null;
            if (args == null ||args.Length < 1 )
            {
                DisplayUsage();
            }
            certificate = args[0];
            SslTcpServer.RunServer (certificate);
            return 0;
        } 
    }
}

Das folgende Codebeispiel veranschaulicht das Erstellen einer TcpClient , verwendet die SslStream Klasse für die Kommunikation mit einem Server.

using System;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public class SslTcpClient 
    {   
        private static Hashtable certificateErrors = new Hashtable();

        // The following method is invoked by the RemoteCertificateValidationDelegate.
        public static bool ValidateServerCertificate(
              object sender,
              X509Certificate certificate,
              X509Chain chain,
              SslPolicyErrors sslPolicyErrors)
        {
           if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }
        public static void RunClient(string machineName, string serverName)  
        {
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient client = new TcpClient(machineName,443);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(), 
                false, 
                new RemoteCertificateValidationCallback (ValidateServerCertificate), 
                null
                );
            // The server name must match the name on the server certificate.
            try 
            {
                sslStream.AuthenticateAsClient(serverName);
            } 
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                client.Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server. 
            sslStream.Write(messsage);
            sslStream.Flush();
            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes != 0); 

            return messageData.ToString();
        }
        private static void DisplayUsage()
        { 
            Console.WriteLine("To start the client specify:");
            Console.WriteLine("clientSync machineName [serverName]");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string serverCertificateName = null;
            string machineName = null;
            if (args == null ||args.Length <1 )
            {
                DisplayUsage();
            }
            // User can specify the machine name and server name.
            // Server name must match the name on the server's certificate. 
            machineName = args[0];
            if (args.Length <2 )
            {
                serverCertificateName = machineName;
            }
            else 
            {
                serverCertificateName = args[1];
            }
            SslTcpClient.RunClient (machineName, serverCertificateName);
            return 0;
        }
    }
}

.NET Framework
Verfügbar seit 2.0

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: