SslStream Klasse

Referenz

Definition

Namespace:: System.Net.Security

Assembly:: System.Net.Security.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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.

public ref class SslStream : System::Net::Security::AuthenticatedStream

public class SslStream : System.Net.Security.AuthenticatedStream

type SslStream = class
    inherit AuthenticatedStream

type SslStream = class
    inherit AuthenticatedStream
    interface IDisposable

Public Class SslStream
Inherits AuthenticatedStream

Vererbung: Object

Stream

AuthenticatedStream
SslStream

Vererbung: Object

MarshalByRefObject

Stream

AuthenticatedStream
SslStream

Implementiert: IDisposable

Beispiele

Im folgenden Codebeispiel wird das Erstellen einer TcpListener Klasse veranschaulicht, die die Kommunikation mit Clients verwendet SslStream .

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Net::Security;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;
public ref class SslTcpServer sealed
{
private:
   static X509Certificate^ serverCertificate = nullptr;

public:

   // The certificate parameter specifies the name of the file 
   // containing the machine certificate.
   static void RunServer( String^ certificate )
   {
      serverCertificate = X509Certificate::CreateFromCertFile( certificate );
      
      // Create a TCP/IP (IPv4) socket and listen for incoming connections.
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,5000 );
      listener->Start();
      
      while (true) 
      {
         Console::WriteLine( L"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 = gcnew SslStream( client->GetStream(),false );
      
      // Authenticate the server but don't require the client to authenticate.
      try
      {
         sslStream->AuthenticateAsServer( serverCertificate, false, true );
         // false == no client cert required; true == check cert revocation.
         
         // 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( L"Waiting for client message..." );
         String^ messageData = ReadMessage( sslStream );
         Console::WriteLine( L"Received: {0}", messageData );
         
         // Write a message to the client.
         array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
         Console::WriteLine( L"Sending hello message." );
         sslStream->Write( message );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( L"Exception: {0}", e->Message );
         if ( e->InnerException != nullptr )
         {
            Console::WriteLine( L"Inner exception: {0}", e->InnerException->Message );
         }
         Console::WriteLine( L"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.
      array<Byte>^buffer = gcnew array<Byte>(2048);
      StringBuilder^ messageData = gcnew 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();
         array<Char>^chars = gcnew array<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( L"<EOF>" ) != -1 )
         {
            break;
         }
      }
      while ( bytes != 0 );

      return messageData->ToString();
   }


   static void DisplaySecurityLevel( SslStream^ stream )
   {
      Console::WriteLine( L"Cipher: {0} strength {1}", stream->CipherAlgorithm, stream->CipherStrength );
      Console::WriteLine( L"Hash: {0} strength {1}", stream->HashAlgorithm, stream->HashStrength );
      Console::WriteLine( L"Key exchange: {0} strength {1}", stream->KeyExchangeAlgorithm, stream->KeyExchangeStrength );
      Console::WriteLine( L"Protocol: {0}", stream->SslProtocol );
   }


   static void DisplaySecurityServices( SslStream^ stream )
   {
      Console::WriteLine( L"Is authenticated: {0} as server? {1}", stream->IsAuthenticated, stream->IsServer );
      Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
      Console::WriteLine( L"Is Encrypted: {0}", stream->IsEncrypted );
   }


   static void DisplayStreamProperties( SslStream^ stream )
   {
      Console::WriteLine( L"Can read: {0}, write {1}", stream->CanRead, stream->CanWrite );
      Console::WriteLine( L"Can timeout: {0}", stream->CanTimeout );
   }


   static void DisplayCertificateInformation( SslStream^ stream )
   {
      Console::WriteLine( L"Certificate revocation list checked: {0}", stream->CheckCertRevocationStatus );
      X509Certificate^ localCertificate = stream->LocalCertificate;
      if ( stream->LocalCertificate != nullptr )
      {
         Console::WriteLine( L"Local cert was issued to {0} and is valid from {1} until {2}.", 
             localCertificate->Subject, 
             localCertificate->GetEffectiveDateString(), 
             localCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Local certificate is null." );
      }

      X509Certificate^ remoteCertificate = stream->RemoteCertificate;
      if ( stream->RemoteCertificate != nullptr )
      {
         Console::WriteLine( L"Remote cert was issued to {0} and is valid from {1} until {2}.", 
            remoteCertificate->Subject, 
            remoteCertificate->GetEffectiveDateString(), 
            remoteCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Remote certificate is null." );
      }
   }


private:

   static void DisplayUsage()
   {
      Console::WriteLine( L"To start the server specify:" );
      Console::WriteLine( L"serverSync certificateFile.cer" );
      Environment::Exit( 1 );
   }

public:
   int RunServerASync()
   {
      array<String^>^args = Environment::GetCommandLineArgs();
      String^ certificate = nullptr;
      if ( args == nullptr || args->Length < 2 )
      {
         DisplayUsage();
      }

      certificate = args[ 1 ];
      SslTcpServer::RunServer( certificate );
      return 0;
   }

};

int main(){
    SslTcpServer^ sts = gcnew SslTcpServer();
    sts->RunServerASync();
}

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, 5000);
            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, clientCertificateRequired: false, checkCertificateRevocation: 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;
        }
    }
}

Imports System.Collections
Imports System.Net
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net
    Public NotInheritable Class SslTcpServer
        Shared serverCertificate As X509Certificate = Nothing

        ' The certificate parameter specifies the name of the file 
        ' containing the machine certificate.
        Public Shared Sub RunServer(certificate As String)
            serverCertificate = X509Certificate.CreateFromCertFile(certificate)
            ' Create a TCP/IP (IPv4) socket And listen for incoming connections.
            Dim listener = New TcpListener(IPAddress.Any, 5000)
            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.
                Dim client As TcpClient = listener.AcceptTcpClient()
                ProcessClient(client)
            End While
        End Sub
        Private Shared Sub ProcessClient(client As TcpClient)
            ' A client has connected. Create the 
            ' SslStream using the client's network stream.
            Dim sslStream = New SslStream(client.GetStream(), False)

            Try

                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired:=False, checkCertificateRevocation:=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...")
                Dim messageData As String = ReadMessage(sslStream)
                Console.WriteLine("Received: {0}", messageData)

                ' Write a message to the client.
                Dim message As Byte() = Encoding.UTF8.GetBytes("Hello from the server.<EOF>")
                Console.WriteLine("Sending hello message.")
                sslStream.Write(message)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                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()
            End Try
        End Sub

        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the client.
            ' The client signals the end of the message using the
            ' "<EOF>" marker.
            Dim buffer As Byte() = New Byte(2048) {}
            Dim messageData As StringBuilder = New StringBuilder()
            Dim bytes As Integer = -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.
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars As Char() = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF or an empty message.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then
                    Exit Do
                End If
            Loop While bytes <> 0

            Return messageData.ToString()
        End Function

        Private Shared Sub DisplaySecurityLevel(stream As SslStream)
            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)
        End Sub

        Private Shared Sub DisplaySecurityServices(stream As SslStream)
            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)
        End Sub

        Private Shared Sub DisplayStreamProperties(stream As SslStream)
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite)
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout)
        End Sub

        Private Shared Sub DisplayCertificateInformation(stream As SslStream)
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus)
            Dim localCertificate As X509Certificate = stream.LocalCertificate

            If stream.LocalCertificate IsNot Nothing Then
                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.")
            End If

            ' Display the properties of the client's certificate.
            Dim remoteCertificate As X509Certificate = stream.RemoteCertificate

            If stream.RemoteCertificate IsNot Nothing Then
                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.")
            End If
        End Sub

        Private Shared Sub DisplayUsage()
            Console.WriteLine("To start the server specify:")
            Console.WriteLine("serverSync certificateFile.cer")
            Environment.[Exit](1)
        End Sub

        Public Shared Function Main(ByVal args As String()) As Integer
            Dim certificate As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            certificate = args(0)
            RunServer(certificate)
            Return 0
        End Function
    End Class
End Namespace

Im folgenden Codebeispiel wird das Erstellen einer TcpClient Klasse veranschaulicht, die die Kommunikation mit einem Server verwendet SslStream .

#using <System.dll>
#using <System.Security.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;

namespace NlsClientSync
{
    public ref class SslTcpClient
    {
    private:
        static Hashtable^ certificateErrors = gcnew Hashtable;
        // Load a table of errors that might cause 
        // the certificate authentication to fail.
        static void InitializeCertificateErrors()
        {
            certificateErrors->Add(0x800B0101,
                "The certification has expired.");
            certificateErrors->Add(0x800B0104,
                "A path length constraint "
                "in the certification chain has been violated.");
            certificateErrors->Add(0x800B0105,
                "A certificate contains an unknown extension "
                "that is marked critical.");
            certificateErrors->Add(0x800B0107,
                "A parent of a given certificate in fact "
                "did not issue that child certificate.");
            certificateErrors->Add(0x800B0108,
                "A certificate is missing or has an empty value "
                "for a necessary field.");
            certificateErrors->Add(0x800B0109,
                "The certificate root is not trusted.");
            certificateErrors->Add(0x800B010C,
                "The certificate has been revoked.");
            certificateErrors->Add(0x800B010F,
                "The name in the certificate does not not match "
                "the host name requested by the client.");
            certificateErrors->Add(0x800B0111,
                "The certificate was explicitly marked "
                "as untrusted by the user.");
            certificateErrors->Add(0x800B0112,
                "A certification chain processed correctly, "
                "but one of the CA certificates is not trusted.");
            certificateErrors->Add(0x800B0113,
                "The certificate has an invalid policy.");
            certificateErrors->Add(0x800B0114,
                "The certificate name is either not "
                "in the permitted list or is explicitly excluded.");
            certificateErrors->Add(0x80092012,
                "The revocation function was unable to check "
                "revocation for the certificate.");
            certificateErrors->Add(0x80090327,
                "An unknown error occurred while "
                "processing the certificate.");
            certificateErrors->Add(0x80096001,
                "A system-level error occurred "
                "while verifying trust.");
            certificateErrors->Add(0x80096002,
                "The certificate for the signer of the message "
                "is invalid or not found.");
            certificateErrors->Add(0x80096003,
                "One of the counter signatures was invalid.");
            certificateErrors->Add(0x80096004,
                "The signature of the certificate "
                "cannot be verified.");
            certificateErrors->Add(0x80096005,
                "The time stamp signature or certificate "
                "could not be verified or is malformed.");
            certificateErrors->Add(0x80096010,
                "The digital signature of the object "
                "was not verified.");
            certificateErrors->Add(0x80096019,
                "The basic constraint extension of a certificate "
                "has not been observed.");
        }

        static String^ CertificateErrorDescription(UInt32 problem)
        {
            // Initialize the error message dictionary 
            // if it is not yet available.
            if (certificateErrors->Count == 0)
            {
                InitializeCertificateErrors();
            }

            String^ description = safe_cast<String^>(
                certificateErrors[problem]);
            if (description == nullptr)
            {
                description = String::Format(
                    CultureInfo::CurrentCulture,
                    "Unknown certificate error - 0x{0:x8}",
                    problem);
            }

            return description;
        }

    public:
        // The following method is invoked 
        // by the CertificateValidationDelegate.
    static bool ValidateServerCertificate(
            Object^ sender,
            X509Certificate^ certificate,
            X509Chain^ chain,
            SslPolicyErrors sslPolicyErrors)
        {
        
            Console::WriteLine("Validating the server certificate.");
            if (sslPolicyErrors == SslPolicyErrors::None)
                return true;

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

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }

        static void RunClient(String^ machineName, String^ serverName)
        {
              
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient^ client = gcnew TcpClient(machineName, 5000);
            Console::WriteLine("Client connected.");
              
            // Create an SSL stream that will close 
            // the client's stream.
            SslStream^ sslStream = gcnew SslStream(
                client->GetStream(), false,
                gcnew RemoteCertificateValidationCallback(ValidateServerCertificate),
                nullptr);
              
            // The server name must match the name
            // on the server certificate.
            try
            {
                sslStream->AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException^ ex) 
            {
                Console::WriteLine("Exception: {0}", ex->Message);
                if (ex->InnerException != nullptr)
                {
                    Console::WriteLine("Inner exception: {0}", 
                        ex->InnerException->Message);
                }

                Console::WriteLine("Authentication failed - "
                    "closing the connection.");
                sslStream->Close();
                client->Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            array<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.
            sslStream->Close();
            client->Close();
            Console::WriteLine("Client closed.");
        }
    private:
        static String^ ReadMessage(SslStream^ sslStream)
        {
              
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            array<Byte>^ buffer = gcnew array<Byte>(2048);
            StringBuilder^ messageData = gcnew StringBuilder;
            // Use Decoder class to convert from bytes to UTF8
            // in case a character spans two buffers.
            Encoding^ u8 = Encoding::UTF8;
            Decoder^ decoder = u8->GetDecoder();

            int bytes = -1;
            do
            {
                bytes = sslStream->Read(buffer, 0, buffer->Length);
                 
                array<__wchar_t>^ chars = gcnew array<__wchar_t>(
                    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();
        }
    };
}

int main()
{
    array<String^>^ args = Environment::GetCommandLineArgs();
    String^ serverCertificateName = nullptr;
    String^ machineName = nullptr;
    if (args == nullptr || args->Length < 2)
    {
        Console::WriteLine("To start the client specify:");
        Console::WriteLine("clientSync machineName [serverName]");
        return 1;
    }
        
    // User can specify the machine name and server name.
    // Server name must match the name on 
    // the server's certificate.
    machineName = args[1];
    if (args->Length < 3)
    {
        serverCertificateName = machineName;
    }
    else
    {
        serverCertificateName = args[2];
    };

    NlsClientSync::SslTcpClient::RunClient(machineName,
        serverCertificateName);

    return 0;
}

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,5000);
            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;
        }
    }
}

Imports System.Collections
Imports System.Net
Imports System.Net.Security
Imports System.Net.Sockets
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net

    Public Class SslTcpClient
        
        ' The following method is invoked by the RemoteCertificateValidationDelegate.
        Public Shared Function ValidateServerCertificate(
            sender As Object, 
            certificate As X509Certificate, 
            chain As X509Chain, 
            sslPolicyErrors As SslPolicyErrors) As Boolean
            
            If sslPolicyErrors = SslPolicyErrors.None Then Return True

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

            ' Do not allow this client to communicate with unauthenticated servers.
            Return False
        End Function
        Public Shared Sub RunClient(machineName As String, serverName As String)

            ' Create a TCP/IP client socket.
            ' machineName is the host running the server application.
            Dim client = New TcpClient(machineName, 5000)
            Console.WriteLine("Client connected.")

            ' Create an SSL stream that will close the client's stream.
            Dim sslStream = New SslStream(
                client.GetStream(), False, 
                New RemoteCertificateValidationCallback(AddressOf ValidateServerCertificate), Nothing)

            ' The server name must match the name on the server certificate.
            Try
                sslStream.AuthenticateAsClient(serverName)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                client.Close()
                Return
            End Try
            
            ' Encode a test message into a byte array.
            ' Signal the end of the message using the "<EOF>".
            Dim messsage As Byte() = Encoding.UTF8.GetBytes("Hello from the client.<EOF>")
            
            ' Send hello message to the server.
            sslStream.Write(messsage)
            sslStream.Flush()
            ' Read message from the server.
            Dim serverMessage = ReadMessage(sslStream)
            Console.WriteLine("Server says: {0}", serverMessage)

            ' Close the client connection
            client.Close()
            Console.WriteLine("Client closed.")
        End Sub
        
        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the server.
            ' The end of the message is signaled using the "<EOF>" marker.
            Dim buffer = New Byte(2048) {}
            Dim messageData = New StringBuilder()
            Dim bytes As Integer

            Do
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use Decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.        
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then Exit Do
                
            Loop While bytes <> 0

            Return messageData.ToString()

        End Function

        Private Shared Sub DisplayUsage()

            Console.WriteLine("To start the client specify:")
            Console.WriteLine("clientSync machineName [serverName]")
            Environment.[Exit](1)

        End Sub

        Public Shared Function Main(args As String()) As Integer

            Dim serverCertificateName As String
            Dim machineName As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            ' 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 Then
                serverCertificateName = machineName
            Else
                serverCertificateName = args(1)
            End If

            SslTcpClient.RunClient(machineName, serverCertificateName)

            Return 0

        End Function

    End Class

End Namespace

Hinweise

SSL-Protokolle helfen, vertraulichkeits- und Integritätsprüfung für Nachrichten bereitzustellen, die mithilfe einer SslStream. Eine SSL-Verbindung, z. B. die von SslStreamihnen bereitgestellt wird, sollte beim Kommunizieren vertraulicher Informationen zwischen einem Client und einem Server verwendet werden. Die Verwendung einer SslStream Hilfe, um zu verhindern, dass alle Personen Informationen lesen und manipulieren, während sie im Netzwerk ausgeführt werden.

Eine SslStream Instanz sendet Daten mithilfe eines Datenstroms, den Sie beim Erstellen des SslStreamDatenstroms angeben. Wenn Sie diesen zugrunde liegenden Datenstrom angeben, können Sie angeben, ob das SslStream Schließen des zugrunde liegenden Datenstroms ebenfalls geschlossen wird. In der Regel wird die SslStream Klasse mit den TcpClient Klassen verwendet TcpListener . Die GetStream Methode bietet eine NetworkStream geeignete Verwendung mit der SslStream Klasse.

Nach dem Erstellen eines SslStreamServers und optional muss der Client authentifiziert werden. Der Server muss ein X509-Zertifikat bereitstellen, das den Nachweis seiner Identität festlegt und den Client auch anfordern kann. Die Authentifizierung muss ausgeführt werden, bevor Informationen mithilfe einer SslStream. Clients initiieren die Authentifizierung mithilfe der synchronen AuthenticateAsClient Methoden, die blockieren, bis die Authentifizierung abgeschlossen ist, oder die asynchronen BeginAuthenticateAsClient Methoden, die nicht blockieren, bis die Authentifizierung abgeschlossen ist. Server initiieren die Authentifizierung mithilfe der synchronen AuthenticateAsServer oder asynchronen BeginAuthenticateAsServer Methoden. Sowohl Client als auch Server müssen die Authentifizierung initiieren.

Die Authentifizierung wird vom SSPI-Kanalanbieter (Security Support Provider) behandelt. Der Client erhält eine Möglichkeit, die Überprüfung des Zertifikats des Servers zu steuern, indem er beim Erstellen eines RemoteCertificateValidationCallback SslStreamStellvertretungsstellvertretungs eingibt. Der Server kann auch die Überprüfung steuern, indem er eine RemoteCertificateValidationCallback Stellvertretung angibt. Die vom Stellvertretung verwiesene Methode umfasst das Zertifikat der Remotepartei und alle Fehler, die beim Überprüfen des Zertifikats aufgetreten sind. Beachten Sie, dass der Server eine Stellvertretung angibt, unabhängig davon, ob die Clientauthentifizierung vom Server angefordert wird. Wenn der Server die Clientauthentifizierung nicht anforderte, empfängt die Stellvertretungsmethode des Servers ein Nullzertifikat und ein leeres Array von Zertifikatfehlern.

Wenn der Server die Clientauthentifizierung erfordert, muss der Client mindestens ein Zertifikat für die Authentifizierung angeben. Wenn der Client über mehr als ein Zertifikat verfügt, kann der Client eine LocalCertificateSelectionCallback Stellvertretung bereitstellen, um das richtige Zertifikat für den Server auszuwählen. Die Zertifikate des Clients müssen sich im Zertifikatspeicher des aktuellen Benutzers befinden. Die Clientauthentifizierung über Zertifikate wird für das Ssl2 Protokoll (SSL Version 2) nicht unterstützt.

Wenn die Authentifizierung fehlschlägt, erhalten Sie eine AuthenticationException, und die SslStream ist nicht mehr nutzbar. Sie sollten dieses Objekt schließen und alle Verweise darauf entfernen, damit sie vom Müllsammler gesammelt werden kann.

Wenn der Authentifizierungsprozess, auch als SSL-Handshake bezeichnet, erfolgreich ist, wird die Identität des Servers (und optional, der Client) eingerichtet und kann SslStream vom Client und server verwendet werden, um Nachrichten zu austauschen. Vor dem Senden oder Empfangen von Informationen sollte der Client und der Server die von den SslStream Sicherheitsdiensten und -ebenen bereitgestellten Sicherheitsdienste und -ebenen überprüfen, um zu ermitteln, ob das Protokoll, algorithmen und Stärken ausgewählt wurden, ihre Anforderungen für Integrität und Vertraulichkeit erfüllen. Wenn die aktuellen Einstellungen nicht ausreichend sind, sollte der Datenstrom geschlossen werden. Sie können die sicherheitsrelevanten Dienste überprüfen, die von der Verwendung der SslStream IsEncrypted IsSigned Eigenschaften bereitgestellt werden. Die folgende Tabelle zeigt die Elemente, die die kryptografischen Einstellungen für die Authentifizierung, Verschlüsselung und Datensignatur melden.

Element	Member
Das Sicherheitsprotokoll, das zum Authentifizieren des Servers und optional zum Client verwendet wird.	Die SslProtocol Eigenschaft und die zugeordnete SslProtocols Enumeration.
Der Schlüsselaustauschalgorithmus.	Die KeyExchangeAlgorithm Eigenschaft und die zugeordnete ExchangeAlgorithmType Enumeration.
Der Nachrichtenintegritätsalgorithmus.	Die HashAlgorithm Eigenschaft und die zugeordnete HashAlgorithmType Enumeration.
Der Vertraulichkeitsalgorithmus der Nachricht.	Die CipherAlgorithm Eigenschaft und die zugeordnete CipherAlgorithmType Enumeration.
Die Stärken der ausgewählten Algorithmen.	Die KeyExchangeStrength, HashStrength, und CipherStrength Eigenschaften.

Nach einer erfolgreichen Authentifizierung können Sie Daten mithilfe der synchronen Write oder asynchronen BeginWrite Methoden senden. Sie können Daten mithilfe der synchronen Read oder asynchronen BeginRead Methoden empfangen.

Wenn Sie angegeben haben, dass der zugrunde liegende Stream geöffnet sein soll, sind Sie verantwortlich für das SslStream Schließen dieses Datenstroms, wenn Sie es verwenden.

Hinweis

Wenn die Anwendung, die das SslStream Objekt erstellt, mit den Anmeldeinformationen eines normalen Benutzers ausgeführt wird, kann die Anwendung nicht auf Zertifikate zugreifen, die im lokalen Computerspeicher installiert sind, es sei denn, die Berechtigung wurde dem Benutzer explizit erteilt.

SslStream geht davon aus, dass ein Timeout zusammen mit jedem anderen IOException , wenn man vom inneren Datenstrom ausgelöst wird, von seinem Anrufer als tödlich behandelt wird. Wiederverwenden einer Instanz, nachdem ein SslStream Timeout Müll zurückgibt. Eine Anwendung sollte Close eine SslStream Ausnahme in diesen Fällen auslösen.

Das .NET Framework 4.6 enthält ein neues Sicherheitsfeature, das unsichere Verschlüsselungs- und Hashalgorithmen für Verbindungen blockiert. Anwendungen, die TLS/SSL über APIs wie HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream usw. verwenden und auf .NET Framework 4.6 abzielen, erhalten standardmäßig das sicherere Verhalten.

Entwickler möchten dieses Verhalten möglicherweise deaktivieren, um die Interoperabilität mit ihren vorhandenen SSL3-Diensten ODER TLS w/RC4-Diensten beizubehalten. In diesem Artikel wird erläutert, wie Sie Ihren Code so ändern, dass das neue Verhalten deaktiviert ist.

Die .NET Framework 4.7 fügt neue Überladungen für die Methoden hinzu, die SslStreams authentifizieren, die keine TLS-Version angeben, sondern stattdessen die TLS-Version verwenden, die als Systemstandard in SCHANNEL definiert ist. Verwenden Sie diese Methoden in Ihrer App als Möglichkeit, die Standardeinstellungen später als TLS-Version bewährte Methoden im Laufe der Zeit zu ändern, ohne dass Sie Ihre App neu erstellen und erneut bereitstellen müssen.

Weitere Informationen finden Sie in den bewährten Methoden für Die Transport Layer Security (TLS) mit dem .NET Framework.

Konstruktoren

SslStream(Stream)	Initialisiert eine neue Instanz der SslStream-Klasse mit dem angegebenen Stream.
SslStream(Stream, Boolean)	Verwendet den angegebenen SslStream und das Schlussverhalten des Streams zum Initialisieren einer neuen Instanz der Stream-Klasse.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Verwendet den angegebenen SslStream, das angegebene Schlussverhalten des Streams und den angegebenen Zertifikatsvalidierungsdelegaten zum Initialisieren einer neuen Instanz der Stream-Klasse.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Verwendet den angegebenen SslStream, das Schlussverhalten des Streams, den Zertifikatsvalidierungsdelegaten und den Zertifikatsauswahldelegaten zum Initialisieren einer neuen Instanz der Stream-Klasse.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Initialisiert eine neue Instanz der SslStream-Klasse mit dem angegebenen Stream.

Eigenschaften

CanRead	Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream gelesen werden kann.
CanSeek	Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream durchsucht werden kann.
CanTimeout	Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream Timeouts unterstützt.
CanWrite	Ruft einen Boolean-Wert ab, der angibt, ob im zugrunde liegenden Stream geschrieben werden kann.
CheckCertRevocationStatus	Ruft einen Boolean-Wert ab, der angibt, ob die Zertifikatssperrliste während der Zertifikatsvalidierung überprüft wird.
CipherAlgorithm	Ruft einen Wert ab, der den von diesem SslStream verwendeten Sammelverschlüsselungsalgorithmus angibt.
CipherStrength	Ruft einen Wert ab, der die Stärke des von diesem SslStream verwendeten Verschlüsselungsverfahrensalgorithmus angibt.
HashAlgorithm	Ruft den für das Generieren von Message Authentication Codes (MAC – Nachrichtenauthentifizierungscode) verwendeten Algorithmus an.
HashStrength	Ruft einen Wert ab, der die Stärke des von dieser Instanz verwendeten Hashalgorithmus angibt.
InnerStream	Ruft den von diesem AuthenticatedStream verwendeten Stream zum Senden und Empfangen von Daten ab. (Geerbt von AuthenticatedStream)
IsAuthenticated	Ruft einen Boolean-Wert ab, der angibt, ob die Authentifizierung erfolgreich war.
IsEncrypted	Ruft einen Boolean-Wert ab, der angibt, ob dieser SslStream verschlüsselte Daten verwendet.
IsMutuallyAuthenticated	Ruft einen Boolean-Wert ab, der angibt, ob sowohl Client als auch Server authentifiziert wurden.
IsServer	Ruft einen Boolean-Wert ab, der angibt, ob die lokale, von diesem SslStream verwendete Seite der Verbindung als Server authentifiziert wurde.
IsSigned	Ruft einen Boolean-Wert ab, der angibt, ob die mit diesem Stream gesendeten Daten signiert sind.
KeyExchangeAlgorithm	Ruft den von diesem SslStream verwendeten Schlüsselaustauschalgorithmus ab.
KeyExchangeStrength	Ruft einen Wert ab, der die Stärke des von dieser Instanz verwendeten Schlüsselaustauschalgorithmus angibt.
LeaveInnerStreamOpen	Ruft ab, ob der zum Senden und Empfangen von Daten von diesem AuthenticatedStream verwendete Stream weiterhin geöffnet ist. (Geerbt von AuthenticatedStream)
Length	Ruft die Länge des zugrunde liegenden Streams ab.
LocalCertificate	Ruft das Zertifikat ab, mit dem der lokale Endpunkt authentifiziert wird.
NegotiatedApplicationProtocol	Das ausgehandelte Anwendungsprotokoll in TLS handshake.
NegotiatedCipherSuite	Ruft die Verschlüsselungssammlung ab, die für diese Verbindung ausgehandelt wurde.
Position	Ruft die aktuelle Position im zugrunde liegenden Stream ab oder legt diese fest.
ReadTimeout	Ruft die Zeitspanne (in Millisekunden) ab, in der ein Lesevorgang während des Wartens auf Daten blockiert wird, oder legt diese fest.
RemoteCertificate	Ruft das Zertifikat ab, mit dem der Remoteendpunkt authentifiziert wird.
SslProtocol	Ruft einen Wert ab, der das zum Authentifizieren dieser Verbindung verwendete Sicherheitsprotokoll angibt.
TargetHostName	Ruft den Namen des Servers ab, mit dem der Client versucht, eine Verbindung herzustellen. Dieser Name wird für die Serverzertifikatüberprüfung verwendet. Es kann sich um einen DNS-Namen oder eine IP-Adresse handeln.
TransportContext	Ruft das für die Authentifizierung mit erweitertem Schutz verwendete TransportContext ab.
WriteTimeout	Ruft die Zeitspanne ab, in der ein Schreibvorgang während des Wartens auf Daten blockiert wird, oder legt diese fest.

Methoden

AuthenticateAsClient(SslClientAuthenticationOptions)	Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet.
AuthenticateAsClient(String)	Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet.
AuthenticateAsClient(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.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Beim Authentifizierungsvorgang werden die angegebene Zertifikatsauflistung und das SSL-Protokoll verwendet.
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Der Authentifizierungsprozess verwendet Informationen, die in der `sslClientAuthenticationOptions`-Eigenschaftensammlung angegeben sind.
AuthenticateAsClientAsync(String)	Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet.
AuthenticateAsClientAsync(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.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Beim Authentifizierungsvorgang werden die angegebene Zertifikatsauflistung und das SSL-Protokoll verwendet.
AuthenticateAsServer(SslServerAuthenticationOptions)	Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Servers und optional auch des Clients mit dem angegebenen Zertifikat aufgerufen.
AuthenticateAsServer(X509Certificate)	Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Servers und optional auch des Clients mit dem angegebenen Zertifikat aufgerufen.
AuthenticateAsServer(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.
AuthenticateAsServer(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.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Wird von Servern zur Authentifizierung des Servers und optional auch des Clients aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang. Der Authentifizierungsprozess verwendet Informationen, die von `optionsCallback` zurückgegeben werden.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Wird von Servern zur Authentifizierung des Servers und optional auch des Clients aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang. Der Authentifizierungsprozess verwendet Informationen, die in der `sslClientAuthenticationOptions`-Eigenschaftensammlung angegeben sind.
AuthenticateAsServerAsync(X509Certificate)	Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Servers und optional auch des Clients mit dem angegebenen Zertifikat als asynchroner Vorgang aufgerufen.
AuthenticateAsServerAsync(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.
AuthenticateAsServerAsync(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.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Servers und optional auch des Clients zu starten.
BeginAuthenticateAsClient(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.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Servers und optional auch des Clients mit den angegebenen Zertifikaten und dem angegebenen Sicherheitsprotokoll zu starten.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	Wird bei einer Client-/Serververbindungen von Servern zum Starten eines asynchronen Vorgangs zur Authentifizierung des Clients und optional auch des Servers aufgerufen.
BeginAuthenticateAsServer(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.
BeginAuthenticateAsServer(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.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Lesevorgang, der Daten aus dem Stream liest und im angegebenen Array speichert.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Schreibvorgang, der Byte vom angegebenen Puffer in den Stream schreibt.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
Close()	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)
CopyTo(Stream)	Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. (Geerbt von Stream)
CopyTo(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)
CopyToAsync(Stream)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. (Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung eines angegebenen Abbruchtokens in einen anderen Stream. (Geerbt von Stream)
CopyToAsync(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)
CopyToAsync(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)
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
CreateWaitHandle()	Veraltet. Veraltet. Reserviert ein WaitHandle-Objekt. (Geerbt von Stream)
Dispose()	Gibt alle vom Stream verwendeten Ressourcen frei. (Geerbt von Stream)
Dispose(Boolean)	Gibt die von SslStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.
Dispose(Boolean)	Gibt die von AuthenticatedStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von AuthenticatedStream)
DisposeAsync()	Gibt die nicht verwalteten und verwalteten Ressourcen, die von SslStream verwendet werden, asynchron frei.
DisposeAsync()	Gibt die nicht verwalteten und verwalteten Ressourcen, die von AuthenticatedStream verwendet werden, asynchron frei. (Geerbt von AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)	Beendet einen ausstehenden asynchronen Serverauthentifizierungsvorgang, der mit einem vorhergehenden Aufruf von BeginAuthenticateAsClient gestartet wurde.
EndAuthenticateAsServer(IAsyncResult)	Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem vorherigen Aufruf von BeginAuthenticateAsClient gestartet wird.
EndRead(IAsyncResult)	Beendet einen asynchronen mit einem vorhergehenden Aufruf von BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) gestarteten Lesevorgang.
EndRead(IAsyncResult)	Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
EndWrite(IAsyncResult)	Beendet einen asynchronen mit einem vorhergehenden Aufruf von BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) gestarteten Schreibvorgang.
EndWrite(IAsyncResult)	Beendet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Finalize()	Gibt alle vom SslStream verwendeten Ressourcen frei.
Flush()	Veranlasst das Schreiben aller gepufferten Daten in das zugrunde liegende Gerät.
FlushAsync()	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)
FlushAsync(CancellationToken)	Schreibt asynchron alle gepufferten Daten auf das zugrunde liegende Gerät.
FlushAsync(CancellationToken)	Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. (Geerbt von Stream)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Verhandelt das Clientzertifikat für die authentifizierte Verbindung.
ObjectInvariant()	Veraltet. Bietet Unterstützung für einen Contract. (Geerbt von Stream)
Read(Byte[], Int32, Int32)	Liest Daten aus diesem Stream und speichert sie im angegebenen Array.
Read(Span<Byte>)	Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAsync(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)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest Daten asynchron aus diesem Datenstrom und speichert sie im angegebenen Bereich eines Bytearrays.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Geerbt von Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Liest Daten asynchron aus diesem Datenstrom und speichert sie im angegebenen Speicherbereich.
ReadAsync(Memory<Byte>, CancellationToken)	Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Geerbt von Stream)
ReadByte()	Liest ein Byte aus SslStream und erhöht die Position im Datenstrom um ein Byte, oder gibt „-1“ zurück, wenn das Ende des Datenstroms erreicht ist.
ReadByte()	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)
Seek(Int64, SeekOrigin)	Löst eine NotSupportedException aus.
SetLength(Int64)	Legt die Länge des zugrunde liegenden Streams fest.
ShutdownAsync()	Fährt diesen SslStream herunter.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
Write(Byte[])	Schreibt die angegebenen Daten in diesen Stream.
Write(Byte[], Int32, Int32)	Schreiben Sie die angegebene Anzahl von Byte mit dem angegebenen Puffer und dem angegebenen Offset in den zugrunde liegenden Stream.
Write(ReadOnlySpan<Byte>)	Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. (Geerbt von Stream)
WriteAsync(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)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreibt Daten aus dem festgelegten Bereich eines Bytearrays asynchron in den zugrunde liegenden Datenstrom.
WriteAsync(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)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreibt Daten asynchron in den zugrunde liegenden Datenstrom eines schreibgeschützten Bytespeicherbereichs.
WriteAsync(ReadOnlyMemory<Byte>, 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)
WriteByte(Byte)	Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. (Geerbt von Stream)

Erweiterungsmethoden

ConfigureAwait(IAsyncDisposable, Boolean)

Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden.

Gilt für